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