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 #ifndef CONFIG_WIN 117 /** 118 * cdp_flow_pool_map() - Create flow pool for vdev 119 * @soc - data path soc handle 120 * @pdev 121 * @vdev_id - vdev_id corresponding to vdev start 122 * 123 * Create per vdev flow pool. 124 * 125 * return none 126 */ 127 static inline QDF_STATUS cdp_flow_pool_map(ol_txrx_soc_handle soc, 128 struct cdp_pdev *pdev, uint8_t vdev_id) 129 { 130 if (!soc || !soc->ops) { 131 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 132 "%s: Invalid Instance:", __func__); 133 QDF_BUG(0); 134 return QDF_STATUS_E_INVAL; 135 } 136 137 if (!soc->ops->flowctl_ops || 138 !soc->ops->flowctl_ops->flow_pool_map_handler) 139 return QDF_STATUS_E_INVAL; 140 141 return soc->ops->flowctl_ops->flow_pool_map_handler(soc, pdev, vdev_id); 142 } 143 144 /** 145 * cdp_flow_pool_unmap() - Delete flow pool 146 * @soc - data path soc handle 147 * @pdev 148 * @vdev_id - vdev_id corresponding to vdev start 149 * 150 * Delete flow pool 151 * 152 * return none 153 */ 154 static inline void cdp_flow_pool_unmap(ol_txrx_soc_handle soc, 155 struct cdp_pdev *pdev, uint8_t vdev_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; 162 } 163 164 if (!soc->ops->flowctl_ops || 165 !soc->ops->flowctl_ops->flow_pool_unmap_handler) 166 return; 167 168 return soc->ops->flowctl_ops->flow_pool_unmap_handler(soc, pdev, 169 vdev_id); 170 } 171 #endif 172 173 static inline void 174 cdp_vdev_detach(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 175 ol_txrx_vdev_delete_cb callback, void *cb_context) 176 { 177 if (!soc || !soc->ops) { 178 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 179 "%s: Invalid Instance:", __func__); 180 QDF_BUG(0); 181 return; 182 } 183 184 if (!soc->ops->cmn_drv_ops || 185 !soc->ops->cmn_drv_ops->txrx_vdev_detach) 186 return; 187 188 soc->ops->cmn_drv_ops->txrx_vdev_detach(vdev, 189 callback, cb_context); 190 } 191 192 static inline int 193 cdp_pdev_attach_target(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 194 { 195 if (!soc || !soc->ops) { 196 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 197 "%s: Invalid Instance:", __func__); 198 QDF_BUG(0); 199 return 0; 200 } 201 202 if (!soc->ops->cmn_drv_ops || 203 !soc->ops->cmn_drv_ops->txrx_pdev_attach_target) 204 return 0; 205 206 return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(pdev); 207 } 208 209 static inline struct cdp_pdev *cdp_pdev_attach 210 (ol_txrx_soc_handle soc, struct cdp_cfg *ctrl_pdev, 211 HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id) 212 { 213 if (!soc || !soc->ops) { 214 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 215 "%s: Invalid Instance:", __func__); 216 QDF_BUG(0); 217 return NULL; 218 } 219 220 if (!soc->ops->cmn_drv_ops || 221 !soc->ops->cmn_drv_ops->txrx_pdev_attach) 222 return NULL; 223 224 return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, ctrl_pdev, 225 htc_pdev, osdev, pdev_id); 226 } 227 228 static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, 229 struct cdp_pdev *pdev) 230 { 231 if (!soc || !soc->ops) { 232 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 233 "%s: Invalid Instance:", __func__); 234 QDF_BUG(0); 235 return 0; 236 } 237 238 if (!soc->ops->cmn_drv_ops || 239 !soc->ops->cmn_drv_ops->txrx_pdev_post_attach) 240 return 0; 241 242 return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(pdev); 243 } 244 245 static inline void 246 cdp_pdev_pre_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 247 { 248 if (!soc || !soc->ops) { 249 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 250 "%s: Invalid Instance:", __func__); 251 QDF_BUG(0); 252 return; 253 } 254 255 if (!soc->ops->cmn_drv_ops || 256 !soc->ops->cmn_drv_ops->txrx_pdev_pre_detach) 257 return; 258 259 soc->ops->cmn_drv_ops->txrx_pdev_pre_detach(pdev, force); 260 } 261 262 static inline void 263 cdp_pdev_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 264 { 265 if (!soc || !soc->ops) { 266 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 267 "%s: Invalid Instance:", __func__); 268 QDF_BUG(0); 269 return; 270 } 271 272 if (!soc->ops->cmn_drv_ops || 273 !soc->ops->cmn_drv_ops->txrx_pdev_detach) 274 return; 275 276 soc->ops->cmn_drv_ops->txrx_pdev_detach(pdev, force); 277 } 278 279 static inline void *cdp_peer_create 280 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 281 uint8_t *peer_mac_addr) 282 { 283 if (!soc || !soc->ops) { 284 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 285 "%s: Invalid Instance:", __func__); 286 QDF_BUG(0); 287 return NULL; 288 } 289 290 if (!soc->ops->cmn_drv_ops || 291 !soc->ops->cmn_drv_ops->txrx_peer_create) 292 return NULL; 293 294 return soc->ops->cmn_drv_ops->txrx_peer_create(vdev, 295 peer_mac_addr); 296 } 297 298 static inline void cdp_peer_setup 299 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 300 { 301 if (!soc || !soc->ops) { 302 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 303 "%s: Invalid Instance:", __func__); 304 QDF_BUG(0); 305 return; 306 } 307 308 if (!soc->ops->cmn_drv_ops || 309 !soc->ops->cmn_drv_ops->txrx_peer_setup) 310 return; 311 312 soc->ops->cmn_drv_ops->txrx_peer_setup(vdev, 313 peer); 314 } 315 316 static inline void *cdp_peer_ast_hash_find 317 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr) 318 { 319 if (!soc || !soc->ops) { 320 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 321 "%s: Invalid Instance:", __func__); 322 QDF_BUG(0); 323 return NULL; 324 } 325 326 if (!soc->ops->cmn_drv_ops || 327 !soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find) 328 return NULL; 329 330 return soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find(soc, 331 ast_mac_addr); 332 } 333 334 static inline int cdp_peer_add_ast 335 (ol_txrx_soc_handle soc, struct cdp_peer *peer_handle, 336 uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, uint32_t flags) 337 { 338 if (!soc || !soc->ops) { 339 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 340 "%s: Invalid Instance:", __func__); 341 QDF_BUG(0); 342 return 0; 343 } 344 345 if (!soc->ops->cmn_drv_ops || 346 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 347 return 0; 348 349 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 350 peer_handle, 351 mac_addr, 352 type, 353 flags); 354 } 355 356 static inline void cdp_peer_reset_ast 357 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr) 358 { 359 360 if (!soc || !soc->ops) { 361 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 362 "%s: Invalid Instance:", __func__); 363 QDF_BUG(0); 364 return; 365 } 366 if (!soc->ops->cmn_drv_ops || 367 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast) 368 return; 369 370 soc->ops->cmn_drv_ops->txrx_peer_reset_ast(soc, wds_macaddr); 371 } 372 373 static inline void cdp_peer_reset_ast_table 374 (ol_txrx_soc_handle soc) 375 { 376 if (!soc || !soc->ops) { 377 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 378 "%s: Invalid Instance:", __func__); 379 QDF_BUG(0); 380 return; 381 } 382 383 if (!soc->ops->cmn_drv_ops || 384 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table) 385 return; 386 387 soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table(soc); 388 } 389 390 static inline void cdp_peer_flush_ast_table 391 (ol_txrx_soc_handle soc) 392 { 393 if (!soc || !soc->ops) { 394 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 395 "%s: Invalid Instance:", __func__); 396 QDF_BUG(0); 397 return; 398 } 399 400 if (!soc->ops->cmn_drv_ops || 401 !soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table) 402 return; 403 404 soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table(soc); 405 } 406 407 static inline int cdp_peer_update_ast 408 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, 409 struct cdp_peer *peer_handle, uint32_t flags) 410 { 411 if (!soc || !soc->ops) { 412 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 413 "%s: Invalid Instance:", __func__); 414 QDF_BUG(0); 415 return 0; 416 } 417 418 if (!soc->ops->cmn_drv_ops || 419 !soc->ops->cmn_drv_ops->txrx_peer_update_ast) 420 return 0; 421 422 423 return soc->ops->cmn_drv_ops->txrx_peer_update_ast(soc, 424 peer_handle, 425 wds_macaddr, 426 flags); 427 } 428 429 static inline void cdp_peer_del_ast 430 (ol_txrx_soc_handle soc, void *ast_handle) 431 { 432 if (!soc || !soc->ops) { 433 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 434 "%s: Invalid Instance:", __func__); 435 QDF_BUG(0); 436 return; 437 } 438 439 if (!soc->ops->cmn_drv_ops || 440 !soc->ops->cmn_drv_ops->txrx_peer_del_ast) 441 return; 442 443 soc->ops->cmn_drv_ops->txrx_peer_del_ast(soc, ast_handle); 444 } 445 446 447 static inline uint8_t cdp_peer_ast_get_pdev_id 448 (ol_txrx_soc_handle soc, void *ast_handle) 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 0xff; 455 } 456 457 if (!soc->ops->cmn_drv_ops || 458 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id) 459 return 0xff; 460 461 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id(soc, 462 ast_handle); 463 } 464 465 static inline uint8_t cdp_peer_ast_get_next_hop 466 (ol_txrx_soc_handle soc, void *ast_handle) 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 0xff; 473 } 474 475 if (!soc->ops->cmn_drv_ops || 476 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop) 477 return 0xff; 478 479 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop(soc, 480 ast_handle); 481 } 482 483 static inline void cdp_peer_ast_set_type 484 (ol_txrx_soc_handle soc, void *ast_handle, 485 enum cdp_txrx_ast_entry_type type) 486 { 487 if (!soc || !soc->ops) { 488 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 489 "%s: Invalid Instance:", __func__); 490 QDF_BUG(0); 491 return; 492 } 493 494 if (!soc->ops->cmn_drv_ops || 495 !soc->ops->cmn_drv_ops->txrx_peer_ast_set_type) 496 return; 497 498 soc->ops->cmn_drv_ops->txrx_peer_ast_set_type(soc, ast_handle, type); 499 } 500 501 static inline void cdp_peer_teardown 502 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 503 { 504 if (!soc || !soc->ops) { 505 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 506 "%s: Invalid Instance:", __func__); 507 QDF_BUG(0); 508 return; 509 } 510 511 if (!soc->ops->cmn_drv_ops || 512 !soc->ops->cmn_drv_ops->txrx_peer_teardown) 513 return; 514 515 soc->ops->cmn_drv_ops->txrx_peer_teardown(vdev, peer); 516 } 517 518 static inline void 519 cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 520 { 521 if (!soc || !soc->ops) { 522 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 523 "%s: Invalid Instance:", __func__); 524 QDF_BUG(0); 525 return; 526 } 527 528 if (!soc->ops->cmn_drv_ops || 529 !soc->ops->cmn_drv_ops->txrx_peer_delete) 530 return; 531 532 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 533 } 534 535 static inline int 536 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 537 uint8_t smart_monitor) 538 { 539 if (!soc || !soc->ops) { 540 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 541 "%s: Invalid Instance:", __func__); 542 QDF_BUG(0); 543 return 0; 544 } 545 546 if (!soc->ops->cmn_drv_ops || 547 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 548 return 0; 549 550 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 551 smart_monitor); 552 } 553 554 static inline void 555 cdp_set_curchan(ol_txrx_soc_handle soc, 556 struct cdp_pdev *pdev, 557 uint32_t chan_mhz) 558 { 559 if (!soc || !soc->ops) { 560 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 561 "%s: Invalid Instance:", __func__); 562 QDF_BUG(0); 563 return; 564 } 565 566 if (!soc->ops->cmn_drv_ops || 567 !soc->ops->cmn_drv_ops->txrx_set_curchan) 568 return; 569 570 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 571 } 572 573 static inline void 574 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 575 void *filter, uint32_t num) 576 { 577 if (!soc || !soc->ops) { 578 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 579 "%s: Invalid Instance:", __func__); 580 QDF_BUG(0); 581 return; 582 } 583 584 if (!soc->ops->cmn_drv_ops || 585 !soc->ops->cmn_drv_ops->txrx_set_privacy_filters) 586 return; 587 588 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 589 filter, num); 590 } 591 592 static inline int 593 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 594 struct cdp_monitor_filter *filter_val) 595 { 596 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 597 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 598 filter_val); 599 return 0; 600 } 601 602 603 /****************************************************************************** 604 * Data Interface (B Interface) 605 *****************************************************************************/ 606 static inline void 607 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 608 void *osif_vdev, struct ol_txrx_ops *txrx_ops) 609 { 610 if (!soc || !soc->ops) { 611 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 612 "%s: Invalid Instance:", __func__); 613 QDF_BUG(0); 614 return; 615 } 616 617 if (!soc->ops->cmn_drv_ops || 618 !soc->ops->cmn_drv_ops->txrx_vdev_register) 619 return; 620 621 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 622 osif_vdev, txrx_ops); 623 } 624 625 static inline int 626 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 627 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 628 { 629 if (!soc || !soc->ops) { 630 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 631 "%s: Invalid Instance:", __func__); 632 QDF_BUG(0); 633 return 0; 634 } 635 636 if (!soc->ops->cmn_drv_ops || 637 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 638 return 0; 639 640 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 641 tx_mgmt_frm, type); 642 } 643 644 static inline int 645 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 646 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 647 uint8_t use_6mbps, uint16_t chanfreq) 648 { 649 if (!soc || !soc->ops) { 650 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 651 "%s: Invalid Instance:", __func__); 652 QDF_BUG(0); 653 return 0; 654 } 655 656 if (!soc->ops->cmn_drv_ops || 657 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 658 return 0; 659 660 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 661 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 662 } 663 664 665 static inline void 666 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 667 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 668 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 669 { 670 if (!soc || !soc->ops) { 671 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 672 "%s: Invalid Instance:", __func__); 673 QDF_BUG(0); 674 return; 675 } 676 677 if (!soc->ops->cmn_drv_ops || 678 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 679 return; 680 681 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 682 (pdev, type, download_cb, ota_ack_cb, ctxt); 683 } 684 685 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 686 struct cdp_pdev *pdev) 687 { 688 if (!soc || !soc->ops) { 689 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 690 "%s: Invalid Instance:", __func__); 691 QDF_BUG(0); 692 return 0; 693 } 694 695 if (!soc->ops->cmn_drv_ops || 696 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 697 return 0; 698 699 700 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 701 } 702 703 static inline void 704 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 705 ol_txrx_data_tx_cb callback, void *ctxt) 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_data_tx_cb_set) 716 return; 717 718 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 719 callback, ctxt); 720 } 721 722 /****************************************************************************** 723 * Statistics and Debugging Interface (C Inteface) 724 *****************************************************************************/ 725 /** 726 * External Device physical address types 727 * 728 * Currently, both MAC and IPA uController use the same size addresses 729 * and descriptors are exchanged between these two depending on the mode. 730 * 731 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 732 * operations. However, external device physical address sizes 733 * may be different from host-specific physical address sizes. 734 * This calls for the following definitions for target devices 735 * (MAC, IPA uc). 736 */ 737 #if HTT_PADDR64 738 typedef uint64_t target_paddr_t; 739 #else 740 typedef uint32_t target_paddr_t; 741 #endif /*HTT_PADDR64 */ 742 743 static inline int 744 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 745 int max_subfrms_ampdu, 746 int max_subfrms_amsdu) 747 { 748 if (!soc || !soc->ops) { 749 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 750 "%s: Invalid Instance:", __func__); 751 QDF_BUG(0); 752 return 0; 753 } 754 755 if (!soc->ops->cmn_drv_ops || 756 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 757 return 0; 758 759 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 760 max_subfrms_ampdu, max_subfrms_amsdu); 761 } 762 763 static inline int 764 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 765 struct ol_txrx_stats_req *req, bool per_vdev, 766 bool response_expected) 767 { 768 if (!soc || !soc->ops) { 769 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 770 "%s: Invalid Instance:", __func__); 771 QDF_BUG(0); 772 return 0; 773 } 774 775 if (!soc->ops->cmn_drv_ops || 776 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 777 return 0; 778 779 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 780 per_vdev, response_expected); 781 } 782 783 static inline int 784 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 785 { 786 if (!soc || !soc->ops) { 787 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 788 "%s: Invalid Instance:", __func__); 789 QDF_BUG(0); 790 return 0; 791 } 792 793 if (!soc->ops->cmn_drv_ops || 794 !soc->ops->cmn_drv_ops->txrx_debug) 795 return 0; 796 797 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 798 } 799 800 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 801 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 802 { 803 if (!soc || !soc->ops) { 804 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 805 "%s: Invalid Instance:", __func__); 806 QDF_BUG(0); 807 return; 808 } 809 810 if (!soc->ops->cmn_drv_ops || 811 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 812 return; 813 814 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 815 cfg_stats_type, cfg_val); 816 } 817 818 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 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; 825 } 826 827 if (!soc->ops->cmn_drv_ops || 828 !soc->ops->cmn_drv_ops->txrx_print_level_set) 829 return; 830 831 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 832 } 833 834 static inline uint8_t * 835 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 836 { 837 if (!soc || !soc->ops) { 838 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 839 "%s: Invalid Instance:", __func__); 840 QDF_BUG(0); 841 return NULL; 842 } 843 844 if (!soc->ops->cmn_drv_ops || 845 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 846 return NULL; 847 848 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 849 850 } 851 852 /** 853 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 854 * vdev 855 * @vdev: vdev handle 856 * 857 * Return: Handle to struct qdf_mac_addr 858 */ 859 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 860 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 861 { 862 if (!soc || !soc->ops) { 863 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 864 "%s: Invalid Instance:", __func__); 865 QDF_BUG(0); 866 return NULL; 867 } 868 869 if (!soc->ops->cmn_drv_ops || 870 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 871 return NULL; 872 873 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 874 (vdev); 875 876 } 877 878 /** 879 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 880 * @vdev: vdev handle 881 * 882 * Return: Handle to pdev 883 */ 884 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 885 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 886 { 887 if (!soc || !soc->ops) { 888 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 889 "%s: Invalid Instance:", __func__); 890 QDF_BUG(0); 891 return NULL; 892 } 893 894 if (!soc->ops->cmn_drv_ops || 895 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 896 return NULL; 897 898 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 899 } 900 901 /** 902 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 903 * @vdev: vdev handle 904 * 905 * Return: Handle to control pdev 906 */ 907 static inline struct cdp_cfg * 908 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 909 { 910 if (!soc || !soc->ops) { 911 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 912 "%s: Invalid Instance:", __func__); 913 QDF_BUG(0); 914 return NULL; 915 } 916 917 if (!soc->ops->cmn_drv_ops || 918 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 919 return NULL; 920 921 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 922 (vdev); 923 } 924 925 static inline struct cdp_vdev * 926 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 927 uint8_t vdev_id) 928 { 929 if (!soc || !soc->ops) { 930 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 931 "%s: Invalid Instance:", __func__); 932 QDF_BUG(0); 933 return NULL; 934 } 935 936 if (!soc->ops->cmn_drv_ops || 937 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 938 return NULL; 939 940 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 941 (pdev, vdev_id); 942 } 943 944 static inline void 945 cdp_soc_detach(ol_txrx_soc_handle soc) 946 { 947 if (!soc || !soc->ops) { 948 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 949 "%s: Invalid Instance:", __func__); 950 QDF_BUG(0); 951 return; 952 } 953 954 if (!soc->ops->cmn_drv_ops || 955 !soc->ops->cmn_drv_ops->txrx_soc_detach) 956 return; 957 958 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 959 } 960 961 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 962 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 963 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 964 { 965 if (!soc || !soc->ops) { 966 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 967 "%s: Invalid Instance:", __func__); 968 QDF_BUG(0); 969 return 0; 970 } 971 972 if (!soc->ops->cmn_drv_ops || 973 !soc->ops->cmn_drv_ops->addba_requestprocess) 974 return 0; 975 976 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 977 dialogtoken, tid, batimeout, buffersize, startseqnum); 978 } 979 980 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 981 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 982 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 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; 989 } 990 991 if (!soc->ops->cmn_drv_ops || 992 !soc->ops->cmn_drv_ops->addba_responsesetup) 993 return; 994 995 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 996 dialogtoken, statuscode, buffersize, batimeout); 997 } 998 999 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 1000 void *peer_handle, int tid, uint16_t reasoncode) 1001 { 1002 if (!soc || !soc->ops) { 1003 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1004 "%s: Invalid Instance:", __func__); 1005 QDF_BUG(0); 1006 return 0; 1007 } 1008 1009 if (!soc->ops->cmn_drv_ops || 1010 !soc->ops->cmn_drv_ops->delba_process) 1011 return 0; 1012 1013 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 1014 tid, reasoncode); 1015 } 1016 1017 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1018 void *peer_handle, int tid, uint16_t statuscode) 1019 { 1020 if (!soc || !soc->ops) { 1021 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1022 "%s: Invalid Instance:", __func__); 1023 QDF_BUG(0); 1024 return; 1025 } 1026 1027 if (!soc->ops->cmn_drv_ops || 1028 !soc->ops->cmn_drv_ops->set_addba_response) 1029 return; 1030 1031 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1032 } 1033 1034 /** 1035 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1036 * mac address 1037 * @soc: SOC handle 1038 * @peer_id: peer id of the peer for which mac_address is required 1039 * @mac_addr: reference to mac address 1040 * 1041 * reutm: vdev_id of the vap 1042 */ 1043 static inline uint8_t 1044 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1045 uint8_t *mac_addr) 1046 { 1047 if (!soc || !soc->ops) { 1048 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1049 "%s: Invalid Instance:", __func__); 1050 QDF_BUG(0); 1051 return CDP_INVALID_VDEV_ID; 1052 } 1053 1054 if (!soc->ops->cmn_drv_ops || 1055 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1056 return CDP_INVALID_VDEV_ID; 1057 1058 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1059 peer_id, mac_addr); 1060 } 1061 1062 /** 1063 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1064 * @vdev: vdev handle 1065 * @map_id: id of the tid map 1066 * 1067 * Return: void 1068 */ 1069 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1070 struct cdp_vdev *vdev, uint8_t map_id) 1071 { 1072 if (!soc || !soc->ops) { 1073 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1074 "%s: Invalid Instance:", __func__); 1075 QDF_BUG(0); 1076 return; 1077 } 1078 1079 if (!soc->ops->cmn_drv_ops || 1080 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1081 return; 1082 1083 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1084 map_id); 1085 } 1086 1087 /** 1088 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1089 * @pdev: pdev handle 1090 * @map_id: id of the tid map 1091 * @tos: index value in map that needs to be changed 1092 * @tid: tid value passed by user 1093 * 1094 * Return: void 1095 */ 1096 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1097 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 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; 1104 } 1105 1106 if (!soc->ops->cmn_drv_ops || 1107 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1108 return; 1109 1110 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1111 map_id, tos, tid); 1112 } 1113 1114 /** 1115 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1116 * 1117 * Return: None 1118 */ 1119 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1120 { 1121 if (!soc || !soc->ops) { 1122 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1123 "%s: Invalid Instance:", __func__); 1124 QDF_BUG(0); 1125 return; 1126 } 1127 1128 if (!soc->ops->cmn_drv_ops || 1129 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1130 return; 1131 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1132 } 1133 1134 /** 1135 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1136 * @soc: soc handle 1137 * @vdev: virtual device 1138 * @req: stats request container 1139 * 1140 * return: status 1141 */ 1142 static inline 1143 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1144 struct cdp_txrx_stats_req *req) 1145 { 1146 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1147 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1148 "%s: Invalid Instance:", __func__); 1149 QDF_ASSERT(0); 1150 return 0; 1151 } 1152 1153 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1154 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1155 1156 return 0; 1157 } 1158 1159 /** 1160 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1161 * @soc: soc handle 1162 */ 1163 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1164 { 1165 if (!soc || !soc->ops) { 1166 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1167 "%s: Invalid Instance:", __func__); 1168 QDF_BUG(0); 1169 return 0; 1170 } 1171 1172 if (!soc->ops->cmn_drv_ops || 1173 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1174 return 0; 1175 1176 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1177 } 1178 1179 /** 1180 * cdp_txrx_intr_detach(): function to detach interrupt 1181 * @soc: soc handle 1182 */ 1183 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1184 { 1185 if (!soc || !soc->ops) { 1186 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1187 "%s: Invalid Instance:", __func__); 1188 QDF_BUG(0); 1189 return; 1190 } 1191 1192 if (!soc->ops->cmn_drv_ops || 1193 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1194 return; 1195 1196 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1197 } 1198 1199 /** 1200 * cdp_display_stats(): function to map to dump stats 1201 * @soc: soc handle 1202 * @value: statistics option 1203 */ 1204 static inline QDF_STATUS 1205 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1206 enum qdf_stats_verbosity_level level) 1207 { 1208 if (!soc || !soc->ops) { 1209 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1210 "%s: Invalid Instance:", __func__); 1211 QDF_BUG(0); 1212 return 0; 1213 } 1214 1215 if (!soc->ops->cmn_drv_ops || 1216 !soc->ops->cmn_drv_ops->display_stats) 1217 return 0; 1218 1219 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1220 } 1221 1222 1223 /** 1224 * cdp_set_pn_check(): function to set pn check 1225 * @soc: soc handle 1226 * @sec_type: security type 1227 * #rx_pn: receive pn 1228 */ 1229 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1230 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1231 { 1232 if (!soc || !soc->ops) { 1233 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1234 "%s: Invalid Instance:", __func__); 1235 QDF_BUG(0); 1236 return 0; 1237 } 1238 1239 if (!soc->ops->cmn_drv_ops || 1240 !soc->ops->cmn_drv_ops->set_pn_check) 1241 return 0; 1242 1243 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1244 sec_type, rx_pn); 1245 return 0; 1246 } 1247 1248 /** 1249 * cdp_update_config_parameters(): function to propagate configuration 1250 * parameters to datapath 1251 * @soc: opaque soc handle 1252 * @cfg: configuration handle 1253 * 1254 * Return: status: 0 - Success, non-zero: Failure 1255 */ 1256 static inline 1257 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1258 struct cdp_config_params *cfg) 1259 { 1260 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1261 1262 if (!soc || !soc->ops) { 1263 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1264 "%s: Invalid Instance:", __func__); 1265 QDF_BUG(0); 1266 return 0; 1267 } 1268 1269 if (!soc->ops->cmn_drv_ops || 1270 !soc->ops->cmn_drv_ops->update_config_parameters) 1271 return QDF_STATUS_SUCCESS; 1272 1273 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1274 cfg); 1275 } 1276 1277 /** 1278 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1279 * @soc: opaque soc handle 1280 * @pdev: data path pdev handle 1281 * 1282 * Return: opaque dp handle 1283 */ 1284 static inline void * 1285 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1286 { 1287 if (!soc || !soc->ops) { 1288 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1289 "%s: Invalid Instance:", __func__); 1290 QDF_BUG(0); 1291 return 0; 1292 } 1293 1294 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1295 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1296 1297 return 0; 1298 } 1299 1300 /** 1301 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1302 * @soc: opaque soc handle 1303 * @pdev: data path pdev handle 1304 * @dp_hdl: opaque pointer for dp_txrx_handle 1305 * 1306 * Return: void 1307 */ 1308 static inline void 1309 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1310 { 1311 if (!soc || !soc->ops) { 1312 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1313 "%s: Invalid Instance:", __func__); 1314 QDF_BUG(0); 1315 return; 1316 } 1317 1318 if (!soc->ops->cmn_drv_ops || 1319 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1320 return; 1321 1322 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1323 } 1324 1325 /* 1326 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1327 * @soc: opaque soc handle 1328 * 1329 * Return: opaque extended dp handle 1330 */ 1331 static inline void * 1332 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1333 { 1334 if (!soc || !soc->ops) { 1335 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1336 "%s: Invalid Instance:", __func__); 1337 QDF_BUG(0); 1338 return NULL; 1339 } 1340 1341 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1342 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1343 (struct cdp_soc *) soc); 1344 1345 return NULL; 1346 } 1347 1348 /** 1349 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1350 * @soc: opaque soc handle 1351 * @dp_hdl: opaque pointer for dp_txrx_handle 1352 * 1353 * Return: void 1354 */ 1355 static inline void 1356 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1357 { 1358 if (!soc || !soc->ops) { 1359 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1360 "%s: Invalid Instance:", __func__); 1361 QDF_BUG(0); 1362 return; 1363 } 1364 1365 if (!soc->ops->cmn_drv_ops || 1366 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1367 return; 1368 1369 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1370 dp_handle); 1371 } 1372 1373 /** 1374 * cdp_tx_send() - enqueue frame for transmission 1375 * @soc: soc opaque handle 1376 * @vdev: VAP device 1377 * @nbuf: nbuf to be enqueued 1378 * 1379 * This API is used by Extended Datapath modules to enqueue frame for 1380 * transmission 1381 * 1382 * Return: void 1383 */ 1384 static inline void 1385 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1386 { 1387 if (!soc || !soc->ops) { 1388 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1389 "%s: Invalid Instance:", __func__); 1390 QDF_BUG(0); 1391 return; 1392 } 1393 1394 if (!soc->ops->cmn_drv_ops || 1395 !soc->ops->cmn_drv_ops->tx_send) 1396 return; 1397 1398 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1399 } 1400 1401 /* 1402 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1403 * @soc: opaque soc handle 1404 * @pdev: data path pdev handle 1405 * 1406 * Return: pdev_id 1407 */ 1408 static inline 1409 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1410 struct cdp_pdev *pdev) 1411 { 1412 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1413 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1414 return 0; 1415 } 1416 1417 /** 1418 * cdp_set_nac() - set nac 1419 * @soc: opaque soc handle 1420 * @peer: data path peer handle 1421 * 1422 */ 1423 static inline 1424 void cdp_set_nac(ol_txrx_soc_handle soc, 1425 struct cdp_peer *peer) 1426 { 1427 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1428 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1429 } 1430 1431 /** 1432 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1433 * @soc: opaque soc handle 1434 * @pdev: data path pdev handle 1435 * @val: value of pdev_tx_capture 1436 * 1437 * Return: void 1438 */ 1439 static inline 1440 void cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1441 struct cdp_pdev *pdev, int val) 1442 { 1443 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1444 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1445 val); 1446 1447 } 1448 1449 /** 1450 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1451 * @soc: opaque soc handle 1452 * @pdev: data path pdev handle 1453 * @peer_id: data path peer id 1454 * @peer_mac: peer_mac 1455 * 1456 * Return: void 1457 */ 1458 static inline 1459 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1460 struct cdp_pdev *pdev_handle, 1461 uint32_t peer_id, uint8_t *peer_mac) 1462 { 1463 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1464 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1465 pdev_handle, peer_id, peer_mac); 1466 } 1467 1468 /** 1469 * cdp_vdev_tx_lock() - acquire lock 1470 * @soc: opaque soc handle 1471 * @vdev: data path vdev handle 1472 * 1473 * Return: void 1474 */ 1475 static inline 1476 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1477 struct cdp_vdev *vdev) 1478 { 1479 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1480 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1481 } 1482 1483 /** 1484 * cdp_vdev_tx_unlock() - release lock 1485 * @soc: opaque soc handle 1486 * @vdev: data path vdev handle 1487 * 1488 * Return: void 1489 */ 1490 static inline 1491 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1492 struct cdp_vdev *vdev) 1493 { 1494 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1495 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1496 } 1497 1498 /** 1499 * cdp_ath_getstats() - get updated athstats 1500 * @soc: opaque soc handle 1501 * @pdev: data path pdev handle 1502 * @net_device_stats: interface stats 1503 * @rtnl_link_stats64: device statistics structure 1504 * 1505 * Return: void 1506 */ 1507 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1508 struct cdp_pdev *pdev, struct cdp_dev_stats *stats) 1509 { 1510 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1511 soc->ops->cmn_drv_ops->txrx_ath_getstats(pdev, stats); 1512 } 1513 1514 /** 1515 * cdp_set_gid_flag() - set groupid flag 1516 * @soc: opaque soc handle 1517 * @pdev: data path pdev handle 1518 * @mem_status: member status from grp management frame 1519 * @user_position: user position from grp management frame 1520 * 1521 * Return: void 1522 */ 1523 static inline 1524 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1525 struct cdp_pdev *pdev, u_int8_t *mem_status, 1526 u_int8_t *user_position) 1527 { 1528 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1529 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1530 } 1531 1532 /** 1533 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1534 * @soc: opaque soc handle 1535 * @pdev: data path pdev handle 1536 * 1537 */ 1538 static inline 1539 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1540 struct cdp_pdev *pdev) 1541 { 1542 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1543 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1544 return 0; 1545 } 1546 1547 /** 1548 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1549 * @soc: opaque soc handle 1550 * @ni: associated node 1551 * @force: number of frame in SW queue 1552 * Return: void 1553 */ 1554 static inline 1555 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 1556 void *ni, int force) 1557 { 1558 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 1559 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 1560 } 1561 #endif /* _CDP_TXRX_CMN_H_ */ 1562