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_ctrl_objmgr_pdev *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, struct cdp_ctrl_objmgr_peer *ctrl_peer) 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, ctrl_peer); 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 /** 476 * cdp_peer_ast_get_type() - Return type (Static, WDS, MEC) of AST entry 477 * @soc: DP SoC handle 478 * @ast_handle: Opaque handle to AST entry 479 * 480 * Return: AST entry type (Static/WDS/MEC) 481 */ 482 static inline enum cdp_txrx_ast_entry_type cdp_peer_ast_get_type 483 (ol_txrx_soc_handle soc, void *ast_handle) 484 485 { 486 if (!soc || !soc->ops) { 487 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 488 "%s: Invalid Instance:", __func__); 489 QDF_BUG(0); 490 return 0; 491 } 492 493 if (!soc->ops->cmn_drv_ops || 494 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_type) 495 return 0; 496 497 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_type(soc, ast_handle); 498 } 499 500 static inline void cdp_peer_ast_set_type 501 (ol_txrx_soc_handle soc, void *ast_handle, 502 enum cdp_txrx_ast_entry_type type) 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_ast_set_type) 513 return; 514 515 soc->ops->cmn_drv_ops->txrx_peer_ast_set_type(soc, ast_handle, type); 516 } 517 518 static inline void cdp_peer_teardown 519 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 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_teardown) 530 return; 531 532 soc->ops->cmn_drv_ops->txrx_peer_teardown(vdev, peer); 533 } 534 535 static inline void 536 cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 537 { 538 if (!soc || !soc->ops) { 539 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 540 "%s: Invalid Instance:", __func__); 541 QDF_BUG(0); 542 return; 543 } 544 545 if (!soc->ops->cmn_drv_ops || 546 !soc->ops->cmn_drv_ops->txrx_peer_delete) 547 return; 548 549 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 550 } 551 552 static inline int 553 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 554 uint8_t smart_monitor) 555 { 556 if (!soc || !soc->ops) { 557 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 558 "%s: Invalid Instance:", __func__); 559 QDF_BUG(0); 560 return 0; 561 } 562 563 if (!soc->ops->cmn_drv_ops || 564 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 565 return 0; 566 567 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 568 smart_monitor); 569 } 570 571 static inline void 572 cdp_set_curchan(ol_txrx_soc_handle soc, 573 struct cdp_pdev *pdev, 574 uint32_t chan_mhz) 575 { 576 if (!soc || !soc->ops) { 577 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 578 "%s: Invalid Instance:", __func__); 579 QDF_BUG(0); 580 return; 581 } 582 583 if (!soc->ops->cmn_drv_ops || 584 !soc->ops->cmn_drv_ops->txrx_set_curchan) 585 return; 586 587 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 588 } 589 590 static inline void 591 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 592 void *filter, uint32_t num) 593 { 594 if (!soc || !soc->ops) { 595 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 596 "%s: Invalid Instance:", __func__); 597 QDF_BUG(0); 598 return; 599 } 600 601 if (!soc->ops->cmn_drv_ops || 602 !soc->ops->cmn_drv_ops->txrx_set_privacy_filters) 603 return; 604 605 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 606 filter, num); 607 } 608 609 static inline int 610 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 611 struct cdp_monitor_filter *filter_val) 612 { 613 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 614 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 615 filter_val); 616 return 0; 617 } 618 619 620 /****************************************************************************** 621 * Data Interface (B Interface) 622 *****************************************************************************/ 623 static inline void 624 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 625 void *osif_vdev, struct cdp_ctrl_objmgr_vdev *ctrl_vdev, 626 struct ol_txrx_ops *txrx_ops) 627 { 628 if (!soc || !soc->ops) { 629 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 630 "%s: Invalid Instance:", __func__); 631 QDF_BUG(0); 632 return; 633 } 634 635 if (!soc->ops->cmn_drv_ops || 636 !soc->ops->cmn_drv_ops->txrx_vdev_register) 637 return; 638 639 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 640 osif_vdev, ctrl_vdev, txrx_ops); 641 } 642 643 static inline int 644 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 645 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 646 { 647 if (!soc || !soc->ops) { 648 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 649 "%s: Invalid Instance:", __func__); 650 QDF_BUG(0); 651 return 0; 652 } 653 654 if (!soc->ops->cmn_drv_ops || 655 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 656 return 0; 657 658 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 659 tx_mgmt_frm, type); 660 } 661 662 static inline int 663 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 664 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 665 uint8_t use_6mbps, uint16_t chanfreq) 666 { 667 if (!soc || !soc->ops) { 668 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 669 "%s: Invalid Instance:", __func__); 670 QDF_BUG(0); 671 return 0; 672 } 673 674 if (!soc->ops->cmn_drv_ops || 675 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 676 return 0; 677 678 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 679 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 680 } 681 682 683 static inline void 684 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 685 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 686 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 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; 693 } 694 695 if (!soc->ops->cmn_drv_ops || 696 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 697 return; 698 699 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 700 (pdev, type, download_cb, ota_ack_cb, ctxt); 701 } 702 703 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 704 struct cdp_pdev *pdev) 705 { 706 if (!soc || !soc->ops) { 707 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 708 "%s: Invalid Instance:", __func__); 709 QDF_BUG(0); 710 return 0; 711 } 712 713 if (!soc->ops->cmn_drv_ops || 714 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 715 return 0; 716 717 718 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 719 } 720 721 static inline void 722 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 723 ol_txrx_data_tx_cb callback, void *ctxt) 724 { 725 if (!soc || !soc->ops) { 726 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 727 "%s: Invalid Instance:", __func__); 728 QDF_BUG(0); 729 return; 730 } 731 732 if (!soc->ops->cmn_drv_ops || 733 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 734 return; 735 736 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 737 callback, ctxt); 738 } 739 740 /****************************************************************************** 741 * Statistics and Debugging Interface (C Interface) 742 *****************************************************************************/ 743 /** 744 * External Device physical address types 745 * 746 * Currently, both MAC and IPA uController use the same size addresses 747 * and descriptors are exchanged between these two depending on the mode. 748 * 749 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 750 * operations. However, external device physical address sizes 751 * may be different from host-specific physical address sizes. 752 * This calls for the following definitions for target devices 753 * (MAC, IPA uc). 754 */ 755 #if HTT_PADDR64 756 typedef uint64_t target_paddr_t; 757 #else 758 typedef uint32_t target_paddr_t; 759 #endif /*HTT_PADDR64 */ 760 761 static inline int 762 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 763 int max_subfrms_ampdu, 764 int max_subfrms_amsdu) 765 { 766 if (!soc || !soc->ops) { 767 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 768 "%s: Invalid Instance:", __func__); 769 QDF_BUG(0); 770 return 0; 771 } 772 773 if (!soc->ops->cmn_drv_ops || 774 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 775 return 0; 776 777 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 778 max_subfrms_ampdu, max_subfrms_amsdu); 779 } 780 781 static inline int 782 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 783 struct ol_txrx_stats_req *req, bool per_vdev, 784 bool response_expected) 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_fw_stats_get) 795 return 0; 796 797 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 798 per_vdev, response_expected); 799 } 800 801 static inline int 802 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 803 { 804 if (!soc || !soc->ops) { 805 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 806 "%s: Invalid Instance:", __func__); 807 QDF_BUG(0); 808 return 0; 809 } 810 811 if (!soc->ops->cmn_drv_ops || 812 !soc->ops->cmn_drv_ops->txrx_debug) 813 return 0; 814 815 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 816 } 817 818 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 819 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 820 { 821 if (!soc || !soc->ops) { 822 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 823 "%s: Invalid Instance:", __func__); 824 QDF_BUG(0); 825 return; 826 } 827 828 if (!soc->ops->cmn_drv_ops || 829 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 830 return; 831 832 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 833 cfg_stats_type, cfg_val); 834 } 835 836 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 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_print_level_set) 847 return; 848 849 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 850 } 851 852 static inline uint8_t * 853 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 854 { 855 if (!soc || !soc->ops) { 856 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 857 "%s: Invalid Instance:", __func__); 858 QDF_BUG(0); 859 return NULL; 860 } 861 862 if (!soc->ops->cmn_drv_ops || 863 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 864 return NULL; 865 866 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 867 868 } 869 870 /** 871 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 872 * vdev 873 * @vdev: vdev handle 874 * 875 * Return: Handle to struct qdf_mac_addr 876 */ 877 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 878 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 879 { 880 if (!soc || !soc->ops) { 881 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 882 "%s: Invalid Instance:", __func__); 883 QDF_BUG(0); 884 return NULL; 885 } 886 887 if (!soc->ops->cmn_drv_ops || 888 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 889 return NULL; 890 891 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 892 (vdev); 893 894 } 895 896 /** 897 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 898 * @vdev: vdev handle 899 * 900 * Return: Handle to pdev 901 */ 902 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 903 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 904 { 905 if (!soc || !soc->ops) { 906 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 907 "%s: Invalid Instance:", __func__); 908 QDF_BUG(0); 909 return NULL; 910 } 911 912 if (!soc->ops->cmn_drv_ops || 913 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 914 return NULL; 915 916 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 917 } 918 919 /** 920 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 921 * @vdev: vdev handle 922 * 923 * Return: Handle to control pdev 924 */ 925 static inline struct cdp_cfg * 926 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 927 { 928 if (!soc || !soc->ops) { 929 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 930 "%s: Invalid Instance:", __func__); 931 QDF_BUG(0); 932 return NULL; 933 } 934 935 if (!soc->ops->cmn_drv_ops || 936 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 937 return NULL; 938 939 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 940 (vdev); 941 } 942 943 static inline struct cdp_vdev * 944 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 945 uint8_t vdev_id) 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 NULL; 952 } 953 954 if (!soc->ops->cmn_drv_ops || 955 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 956 return NULL; 957 958 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 959 (pdev, vdev_id); 960 } 961 962 static inline void 963 cdp_soc_detach(ol_txrx_soc_handle soc) 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; 970 } 971 972 if (!soc->ops->cmn_drv_ops || 973 !soc->ops->cmn_drv_ops->txrx_soc_detach) 974 return; 975 976 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 977 } 978 979 /** 980 * cdp_addba_resp_tx_completion() - Indicate addba response tx 981 * completion to dp to change tid state. 982 * @soc: soc handle 983 * @peer_handle: peer handle 984 * @tid: tid 985 * @status: Tx completion status 986 * 987 * Return: success/failure of tid update 988 */ 989 static inline int cdp_addba_resp_tx_completion(ol_txrx_soc_handle soc, 990 void *peer_handle, 991 uint8_t tid, int status) 992 { 993 if (!soc || !soc->ops) { 994 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 995 "%s: Invalid Instance:", __func__); 996 QDF_BUG(0); 997 return 0; 998 } 999 1000 if (!soc->ops->cmn_drv_ops || 1001 !soc->ops->cmn_drv_ops->addba_resp_tx_completion) 1002 return 0; 1003 1004 return soc->ops->cmn_drv_ops->addba_resp_tx_completion(peer_handle, tid, 1005 status); 1006 } 1007 1008 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 1009 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 1010 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 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 0; 1017 } 1018 1019 if (!soc->ops->cmn_drv_ops || 1020 !soc->ops->cmn_drv_ops->addba_requestprocess) 1021 return 0; 1022 1023 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 1024 dialogtoken, tid, batimeout, buffersize, startseqnum); 1025 } 1026 1027 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 1028 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 1029 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 1030 { 1031 if (!soc || !soc->ops) { 1032 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1033 "%s: Invalid Instance:", __func__); 1034 QDF_BUG(0); 1035 return; 1036 } 1037 1038 if (!soc->ops->cmn_drv_ops || 1039 !soc->ops->cmn_drv_ops->addba_responsesetup) 1040 return; 1041 1042 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 1043 dialogtoken, statuscode, buffersize, batimeout); 1044 } 1045 1046 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 1047 void *peer_handle, int tid, uint16_t reasoncode) 1048 { 1049 if (!soc || !soc->ops) { 1050 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1051 "%s: Invalid Instance:", __func__); 1052 QDF_BUG(0); 1053 return 0; 1054 } 1055 1056 if (!soc->ops->cmn_drv_ops || 1057 !soc->ops->cmn_drv_ops->delba_process) 1058 return 0; 1059 1060 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 1061 tid, reasoncode); 1062 } 1063 1064 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1065 void *peer_handle, int tid, uint16_t statuscode) 1066 { 1067 if (!soc || !soc->ops) { 1068 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1069 "%s: Invalid Instance:", __func__); 1070 QDF_BUG(0); 1071 return; 1072 } 1073 1074 if (!soc->ops->cmn_drv_ops || 1075 !soc->ops->cmn_drv_ops->set_addba_response) 1076 return; 1077 1078 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1079 } 1080 1081 /** 1082 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1083 * mac address 1084 * @soc: SOC handle 1085 * @peer_id: peer id of the peer for which mac_address is required 1086 * @mac_addr: reference to mac address 1087 * 1088 * reutm: vdev_id of the vap 1089 */ 1090 static inline uint8_t 1091 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1092 uint8_t *mac_addr) 1093 { 1094 if (!soc || !soc->ops) { 1095 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1096 "%s: Invalid Instance:", __func__); 1097 QDF_BUG(0); 1098 return CDP_INVALID_VDEV_ID; 1099 } 1100 1101 if (!soc->ops->cmn_drv_ops || 1102 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1103 return CDP_INVALID_VDEV_ID; 1104 1105 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1106 peer_id, mac_addr); 1107 } 1108 1109 /** 1110 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1111 * @vdev: vdev handle 1112 * @map_id: id of the tid map 1113 * 1114 * Return: void 1115 */ 1116 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1117 struct cdp_vdev *vdev, uint8_t map_id) 1118 { 1119 if (!soc || !soc->ops) { 1120 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1121 "%s: Invalid Instance:", __func__); 1122 QDF_BUG(0); 1123 return; 1124 } 1125 1126 if (!soc->ops->cmn_drv_ops || 1127 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1128 return; 1129 1130 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1131 map_id); 1132 } 1133 1134 /** 1135 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1136 * @pdev: pdev handle 1137 * @map_id: id of the tid map 1138 * @tos: index value in map that needs to be changed 1139 * @tid: tid value passed by user 1140 * 1141 * Return: void 1142 */ 1143 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1144 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 1145 { 1146 if (!soc || !soc->ops) { 1147 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1148 "%s: Invalid Instance:", __func__); 1149 QDF_BUG(0); 1150 return; 1151 } 1152 1153 if (!soc->ops->cmn_drv_ops || 1154 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1155 return; 1156 1157 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1158 map_id, tos, tid); 1159 } 1160 1161 /** 1162 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1163 * 1164 * Return: None 1165 */ 1166 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1167 { 1168 if (!soc || !soc->ops) { 1169 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1170 "%s: Invalid Instance:", __func__); 1171 QDF_BUG(0); 1172 return; 1173 } 1174 1175 if (!soc->ops->cmn_drv_ops || 1176 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1177 return; 1178 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1179 } 1180 1181 /** 1182 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1183 * @soc: soc handle 1184 * @vdev: virtual device 1185 * @req: stats request container 1186 * 1187 * return: status 1188 */ 1189 static inline 1190 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1191 struct cdp_txrx_stats_req *req) 1192 { 1193 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1194 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1195 "%s: Invalid Instance:", __func__); 1196 QDF_ASSERT(0); 1197 return 0; 1198 } 1199 1200 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1201 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1202 1203 return 0; 1204 } 1205 1206 /** 1207 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1208 * @soc: soc handle 1209 */ 1210 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1211 { 1212 if (!soc || !soc->ops) { 1213 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1214 "%s: Invalid Instance:", __func__); 1215 QDF_BUG(0); 1216 return 0; 1217 } 1218 1219 if (!soc->ops->cmn_drv_ops || 1220 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1221 return 0; 1222 1223 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1224 } 1225 1226 /** 1227 * cdp_txrx_intr_detach(): function to detach interrupt 1228 * @soc: soc handle 1229 */ 1230 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 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; 1237 } 1238 1239 if (!soc->ops->cmn_drv_ops || 1240 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1241 return; 1242 1243 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1244 } 1245 1246 /** 1247 * cdp_display_stats(): function to map to dump stats 1248 * @soc: soc handle 1249 * @value: statistics option 1250 */ 1251 static inline QDF_STATUS 1252 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1253 enum qdf_stats_verbosity_level level) 1254 { 1255 if (!soc || !soc->ops) { 1256 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1257 "%s: Invalid Instance:", __func__); 1258 QDF_BUG(0); 1259 return 0; 1260 } 1261 1262 if (!soc->ops->cmn_drv_ops || 1263 !soc->ops->cmn_drv_ops->display_stats) 1264 return 0; 1265 1266 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1267 } 1268 1269 1270 /** 1271 * cdp_set_pn_check(): function to set pn check 1272 * @soc: soc handle 1273 * @sec_type: security type 1274 * #rx_pn: receive pn 1275 */ 1276 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1277 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 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 || 1287 !soc->ops->cmn_drv_ops->set_pn_check) 1288 return 0; 1289 1290 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1291 sec_type, rx_pn); 1292 return 0; 1293 } 1294 1295 static inline int cdp_set_key(ol_txrx_soc_handle soc, 1296 struct cdp_peer *peer_handle, 1297 bool is_unicast, uint32_t *key) 1298 { 1299 if (!soc || !soc->ops) { 1300 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1301 "%s: Invalid Instance:", __func__); 1302 QDF_BUG(0); 1303 return 0; 1304 } 1305 1306 if (!soc->ops->ctrl_ops || 1307 !soc->ops->ctrl_ops->set_key) 1308 return 0; 1309 1310 soc->ops->ctrl_ops->set_key(peer_handle, 1311 is_unicast, key); 1312 return 0; 1313 } 1314 1315 /** 1316 * cdp_update_config_parameters(): function to propagate configuration 1317 * parameters to datapath 1318 * @soc: opaque soc handle 1319 * @cfg: configuration handle 1320 * 1321 * Return: status: 0 - Success, non-zero: Failure 1322 */ 1323 static inline 1324 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1325 struct cdp_config_params *cfg) 1326 { 1327 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1328 1329 if (!soc || !soc->ops) { 1330 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1331 "%s: Invalid Instance:", __func__); 1332 QDF_BUG(0); 1333 return 0; 1334 } 1335 1336 if (!soc->ops->cmn_drv_ops || 1337 !soc->ops->cmn_drv_ops->update_config_parameters) 1338 return QDF_STATUS_SUCCESS; 1339 1340 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1341 cfg); 1342 } 1343 1344 /** 1345 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1346 * @soc: opaque soc handle 1347 * @pdev: data path pdev handle 1348 * 1349 * Return: opaque dp handle 1350 */ 1351 static inline void * 1352 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1353 { 1354 if (!soc || !soc->ops) { 1355 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1356 "%s: Invalid Instance:", __func__); 1357 QDF_BUG(0); 1358 return 0; 1359 } 1360 1361 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1362 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1363 1364 return 0; 1365 } 1366 1367 /** 1368 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1369 * @soc: opaque soc handle 1370 * @pdev: data path pdev handle 1371 * @dp_hdl: opaque pointer for dp_txrx_handle 1372 * 1373 * Return: void 1374 */ 1375 static inline void 1376 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1377 { 1378 if (!soc || !soc->ops) { 1379 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1380 "%s: Invalid Instance:", __func__); 1381 QDF_BUG(0); 1382 return; 1383 } 1384 1385 if (!soc->ops->cmn_drv_ops || 1386 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1387 return; 1388 1389 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1390 } 1391 1392 /* 1393 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1394 * @soc: opaque soc handle 1395 * 1396 * Return: opaque extended dp handle 1397 */ 1398 static inline void * 1399 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1400 { 1401 if (!soc || !soc->ops) { 1402 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1403 "%s: Invalid Instance:", __func__); 1404 QDF_BUG(0); 1405 return NULL; 1406 } 1407 1408 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1409 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1410 (struct cdp_soc *) soc); 1411 1412 return NULL; 1413 } 1414 1415 /** 1416 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1417 * @soc: opaque soc handle 1418 * @dp_hdl: opaque pointer for dp_txrx_handle 1419 * 1420 * Return: void 1421 */ 1422 static inline void 1423 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1424 { 1425 if (!soc || !soc->ops) { 1426 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1427 "%s: Invalid Instance:", __func__); 1428 QDF_BUG(0); 1429 return; 1430 } 1431 1432 if (!soc->ops->cmn_drv_ops || 1433 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1434 return; 1435 1436 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1437 dp_handle); 1438 } 1439 1440 /** 1441 * cdp_tx_send() - enqueue frame for transmission 1442 * @soc: soc opaque handle 1443 * @vdev: VAP device 1444 * @nbuf: nbuf to be enqueued 1445 * 1446 * This API is used by Extended Datapath modules to enqueue frame for 1447 * transmission 1448 * 1449 * Return: void 1450 */ 1451 static inline void 1452 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1453 { 1454 if (!soc || !soc->ops) { 1455 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1456 "%s: Invalid Instance:", __func__); 1457 QDF_BUG(0); 1458 return; 1459 } 1460 1461 if (!soc->ops->cmn_drv_ops || 1462 !soc->ops->cmn_drv_ops->tx_send) 1463 return; 1464 1465 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1466 } 1467 1468 /* 1469 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1470 * @soc: opaque soc handle 1471 * @pdev: data path pdev handle 1472 * 1473 * Return: pdev_id 1474 */ 1475 static inline 1476 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1477 struct cdp_pdev *pdev) 1478 { 1479 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1480 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1481 return 0; 1482 } 1483 1484 /** 1485 * cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer 1486 * @soc: opaque soc handle 1487 * @pdev: data path pdev handle 1488 * @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path 1489 * 1490 * Return: None 1491 */ 1492 static inline 1493 void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc, 1494 struct cdp_pdev *pdev, 1495 int16_t chan_noise_floor) 1496 { 1497 if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor) 1498 return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor( 1499 pdev, chan_noise_floor); 1500 } 1501 1502 /** 1503 * cdp_set_nac() - set nac 1504 * @soc: opaque soc handle 1505 * @peer: data path peer handle 1506 * 1507 */ 1508 static inline 1509 void cdp_set_nac(ol_txrx_soc_handle soc, 1510 struct cdp_peer *peer) 1511 { 1512 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1513 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1514 } 1515 1516 /** 1517 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1518 * @soc: opaque soc handle 1519 * @pdev: data path pdev handle 1520 * @val: value of pdev_tx_capture 1521 * 1522 * Return: void 1523 */ 1524 static inline 1525 void cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1526 struct cdp_pdev *pdev, int val) 1527 { 1528 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1529 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1530 val); 1531 1532 } 1533 1534 /** 1535 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1536 * @soc: opaque soc handle 1537 * @pdev: data path pdev handle 1538 * @peer_id: data path peer id 1539 * @peer_mac: peer_mac 1540 * 1541 * Return: void 1542 */ 1543 static inline 1544 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1545 struct cdp_pdev *pdev_handle, 1546 uint32_t peer_id, uint8_t *peer_mac) 1547 { 1548 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1549 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1550 pdev_handle, peer_id, peer_mac); 1551 } 1552 1553 /** 1554 * cdp_vdev_tx_lock() - acquire lock 1555 * @soc: opaque soc handle 1556 * @vdev: data path vdev handle 1557 * 1558 * Return: void 1559 */ 1560 static inline 1561 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1562 struct cdp_vdev *vdev) 1563 { 1564 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1565 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1566 } 1567 1568 /** 1569 * cdp_vdev_tx_unlock() - release lock 1570 * @soc: opaque soc handle 1571 * @vdev: data path vdev handle 1572 * 1573 * Return: void 1574 */ 1575 static inline 1576 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1577 struct cdp_vdev *vdev) 1578 { 1579 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1580 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1581 } 1582 1583 /** 1584 * cdp_ath_getstats() - get updated athstats 1585 * @soc: opaque soc handle 1586 * @dev: dp interface handle 1587 * @stats: cdp network device stats structure 1588 * @type: device type pdev/vdev 1589 * 1590 * Return: void 1591 */ 1592 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1593 void *dev, struct cdp_dev_stats *stats, 1594 uint8_t type) 1595 { 1596 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1597 soc->ops->cmn_drv_ops->txrx_ath_getstats(dev, stats, type); 1598 } 1599 1600 /** 1601 * cdp_set_gid_flag() - set groupid flag 1602 * @soc: opaque soc handle 1603 * @pdev: data path pdev handle 1604 * @mem_status: member status from grp management frame 1605 * @user_position: user position from grp management frame 1606 * 1607 * Return: void 1608 */ 1609 static inline 1610 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1611 struct cdp_pdev *pdev, u_int8_t *mem_status, 1612 u_int8_t *user_position) 1613 { 1614 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1615 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1616 } 1617 1618 /** 1619 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1620 * @soc: opaque soc handle 1621 * @pdev: data path pdev handle 1622 * 1623 */ 1624 static inline 1625 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1626 struct cdp_pdev *pdev) 1627 { 1628 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1629 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1630 return 0; 1631 } 1632 1633 /** 1634 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1635 * @soc: opaque soc handle 1636 * @ni: associated node 1637 * @force: number of frame in SW queue 1638 * Return: void 1639 */ 1640 static inline 1641 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 1642 void *ni, int force) 1643 { 1644 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 1645 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 1646 } 1647 1648 static inline void 1649 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers) 1650 { 1651 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1652 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 1653 soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, max_peers); 1654 } 1655 1656 /** 1657 1658 * cdp_pdev_set_ctrl_pdev() - set UMAC ctrl pdev to dp pdev 1659 * @soc: opaque soc handle 1660 * @pdev: opaque dp pdev handle 1661 * @ctrl_pdev: opaque ctrl pdev handle 1662 * 1663 * Return: void 1664 */ 1665 static inline void 1666 cdp_pdev_set_ctrl_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *dp_pdev, 1667 struct cdp_ctrl_objmgr_pdev *ctrl_pdev) 1668 { 1669 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1670 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev) 1671 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev(dp_pdev, 1672 ctrl_pdev); 1673 } 1674 1675 #ifdef RECEIVE_OFFLOAD 1676 /** 1677 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 1678 * @soc - data path soc handle 1679 * @pdev - device instance pointer 1680 * 1681 * register rx offload flush callback function pointer 1682 * 1683 * return none 1684 */ 1685 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 1686 void (rx_ol_flush_cb)(void *)) 1687 { 1688 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1689 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1690 "%s invalid instance", __func__); 1691 return; 1692 } 1693 1694 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 1695 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 1696 rx_ol_flush_cb); 1697 } 1698 1699 /** 1700 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 1701 * @soc - data path soc handle 1702 * 1703 * deregister rx offload flush callback function pointer 1704 * 1705 * return none 1706 */ 1707 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 1708 { 1709 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1710 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1711 "%s invalid instance", __func__); 1712 return; 1713 } 1714 1715 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 1716 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 1717 } 1718 #endif /* RECEIVE_OFFLOAD */ 1719 #endif /* _CDP_TXRX_CMN_H_ */ 1720