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 /** 1065 * cdp_delba_tx_completion() - Handle delba tx completion 1066 * to update stats and retry transmission if failed. 1067 * @soc: soc handle 1068 * @peer_handle: peer handle 1069 * @tid: Tid number 1070 * @status: Tx completion status 1071 * 1072 * Return: 0 on Success, 1 on failure 1073 */ 1074 1075 static inline int cdp_delba_tx_completion(ol_txrx_soc_handle soc, 1076 void *peer_handle, 1077 uint8_t tid, int status) 1078 { 1079 if (!soc || !soc->ops) { 1080 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1081 "%s: Invalid Instance:", __func__); 1082 QDF_BUG(0); 1083 return 0; 1084 } 1085 1086 if (!soc->ops->cmn_drv_ops || 1087 !soc->ops->cmn_drv_ops->delba_tx_completion) 1088 return 0; 1089 1090 return soc->ops->cmn_drv_ops->delba_tx_completion(peer_handle, 1091 tid, status); 1092 } 1093 1094 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1095 void *peer_handle, int tid, uint16_t statuscode) 1096 { 1097 if (!soc || !soc->ops) { 1098 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1099 "%s: Invalid Instance:", __func__); 1100 QDF_BUG(0); 1101 return; 1102 } 1103 1104 if (!soc->ops->cmn_drv_ops || 1105 !soc->ops->cmn_drv_ops->set_addba_response) 1106 return; 1107 1108 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1109 } 1110 1111 /** 1112 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1113 * mac address 1114 * @soc: SOC handle 1115 * @peer_id: peer id of the peer for which mac_address is required 1116 * @mac_addr: reference to mac address 1117 * 1118 * reutm: vdev_id of the vap 1119 */ 1120 static inline uint8_t 1121 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1122 uint8_t *mac_addr) 1123 { 1124 if (!soc || !soc->ops) { 1125 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1126 "%s: Invalid Instance:", __func__); 1127 QDF_BUG(0); 1128 return CDP_INVALID_VDEV_ID; 1129 } 1130 1131 if (!soc->ops->cmn_drv_ops || 1132 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1133 return CDP_INVALID_VDEV_ID; 1134 1135 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1136 peer_id, mac_addr); 1137 } 1138 1139 /** 1140 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1141 * @vdev: vdev handle 1142 * @map_id: id of the tid map 1143 * 1144 * Return: void 1145 */ 1146 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1147 struct cdp_vdev *vdev, uint8_t map_id) 1148 { 1149 if (!soc || !soc->ops) { 1150 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1151 "%s: Invalid Instance:", __func__); 1152 QDF_BUG(0); 1153 return; 1154 } 1155 1156 if (!soc->ops->cmn_drv_ops || 1157 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1158 return; 1159 1160 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1161 map_id); 1162 } 1163 1164 /** 1165 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1166 * @pdev: pdev handle 1167 * @map_id: id of the tid map 1168 * @tos: index value in map that needs to be changed 1169 * @tid: tid value passed by user 1170 * 1171 * Return: void 1172 */ 1173 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1174 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 1175 { 1176 if (!soc || !soc->ops) { 1177 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1178 "%s: Invalid Instance:", __func__); 1179 QDF_BUG(0); 1180 return; 1181 } 1182 1183 if (!soc->ops->cmn_drv_ops || 1184 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1185 return; 1186 1187 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1188 map_id, tos, tid); 1189 } 1190 1191 /** 1192 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1193 * 1194 * Return: None 1195 */ 1196 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1197 { 1198 if (!soc || !soc->ops) { 1199 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1200 "%s: Invalid Instance:", __func__); 1201 QDF_BUG(0); 1202 return; 1203 } 1204 1205 if (!soc->ops->cmn_drv_ops || 1206 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1207 return; 1208 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1209 } 1210 1211 /** 1212 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1213 * @soc: soc handle 1214 * @vdev: virtual device 1215 * @req: stats request container 1216 * 1217 * return: status 1218 */ 1219 static inline 1220 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1221 struct cdp_txrx_stats_req *req) 1222 { 1223 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1224 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1225 "%s: Invalid Instance:", __func__); 1226 QDF_ASSERT(0); 1227 return 0; 1228 } 1229 1230 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1231 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1232 1233 return 0; 1234 } 1235 1236 /** 1237 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1238 * @soc: soc handle 1239 */ 1240 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1241 { 1242 if (!soc || !soc->ops) { 1243 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1244 "%s: Invalid Instance:", __func__); 1245 QDF_BUG(0); 1246 return 0; 1247 } 1248 1249 if (!soc->ops->cmn_drv_ops || 1250 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1251 return 0; 1252 1253 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1254 } 1255 1256 /** 1257 * cdp_txrx_intr_detach(): function to detach interrupt 1258 * @soc: soc handle 1259 */ 1260 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle 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; 1267 } 1268 1269 if (!soc->ops->cmn_drv_ops || 1270 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1271 return; 1272 1273 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1274 } 1275 1276 /** 1277 * cdp_display_stats(): function to map to dump stats 1278 * @soc: soc handle 1279 * @value: statistics option 1280 */ 1281 static inline QDF_STATUS 1282 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1283 enum qdf_stats_verbosity_level level) 1284 { 1285 if (!soc || !soc->ops) { 1286 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1287 "%s: Invalid Instance:", __func__); 1288 QDF_BUG(0); 1289 return 0; 1290 } 1291 1292 if (!soc->ops->cmn_drv_ops || 1293 !soc->ops->cmn_drv_ops->display_stats) 1294 return 0; 1295 1296 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1297 } 1298 1299 1300 /** 1301 * cdp_set_pn_check(): function to set pn check 1302 * @soc: soc handle 1303 * @sec_type: security type 1304 * #rx_pn: receive pn 1305 */ 1306 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1307 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1308 { 1309 if (!soc || !soc->ops) { 1310 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1311 "%s: Invalid Instance:", __func__); 1312 QDF_BUG(0); 1313 return 0; 1314 } 1315 1316 if (!soc->ops->cmn_drv_ops || 1317 !soc->ops->cmn_drv_ops->set_pn_check) 1318 return 0; 1319 1320 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1321 sec_type, rx_pn); 1322 return 0; 1323 } 1324 1325 static inline int cdp_set_key(ol_txrx_soc_handle soc, 1326 struct cdp_peer *peer_handle, 1327 bool is_unicast, uint32_t *key) 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->ctrl_ops || 1337 !soc->ops->ctrl_ops->set_key) 1338 return 0; 1339 1340 soc->ops->ctrl_ops->set_key(peer_handle, 1341 is_unicast, key); 1342 return 0; 1343 } 1344 1345 /** 1346 * cdp_update_config_parameters(): function to propagate configuration 1347 * parameters to datapath 1348 * @soc: opaque soc handle 1349 * @cfg: configuration handle 1350 * 1351 * Return: status: 0 - Success, non-zero: Failure 1352 */ 1353 static inline 1354 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1355 struct cdp_config_params *cfg) 1356 { 1357 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1358 1359 if (!soc || !soc->ops) { 1360 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1361 "%s: Invalid Instance:", __func__); 1362 QDF_BUG(0); 1363 return 0; 1364 } 1365 1366 if (!soc->ops->cmn_drv_ops || 1367 !soc->ops->cmn_drv_ops->update_config_parameters) 1368 return QDF_STATUS_SUCCESS; 1369 1370 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1371 cfg); 1372 } 1373 1374 /** 1375 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1376 * @soc: opaque soc handle 1377 * @pdev: data path pdev handle 1378 * 1379 * Return: opaque dp handle 1380 */ 1381 static inline void * 1382 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1383 { 1384 if (!soc || !soc->ops) { 1385 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1386 "%s: Invalid Instance:", __func__); 1387 QDF_BUG(0); 1388 return 0; 1389 } 1390 1391 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1392 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1393 1394 return 0; 1395 } 1396 1397 /** 1398 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1399 * @soc: opaque soc handle 1400 * @pdev: data path pdev handle 1401 * @dp_hdl: opaque pointer for dp_txrx_handle 1402 * 1403 * Return: void 1404 */ 1405 static inline void 1406 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1407 { 1408 if (!soc || !soc->ops) { 1409 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1410 "%s: Invalid Instance:", __func__); 1411 QDF_BUG(0); 1412 return; 1413 } 1414 1415 if (!soc->ops->cmn_drv_ops || 1416 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1417 return; 1418 1419 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1420 } 1421 1422 /* 1423 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1424 * @soc: opaque soc handle 1425 * 1426 * Return: opaque extended dp handle 1427 */ 1428 static inline void * 1429 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1430 { 1431 if (!soc || !soc->ops) { 1432 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1433 "%s: Invalid Instance:", __func__); 1434 QDF_BUG(0); 1435 return NULL; 1436 } 1437 1438 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1439 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1440 (struct cdp_soc *) soc); 1441 1442 return NULL; 1443 } 1444 1445 /** 1446 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1447 * @soc: opaque soc handle 1448 * @dp_hdl: opaque pointer for dp_txrx_handle 1449 * 1450 * Return: void 1451 */ 1452 static inline void 1453 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1454 { 1455 if (!soc || !soc->ops) { 1456 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1457 "%s: Invalid Instance:", __func__); 1458 QDF_BUG(0); 1459 return; 1460 } 1461 1462 if (!soc->ops->cmn_drv_ops || 1463 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1464 return; 1465 1466 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1467 dp_handle); 1468 } 1469 1470 /** 1471 * cdp_tx_send() - enqueue frame for transmission 1472 * @soc: soc opaque handle 1473 * @vdev: VAP device 1474 * @nbuf: nbuf to be enqueued 1475 * 1476 * This API is used by Extended Datapath modules to enqueue frame for 1477 * transmission 1478 * 1479 * Return: void 1480 */ 1481 static inline void 1482 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1483 { 1484 if (!soc || !soc->ops) { 1485 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1486 "%s: Invalid Instance:", __func__); 1487 QDF_BUG(0); 1488 return; 1489 } 1490 1491 if (!soc->ops->cmn_drv_ops || 1492 !soc->ops->cmn_drv_ops->tx_send) 1493 return; 1494 1495 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1496 } 1497 1498 /* 1499 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1500 * @soc: opaque soc handle 1501 * @pdev: data path pdev handle 1502 * 1503 * Return: pdev_id 1504 */ 1505 static inline 1506 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1507 struct cdp_pdev *pdev) 1508 { 1509 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1510 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1511 return 0; 1512 } 1513 1514 /** 1515 * cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer 1516 * @soc: opaque soc handle 1517 * @pdev: data path pdev handle 1518 * @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path 1519 * 1520 * Return: None 1521 */ 1522 static inline 1523 void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc, 1524 struct cdp_pdev *pdev, 1525 int16_t chan_noise_floor) 1526 { 1527 if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor) 1528 return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor( 1529 pdev, chan_noise_floor); 1530 } 1531 1532 /** 1533 * cdp_set_nac() - set nac 1534 * @soc: opaque soc handle 1535 * @peer: data path peer handle 1536 * 1537 */ 1538 static inline 1539 void cdp_set_nac(ol_txrx_soc_handle soc, 1540 struct cdp_peer *peer) 1541 { 1542 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1543 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1544 } 1545 1546 /** 1547 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1548 * @soc: opaque soc handle 1549 * @pdev: data path pdev handle 1550 * @val: value of pdev_tx_capture 1551 * 1552 * Return: void 1553 */ 1554 static inline 1555 void cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1556 struct cdp_pdev *pdev, int val) 1557 { 1558 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1559 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1560 val); 1561 1562 } 1563 1564 /** 1565 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1566 * @soc: opaque soc handle 1567 * @pdev: data path pdev handle 1568 * @peer_id: data path peer id 1569 * @peer_mac: peer_mac 1570 * 1571 * Return: void 1572 */ 1573 static inline 1574 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1575 struct cdp_pdev *pdev_handle, 1576 uint32_t peer_id, uint8_t *peer_mac) 1577 { 1578 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1579 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1580 pdev_handle, peer_id, peer_mac); 1581 } 1582 1583 /** 1584 * cdp_vdev_tx_lock() - acquire lock 1585 * @soc: opaque soc handle 1586 * @vdev: data path vdev handle 1587 * 1588 * Return: void 1589 */ 1590 static inline 1591 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1592 struct cdp_vdev *vdev) 1593 { 1594 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1595 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1596 } 1597 1598 /** 1599 * cdp_vdev_tx_unlock() - release lock 1600 * @soc: opaque soc handle 1601 * @vdev: data path vdev handle 1602 * 1603 * Return: void 1604 */ 1605 static inline 1606 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1607 struct cdp_vdev *vdev) 1608 { 1609 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1610 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1611 } 1612 1613 /** 1614 * cdp_ath_getstats() - get updated athstats 1615 * @soc: opaque soc handle 1616 * @dev: dp interface handle 1617 * @stats: cdp network device stats structure 1618 * @type: device type pdev/vdev 1619 * 1620 * Return: void 1621 */ 1622 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1623 void *dev, struct cdp_dev_stats *stats, 1624 uint8_t type) 1625 { 1626 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1627 soc->ops->cmn_drv_ops->txrx_ath_getstats(dev, stats, type); 1628 } 1629 1630 /** 1631 * cdp_set_gid_flag() - set groupid flag 1632 * @soc: opaque soc handle 1633 * @pdev: data path pdev handle 1634 * @mem_status: member status from grp management frame 1635 * @user_position: user position from grp management frame 1636 * 1637 * Return: void 1638 */ 1639 static inline 1640 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1641 struct cdp_pdev *pdev, u_int8_t *mem_status, 1642 u_int8_t *user_position) 1643 { 1644 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1645 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1646 } 1647 1648 /** 1649 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1650 * @soc: opaque soc handle 1651 * @pdev: data path pdev handle 1652 * 1653 */ 1654 static inline 1655 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1656 struct cdp_pdev *pdev) 1657 { 1658 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1659 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1660 return 0; 1661 } 1662 1663 /** 1664 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1665 * @soc: opaque soc handle 1666 * @ni: associated node 1667 * @force: number of frame in SW queue 1668 * Return: void 1669 */ 1670 static inline 1671 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 1672 void *ni, int force) 1673 { 1674 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 1675 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 1676 } 1677 1678 static inline void 1679 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers) 1680 { 1681 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1682 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 1683 soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, max_peers); 1684 } 1685 1686 /** 1687 1688 * cdp_pdev_set_ctrl_pdev() - set UMAC ctrl pdev to dp pdev 1689 * @soc: opaque soc handle 1690 * @pdev: opaque dp pdev handle 1691 * @ctrl_pdev: opaque ctrl pdev handle 1692 * 1693 * Return: void 1694 */ 1695 static inline void 1696 cdp_pdev_set_ctrl_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *dp_pdev, 1697 struct cdp_ctrl_objmgr_pdev *ctrl_pdev) 1698 { 1699 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1700 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev) 1701 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev(dp_pdev, 1702 ctrl_pdev); 1703 } 1704 1705 #ifdef RECEIVE_OFFLOAD 1706 /** 1707 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 1708 * @soc - data path soc handle 1709 * @pdev - device instance pointer 1710 * 1711 * register rx offload flush callback function pointer 1712 * 1713 * return none 1714 */ 1715 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 1716 void (rx_ol_flush_cb)(void *)) 1717 { 1718 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1719 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1720 "%s invalid instance", __func__); 1721 return; 1722 } 1723 1724 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 1725 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 1726 rx_ol_flush_cb); 1727 } 1728 1729 /** 1730 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 1731 * @soc - data path soc handle 1732 * 1733 * deregister rx offload flush callback function pointer 1734 * 1735 * return none 1736 */ 1737 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 1738 { 1739 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1740 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1741 "%s invalid instance", __func__); 1742 return; 1743 } 1744 1745 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 1746 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 1747 } 1748 #endif /* RECEIVE_OFFLOAD */ 1749 #endif /* _CDP_TXRX_CMN_H_ */ 1750