1 /* 2 * Copyright (c) 2011-2019 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 #define dp_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP, params) 38 #define dp_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP, params) 39 #define dp_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP, params) 40 #define dp_info(params...) \ 41 __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP, ## params) 42 #define dp_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP, params) 43 44 #define dp_alert_rl(params...) QDF_TRACE_FATAL_RL(QDF_MODULE_ID_DP, params) 45 #define dp_err_rl(params...) QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, params) 46 #define dp_warn_rl(params...) QDF_TRACE_WARN_RL(QDF_MODULE_ID_DP, params) 47 #define dp_info_rl(params...) QDF_TRACE_INFO_RL(QDF_MODULE_ID_DP, params) 48 #define dp_debug_rl(params...) QDF_TRACE_DEBUG_RL(QDF_MODULE_ID_DP, params) 49 50 static inline QDF_STATUS 51 cdp_soc_attach_target(ol_txrx_soc_handle soc) 52 { 53 if (!soc || !soc->ops) { 54 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 55 "%s: Invalid Instance:", __func__); 56 QDF_BUG(0); 57 return QDF_STATUS_E_INVAL; 58 } 59 60 if (!soc->ops->cmn_drv_ops || 61 !soc->ops->cmn_drv_ops->txrx_soc_attach_target) 62 return QDF_STATUS_SUCCESS; 63 64 return soc->ops->cmn_drv_ops->txrx_soc_attach_target(soc); 65 66 } 67 68 static inline int 69 cdp_soc_get_nss_cfg(ol_txrx_soc_handle soc) 70 { 71 if (!soc || !soc->ops) { 72 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 73 "%s: Invalid Instance:", __func__); 74 QDF_BUG(0); 75 return 0; 76 } 77 78 if (!soc->ops->cmn_drv_ops || 79 !soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg) 80 return 0; 81 82 return soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg(soc); 83 } 84 85 static inline void 86 cdp_soc_set_nss_cfg(ol_txrx_soc_handle soc, uint32_t config) 87 { 88 if (!soc || !soc->ops) { 89 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 90 "%s: Invalid Instance:", __func__); 91 QDF_BUG(0); 92 return; 93 } 94 95 if (!soc->ops->cmn_drv_ops || 96 !soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg) 97 return; 98 99 soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg(soc, config); 100 } 101 102 static inline struct cdp_vdev * 103 cdp_vdev_attach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 104 uint8_t *vdev_mac_addr, uint8_t vdev_id, enum wlan_op_mode op_mode) 105 { 106 if (!soc || !soc->ops) { 107 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 108 "%s: Invalid Instance:", __func__); 109 QDF_BUG(0); 110 return NULL; 111 } 112 113 if (!soc->ops->cmn_drv_ops || 114 !soc->ops->cmn_drv_ops->txrx_vdev_attach) 115 return NULL; 116 117 return soc->ops->cmn_drv_ops->txrx_vdev_attach(pdev, 118 vdev_mac_addr, vdev_id, op_mode); 119 } 120 #ifndef CONFIG_WIN 121 /** 122 * cdp_flow_pool_map() - Create flow pool for vdev 123 * @soc - data path soc handle 124 * @pdev 125 * @vdev_id - vdev_id corresponding to vdev start 126 * 127 * Create per vdev flow pool. 128 * 129 * return none 130 */ 131 static inline QDF_STATUS cdp_flow_pool_map(ol_txrx_soc_handle soc, 132 struct cdp_pdev *pdev, uint8_t vdev_id) 133 { 134 if (!soc || !soc->ops) { 135 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 136 "%s: Invalid Instance:", __func__); 137 QDF_BUG(0); 138 return QDF_STATUS_E_INVAL; 139 } 140 141 if (!soc->ops->flowctl_ops || 142 !soc->ops->flowctl_ops->flow_pool_map_handler) 143 return QDF_STATUS_E_INVAL; 144 145 return soc->ops->flowctl_ops->flow_pool_map_handler(soc, pdev, vdev_id); 146 } 147 148 /** 149 * cdp_flow_pool_unmap() - Delete flow pool 150 * @soc - data path soc handle 151 * @pdev 152 * @vdev_id - vdev_id corresponding to vdev start 153 * 154 * Delete flow pool 155 * 156 * return none 157 */ 158 static inline void cdp_flow_pool_unmap(ol_txrx_soc_handle soc, 159 struct cdp_pdev *pdev, uint8_t vdev_id) 160 { 161 if (!soc || !soc->ops) { 162 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 163 "%s: Invalid Instance:", __func__); 164 QDF_BUG(0); 165 return; 166 } 167 168 if (!soc->ops->flowctl_ops || 169 !soc->ops->flowctl_ops->flow_pool_unmap_handler) 170 return; 171 172 return soc->ops->flowctl_ops->flow_pool_unmap_handler(soc, pdev, 173 vdev_id); 174 } 175 #endif 176 177 static inline void 178 cdp_vdev_detach(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 179 ol_txrx_vdev_delete_cb callback, void *cb_context) 180 { 181 if (!soc || !soc->ops) { 182 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 183 "%s: Invalid Instance:", __func__); 184 QDF_BUG(0); 185 return; 186 } 187 188 if (!soc->ops->cmn_drv_ops || 189 !soc->ops->cmn_drv_ops->txrx_vdev_detach) 190 return; 191 192 soc->ops->cmn_drv_ops->txrx_vdev_detach(vdev, 193 callback, cb_context); 194 } 195 196 static inline int 197 cdp_pdev_attach_target(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 198 { 199 if (!soc || !soc->ops) { 200 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 201 "%s: Invalid Instance:", __func__); 202 QDF_BUG(0); 203 return 0; 204 } 205 206 if (!soc->ops->cmn_drv_ops || 207 !soc->ops->cmn_drv_ops->txrx_pdev_attach_target) 208 return 0; 209 210 return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(pdev); 211 } 212 213 static inline struct cdp_pdev *cdp_pdev_attach 214 (ol_txrx_soc_handle soc, struct cdp_ctrl_objmgr_pdev *ctrl_pdev, 215 HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id) 216 { 217 if (!soc || !soc->ops) { 218 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 219 "%s: Invalid Instance:", __func__); 220 QDF_BUG(0); 221 return NULL; 222 } 223 224 if (!soc->ops->cmn_drv_ops || 225 !soc->ops->cmn_drv_ops->txrx_pdev_attach) 226 return NULL; 227 228 return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, ctrl_pdev, 229 htc_pdev, osdev, pdev_id); 230 } 231 232 static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, 233 struct cdp_pdev *pdev) 234 { 235 if (!soc || !soc->ops) { 236 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 237 "%s: Invalid Instance:", __func__); 238 QDF_BUG(0); 239 return 0; 240 } 241 242 if (!soc->ops->cmn_drv_ops || 243 !soc->ops->cmn_drv_ops->txrx_pdev_post_attach) 244 return 0; 245 246 return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(pdev); 247 } 248 249 static inline void 250 cdp_pdev_pre_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 251 { 252 if (!soc || !soc->ops) { 253 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 254 "%s: Invalid Instance:", __func__); 255 QDF_BUG(0); 256 return; 257 } 258 259 if (!soc->ops->cmn_drv_ops || 260 !soc->ops->cmn_drv_ops->txrx_pdev_pre_detach) 261 return; 262 263 soc->ops->cmn_drv_ops->txrx_pdev_pre_detach(pdev, force); 264 } 265 266 static inline void 267 cdp_pdev_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 268 { 269 if (!soc || !soc->ops) { 270 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 271 "%s: Invalid Instance:", __func__); 272 QDF_BUG(0); 273 return; 274 } 275 276 if (!soc->ops->cmn_drv_ops || 277 !soc->ops->cmn_drv_ops->txrx_pdev_detach) 278 return; 279 280 soc->ops->cmn_drv_ops->txrx_pdev_detach(pdev, force); 281 } 282 283 static inline void 284 cdp_pdev_deinit(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 285 { 286 if (!soc || !soc->ops) { 287 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 288 "%s: Invalid Instance:", __func__); 289 QDF_BUG(0); 290 return; 291 } 292 293 if (!soc->ops->cmn_drv_ops || 294 !soc->ops->cmn_drv_ops->txrx_pdev_deinit) 295 return; 296 297 soc->ops->cmn_drv_ops->txrx_pdev_deinit(pdev, force); 298 } 299 300 static inline void *cdp_peer_create 301 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 302 uint8_t *peer_mac_addr, struct cdp_ctrl_objmgr_peer *ctrl_peer) 303 { 304 if (!soc || !soc->ops) { 305 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 306 "%s: Invalid Instance:", __func__); 307 QDF_BUG(0); 308 return NULL; 309 } 310 311 if (!soc->ops->cmn_drv_ops || 312 !soc->ops->cmn_drv_ops->txrx_peer_create) 313 return NULL; 314 315 return soc->ops->cmn_drv_ops->txrx_peer_create(vdev, 316 peer_mac_addr, ctrl_peer); 317 } 318 319 static inline void cdp_peer_setup 320 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 321 { 322 if (!soc || !soc->ops) { 323 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 324 "%s: Invalid Instance:", __func__); 325 QDF_BUG(0); 326 return; 327 } 328 329 if (!soc->ops->cmn_drv_ops || 330 !soc->ops->cmn_drv_ops->txrx_peer_setup) 331 return; 332 333 soc->ops->cmn_drv_ops->txrx_peer_setup(vdev, 334 peer); 335 } 336 337 /** 338 * cdp_peer_get_ast_info_by_soc() - search the soc AST hash table 339 * and return ast entry information 340 * of first ast entry found in the 341 * table with given mac address 342 * 343 * @soc - data path soc handle 344 * @ast_mac_addr - AST entry mac address 345 * @ast_entry_info - ast entry information 346 * 347 * return - true if ast entry found with ast_mac_addr 348 * false if ast entry not found 349 */ 350 static inline bool cdp_peer_get_ast_info_by_soc 351 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 352 struct cdp_ast_entry_info *ast_entry_info) 353 { 354 if (!soc || !soc->ops) { 355 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 356 "%s: Invalid Instance:", __func__); 357 QDF_BUG(0); 358 return false; 359 } 360 361 if (!soc->ops->cmn_drv_ops || 362 !soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_soc) 363 return false; 364 365 return soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_soc 366 (soc, ast_mac_addr, 367 ast_entry_info); 368 } 369 370 /** 371 * cdp_peer_get_ast_info_by_pdev() - search the soc AST hash table 372 * and return ast entry information 373 * if mac address and pdev_id matches 374 * 375 * @soc - data path soc handle 376 * @ast_mac_addr - AST entry mac address 377 * @pdev_id - pdev_id 378 * @ast_entry_info - ast entry information 379 * 380 * return - true if ast entry found with ast_mac_addr 381 * false if ast entry not found 382 */ 383 static inline bool cdp_peer_get_ast_info_by_pdev 384 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 385 uint8_t pdev_id, 386 struct cdp_ast_entry_info *ast_entry_info) 387 { 388 if (!soc || !soc->ops) { 389 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 390 "%s: Invalid Instance:", __func__); 391 QDF_BUG(0); 392 return false; 393 } 394 395 if (!soc->ops->cmn_drv_ops || 396 !soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_pdev) 397 return false; 398 399 return soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_pdev 400 (soc, 401 ast_mac_addr, 402 pdev_id, 403 ast_entry_info); 404 } 405 406 /** 407 * cdp_peer_ast_delete_by_soc() - delete the ast entry from soc AST hash table 408 * with given mac address 409 * 410 * @soc - data path soc handle 411 * @ast_mac_addr - AST entry mac address 412 * @callback - callback function to called on ast delete response from FW 413 * @cookie - argument to be passed to callback 414 * 415 * return - QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 416 * is sent 417 * QDF_STATUS_E_INVAL false if ast entry not found 418 */ 419 static inline QDF_STATUS cdp_peer_ast_delete_by_soc 420 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 421 txrx_ast_free_cb callback, 422 void *cookie) 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 QDF_STATUS_E_INVAL; 429 } 430 431 if (!soc->ops->cmn_drv_ops || 432 !soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_soc) 433 return QDF_STATUS_E_INVAL; 434 435 return soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_soc 436 (soc, 437 ast_mac_addr, 438 callback, 439 cookie); 440 } 441 442 /** 443 * cdp_peer_ast_delete_by_pdev() - delete the ast entry from soc AST hash table 444 * if mac address and pdev_id matches 445 * 446 * @soc - data path soc handle 447 * @ast_mac_addr - AST entry mac address 448 * @pdev_id - pdev id 449 * @callback - callback function to called on ast delete response from FW 450 * @cookie - argument to be passed to callback 451 * 452 * return - QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 453 * is sent 454 * QDF_STATUS_E_INVAL false if ast entry not found 455 */ 456 static inline QDF_STATUS cdp_peer_ast_delete_by_pdev 457 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 458 uint8_t pdev_id, txrx_ast_free_cb callback, 459 void *cookie) 460 { 461 if (!soc || !soc->ops) { 462 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 463 "%s: Invalid Instance:", __func__); 464 QDF_BUG(0); 465 return QDF_STATUS_E_INVAL; 466 } 467 468 if (!soc->ops->cmn_drv_ops || 469 !soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_pdev) 470 return QDF_STATUS_E_INVAL; 471 472 return soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_pdev 473 (soc, 474 ast_mac_addr, 475 pdev_id, 476 callback, 477 cookie); 478 } 479 480 static inline int cdp_peer_add_ast 481 (ol_txrx_soc_handle soc, struct cdp_peer *peer_handle, 482 uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, uint32_t flags) 483 { 484 if (!soc || !soc->ops) { 485 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 486 "%s: Invalid Instance:", __func__); 487 QDF_BUG(0); 488 return 0; 489 } 490 491 if (!soc->ops->cmn_drv_ops || 492 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 493 return 0; 494 495 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 496 peer_handle, 497 mac_addr, 498 type, 499 flags); 500 } 501 502 static inline void cdp_peer_reset_ast 503 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, void *vdev_hdl) 504 { 505 506 if (!soc || !soc->ops) { 507 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 508 "%s: Invalid Instance:", __func__); 509 QDF_BUG(0); 510 return; 511 } 512 if (!soc->ops->cmn_drv_ops || 513 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast) 514 return; 515 516 soc->ops->cmn_drv_ops->txrx_peer_reset_ast(soc, wds_macaddr, vdev_hdl); 517 } 518 519 static inline void cdp_peer_reset_ast_table 520 (ol_txrx_soc_handle soc, void *vdev_hdl) 521 { 522 if (!soc || !soc->ops) { 523 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 524 "%s: Invalid Instance:", __func__); 525 QDF_BUG(0); 526 return; 527 } 528 529 if (!soc->ops->cmn_drv_ops || 530 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table) 531 return; 532 533 soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table(soc, vdev_hdl); 534 } 535 536 static inline void cdp_peer_flush_ast_table 537 (ol_txrx_soc_handle soc) 538 { 539 if (!soc || !soc->ops) { 540 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 541 "%s: Invalid Instance:", __func__); 542 QDF_BUG(0); 543 return; 544 } 545 546 if (!soc->ops->cmn_drv_ops || 547 !soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table) 548 return; 549 550 soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table(soc); 551 } 552 553 static inline int cdp_peer_update_ast 554 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, 555 struct cdp_peer *peer_handle, uint32_t flags) 556 { 557 if (!soc || !soc->ops) { 558 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 559 "%s: Invalid Instance:", __func__); 560 QDF_BUG(0); 561 return 0; 562 } 563 564 if (!soc->ops->cmn_drv_ops || 565 !soc->ops->cmn_drv_ops->txrx_peer_update_ast) 566 return 0; 567 568 569 return soc->ops->cmn_drv_ops->txrx_peer_update_ast(soc, 570 peer_handle, 571 wds_macaddr, 572 flags); 573 } 574 575 static inline void cdp_peer_teardown 576 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 577 { 578 if (!soc || !soc->ops) { 579 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 580 "%s: Invalid Instance:", __func__); 581 QDF_BUG(0); 582 return; 583 } 584 585 if (!soc->ops->cmn_drv_ops || 586 !soc->ops->cmn_drv_ops->txrx_peer_teardown) 587 return; 588 589 soc->ops->cmn_drv_ops->txrx_peer_teardown(vdev, peer); 590 } 591 592 static inline void 593 cdp_vdev_flush_peers(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 594 bool unmap_only) 595 { 596 if (!soc || !soc->ops) { 597 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 598 "%s: Invalid Instance:", __func__); 599 QDF_BUG(0); 600 return; 601 } 602 603 if (!soc->ops->cmn_drv_ops || 604 !soc->ops->cmn_drv_ops->txrx_vdev_flush_peers) 605 return; 606 607 soc->ops->cmn_drv_ops->txrx_vdev_flush_peers(vdev, unmap_only); 608 } 609 610 static inline void 611 cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 612 { 613 if (!soc || !soc->ops) { 614 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 615 "%s: Invalid Instance:", __func__); 616 QDF_BUG(0); 617 return; 618 } 619 620 if (!soc->ops->cmn_drv_ops || 621 !soc->ops->cmn_drv_ops->txrx_peer_delete) 622 return; 623 624 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 625 } 626 627 static inline void 628 cdp_peer_delete_sync(ol_txrx_soc_handle soc, void *peer, 629 QDF_STATUS(*delete_cb)( 630 uint8_t vdev_id, 631 uint32_t peerid_cnt, 632 uint16_t *peerid_list), 633 uint32_t bitmap) 634 { 635 if (!soc || !soc->ops) { 636 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 637 "%s: Invalid Instance:", __func__); 638 QDF_BUG(0); 639 return; 640 } 641 642 if (!soc->ops->cmn_drv_ops || 643 !soc->ops->cmn_drv_ops->txrx_peer_delete_sync) 644 return; 645 646 soc->ops->cmn_drv_ops->txrx_peer_delete_sync(peer, 647 delete_cb, 648 bitmap); 649 } 650 651 static inline int 652 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 653 uint8_t smart_monitor) 654 { 655 if (!soc || !soc->ops) { 656 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 657 "%s: Invalid Instance:", __func__); 658 QDF_BUG(0); 659 return 0; 660 } 661 662 if (!soc->ops->cmn_drv_ops || 663 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 664 return 0; 665 666 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 667 smart_monitor); 668 } 669 670 static inline void 671 cdp_set_curchan(ol_txrx_soc_handle soc, 672 struct cdp_pdev *pdev, 673 uint32_t chan_mhz) 674 { 675 if (!soc || !soc->ops) { 676 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 677 "%s: Invalid Instance:", __func__); 678 QDF_BUG(0); 679 return; 680 } 681 682 if (!soc->ops->cmn_drv_ops || 683 !soc->ops->cmn_drv_ops->txrx_set_curchan) 684 return; 685 686 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 687 } 688 689 static inline void 690 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 691 void *filter, uint32_t num) 692 { 693 if (!soc || !soc->ops) { 694 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 695 "%s: Invalid Instance:", __func__); 696 QDF_BUG(0); 697 return; 698 } 699 700 if (!soc->ops->cmn_drv_ops || 701 !soc->ops->cmn_drv_ops->txrx_set_privacy_filters) 702 return; 703 704 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 705 filter, num); 706 } 707 708 static inline int 709 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 710 struct cdp_monitor_filter *filter_val) 711 { 712 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 713 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 714 filter_val); 715 return 0; 716 } 717 718 719 /****************************************************************************** 720 * Data Interface (B Interface) 721 *****************************************************************************/ 722 static inline void 723 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 724 void *osif_vdev, struct cdp_ctrl_objmgr_vdev *ctrl_vdev, 725 struct ol_txrx_ops *txrx_ops) 726 { 727 if (!soc || !soc->ops) { 728 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 729 "%s: Invalid Instance:", __func__); 730 QDF_BUG(0); 731 return; 732 } 733 734 if (!soc->ops->cmn_drv_ops || 735 !soc->ops->cmn_drv_ops->txrx_vdev_register) 736 return; 737 738 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 739 osif_vdev, ctrl_vdev, txrx_ops); 740 } 741 742 static inline int 743 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 744 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 745 { 746 if (!soc || !soc->ops) { 747 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 748 "%s: Invalid Instance:", __func__); 749 QDF_BUG(0); 750 return 0; 751 } 752 753 if (!soc->ops->cmn_drv_ops || 754 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 755 return 0; 756 757 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 758 tx_mgmt_frm, type); 759 } 760 761 static inline int 762 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 763 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 764 uint8_t use_6mbps, uint16_t chanfreq) 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_mgmt_send_ext) 775 return 0; 776 777 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 778 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 779 } 780 781 782 static inline void 783 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 784 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 785 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 786 { 787 if (!soc || !soc->ops) { 788 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 789 "%s: Invalid Instance:", __func__); 790 QDF_BUG(0); 791 return; 792 } 793 794 if (!soc->ops->cmn_drv_ops || 795 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 796 return; 797 798 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 799 (pdev, type, download_cb, ota_ack_cb, ctxt); 800 } 801 802 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 803 struct cdp_pdev *pdev) 804 { 805 if (!soc || !soc->ops) { 806 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 807 "%s: Invalid Instance:", __func__); 808 QDF_BUG(0); 809 return 0; 810 } 811 812 if (!soc->ops->cmn_drv_ops || 813 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 814 return 0; 815 816 817 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 818 } 819 820 static inline void 821 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 822 ol_txrx_data_tx_cb callback, void *ctxt) 823 { 824 if (!soc || !soc->ops) { 825 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 826 "%s: Invalid Instance:", __func__); 827 QDF_BUG(0); 828 return; 829 } 830 831 if (!soc->ops->cmn_drv_ops || 832 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 833 return; 834 835 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 836 callback, ctxt); 837 } 838 839 /****************************************************************************** 840 * Statistics and Debugging Interface (C Interface) 841 *****************************************************************************/ 842 /** 843 * External Device physical address types 844 * 845 * Currently, both MAC and IPA uController use the same size addresses 846 * and descriptors are exchanged between these two depending on the mode. 847 * 848 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 849 * operations. However, external device physical address sizes 850 * may be different from host-specific physical address sizes. 851 * This calls for the following definitions for target devices 852 * (MAC, IPA uc). 853 */ 854 #if HTT_PADDR64 855 typedef uint64_t target_paddr_t; 856 #else 857 typedef uint32_t target_paddr_t; 858 #endif /*HTT_PADDR64 */ 859 860 static inline int 861 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 862 int max_subfrms_ampdu, 863 int max_subfrms_amsdu) 864 { 865 if (!soc || !soc->ops) { 866 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 867 "%s: Invalid Instance:", __func__); 868 QDF_BUG(0); 869 return 0; 870 } 871 872 if (!soc->ops->cmn_drv_ops || 873 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 874 return 0; 875 876 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 877 max_subfrms_ampdu, max_subfrms_amsdu); 878 } 879 880 static inline int 881 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 882 struct ol_txrx_stats_req *req, bool per_vdev, 883 bool response_expected) 884 { 885 if (!soc || !soc->ops) { 886 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 887 "%s: Invalid Instance:", __func__); 888 QDF_BUG(0); 889 return 0; 890 } 891 892 if (!soc->ops->cmn_drv_ops || 893 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 894 return 0; 895 896 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 897 per_vdev, response_expected); 898 } 899 900 static inline int 901 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 902 { 903 if (!soc || !soc->ops) { 904 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 905 "%s: Invalid Instance:", __func__); 906 QDF_BUG(0); 907 return 0; 908 } 909 910 if (!soc->ops->cmn_drv_ops || 911 !soc->ops->cmn_drv_ops->txrx_debug) 912 return 0; 913 914 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 915 } 916 917 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 918 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 919 { 920 if (!soc || !soc->ops) { 921 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 922 "%s: Invalid Instance:", __func__); 923 QDF_BUG(0); 924 return; 925 } 926 927 if (!soc->ops->cmn_drv_ops || 928 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 929 return; 930 931 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 932 cfg_stats_type, cfg_val); 933 } 934 935 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 936 { 937 if (!soc || !soc->ops) { 938 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 939 "%s: Invalid Instance:", __func__); 940 QDF_BUG(0); 941 return; 942 } 943 944 if (!soc->ops->cmn_drv_ops || 945 !soc->ops->cmn_drv_ops->txrx_print_level_set) 946 return; 947 948 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 949 } 950 951 static inline uint8_t * 952 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 953 { 954 if (!soc || !soc->ops) { 955 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 956 "%s: Invalid Instance:", __func__); 957 QDF_BUG(0); 958 return NULL; 959 } 960 961 if (!soc->ops->cmn_drv_ops || 962 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 963 return NULL; 964 965 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 966 967 } 968 969 /** 970 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 971 * vdev 972 * @vdev: vdev handle 973 * 974 * Return: Handle to struct qdf_mac_addr 975 */ 976 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 977 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 978 { 979 if (!soc || !soc->ops) { 980 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 981 "%s: Invalid Instance:", __func__); 982 QDF_BUG(0); 983 return NULL; 984 } 985 986 if (!soc->ops->cmn_drv_ops || 987 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 988 return NULL; 989 990 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 991 (vdev); 992 993 } 994 995 /** 996 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 997 * @vdev: vdev handle 998 * 999 * Return: Handle to pdev 1000 */ 1001 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 1002 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 1003 { 1004 if (!soc || !soc->ops) { 1005 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1006 "%s: Invalid Instance:", __func__); 1007 QDF_BUG(0); 1008 return NULL; 1009 } 1010 1011 if (!soc->ops->cmn_drv_ops || 1012 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 1013 return NULL; 1014 1015 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 1016 } 1017 1018 /** 1019 * cdp_get_os_rx_handles_from_vdev() - Return os rx handles for a vdev 1020 * @soc: ol_txrx_soc_handle handle 1021 * @vdev: vdev for which os rx handles are needed 1022 * @stack_fn_p: pointer to stack function pointer 1023 * @osif_handle_p: pointer to ol_osif_vdev_handle 1024 * 1025 * Return: void 1026 */ 1027 static inline 1028 void cdp_get_os_rx_handles_from_vdev(ol_txrx_soc_handle soc, 1029 struct cdp_vdev *vdev, 1030 ol_txrx_rx_fp *stack_fn_p, 1031 ol_osif_vdev_handle *osif_handle_p) 1032 { 1033 if (!soc || !soc->ops) { 1034 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1035 "%s: Invalid Instance:", __func__); 1036 QDF_BUG(0); 1037 return; 1038 } 1039 1040 if (!soc->ops->cmn_drv_ops || 1041 !soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev) 1042 return; 1043 1044 soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev(vdev, 1045 stack_fn_p, 1046 osif_handle_p); 1047 } 1048 1049 /** 1050 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 1051 * @vdev: vdev handle 1052 * 1053 * Return: Handle to control pdev 1054 */ 1055 static inline struct cdp_cfg * 1056 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 1057 { 1058 if (!soc || !soc->ops) { 1059 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1060 "%s: Invalid Instance:", __func__); 1061 QDF_BUG(0); 1062 return NULL; 1063 } 1064 1065 if (!soc->ops->cmn_drv_ops || 1066 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 1067 return NULL; 1068 1069 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 1070 (vdev); 1071 } 1072 1073 static inline struct cdp_vdev * 1074 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 1075 uint8_t vdev_id) 1076 { 1077 if (!soc || !soc->ops) { 1078 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1079 "%s: Invalid Instance:", __func__); 1080 QDF_BUG(0); 1081 return NULL; 1082 } 1083 1084 if (!soc->ops->cmn_drv_ops || 1085 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 1086 return NULL; 1087 1088 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 1089 (pdev, vdev_id); 1090 } 1091 1092 static inline struct cdp_vdev * 1093 cdp_get_mon_vdev_from_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 1094 { 1095 if (!soc || !soc->ops) { 1096 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1097 "%s: Invalid Instance:", __func__); 1098 QDF_BUG(0); 1099 return NULL; 1100 } 1101 1102 if (!soc->ops->cmn_drv_ops || 1103 !soc->ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev) 1104 return NULL; 1105 1106 return soc->ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev 1107 (pdev); 1108 } 1109 1110 static inline void 1111 cdp_soc_detach(ol_txrx_soc_handle soc) 1112 { 1113 if (!soc || !soc->ops) { 1114 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1115 "%s: Invalid Instance:", __func__); 1116 QDF_BUG(0); 1117 return; 1118 } 1119 1120 if (!soc->ops->cmn_drv_ops || 1121 !soc->ops->cmn_drv_ops->txrx_soc_detach) 1122 return; 1123 1124 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 1125 } 1126 1127 /** 1128 * cdp_soc_init() - Initialize txrx SOC 1129 * @soc: ol_txrx_soc_handle handle 1130 * @devid: Device ID 1131 * @hif_handle: Opaque HIF handle 1132 * @psoc: Opaque Objmgr handle 1133 * @htc_handle: Opaque HTC handle 1134 * @qdf_dev: QDF device 1135 * @dp_ol_if_ops: Offload Operations 1136 * 1137 * Return: DP SOC handle on success, NULL on failure 1138 */ 1139 static inline ol_txrx_soc_handle 1140 cdp_soc_init(ol_txrx_soc_handle soc, u_int16_t devid, void *hif_handle, 1141 void *psoc, void *htc_handle, qdf_device_t qdf_dev, 1142 struct ol_if_ops *dp_ol_if_ops) 1143 { 1144 if (!soc || !soc->ops) { 1145 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1146 "%s: Invalid Instance:", __func__); 1147 QDF_BUG(0); 1148 return NULL; 1149 } 1150 1151 if (!soc->ops->cmn_drv_ops || 1152 !soc->ops->cmn_drv_ops->txrx_soc_init) 1153 return NULL; 1154 1155 return soc->ops->cmn_drv_ops->txrx_soc_init(soc, psoc, 1156 hif_handle, 1157 htc_handle, qdf_dev, 1158 dp_ol_if_ops, devid); 1159 } 1160 1161 /** 1162 * cdp_soc_deinit() - Deinitialize txrx SOC 1163 * @soc: Opaque DP SOC handle 1164 * 1165 * Return: None 1166 */ 1167 static inline void 1168 cdp_soc_deinit(ol_txrx_soc_handle soc) 1169 { 1170 if (!soc || !soc->ops) { 1171 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1172 "%s: Invalid Instance:", __func__); 1173 QDF_BUG(0); 1174 return; 1175 } 1176 1177 if (!soc->ops->cmn_drv_ops || 1178 !soc->ops->cmn_drv_ops->txrx_soc_deinit) 1179 return; 1180 1181 soc->ops->cmn_drv_ops->txrx_soc_deinit((void *)soc); 1182 } 1183 1184 /** 1185 * cdp_tso_soc_attach() - TSO attach function 1186 * @soc: ol_txrx_soc_handle handle 1187 * 1188 * Reserve TSO descriptor buffers 1189 * 1190 * Return: QDF_STATUS_SUCCESS on Success or 1191 * QDF_STATUS_E_FAILURE on failure 1192 */ 1193 static inline QDF_STATUS 1194 cdp_tso_soc_attach(ol_txrx_soc_handle soc) 1195 { 1196 if (!soc || !soc->ops) { 1197 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1198 "%s: Invalid Instance:", __func__); 1199 QDF_BUG(0); 1200 return 0; 1201 } 1202 1203 if (!soc->ops->cmn_drv_ops || 1204 !soc->ops->cmn_drv_ops->txrx_tso_soc_attach) 1205 return 0; 1206 1207 return soc->ops->cmn_drv_ops->txrx_tso_soc_attach((void *)soc); 1208 } 1209 1210 /** 1211 * cdp_tso_soc_detach() - TSO detach function 1212 * @soc: ol_txrx_soc_handle handle 1213 * 1214 * Release TSO descriptor buffers 1215 * 1216 * Return: QDF_STATUS_SUCCESS on Success or 1217 * QDF_STATUS_E_FAILURE on failure 1218 */ 1219 static inline QDF_STATUS 1220 cdp_tso_soc_detach(ol_txrx_soc_handle soc) 1221 { 1222 if (!soc || !soc->ops) { 1223 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1224 "%s: Invalid Instance:", __func__); 1225 QDF_BUG(0); 1226 return 0; 1227 } 1228 1229 if (!soc->ops->cmn_drv_ops || 1230 !soc->ops->cmn_drv_ops->txrx_tso_soc_detach) 1231 return 0; 1232 1233 return soc->ops->cmn_drv_ops->txrx_tso_soc_detach((void *)soc); 1234 } 1235 1236 /** 1237 * cdp_addba_resp_tx_completion() - Indicate addba response tx 1238 * completion to dp to change tid state. 1239 * @soc: soc handle 1240 * @peer_handle: peer handle 1241 * @tid: tid 1242 * @status: Tx completion status 1243 * 1244 * Return: success/failure of tid update 1245 */ 1246 static inline int cdp_addba_resp_tx_completion(ol_txrx_soc_handle soc, 1247 void *peer_handle, 1248 uint8_t tid, int status) 1249 { 1250 if (!soc || !soc->ops) { 1251 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1252 "%s: Invalid Instance:", __func__); 1253 QDF_BUG(0); 1254 return 0; 1255 } 1256 1257 if (!soc->ops->cmn_drv_ops || 1258 !soc->ops->cmn_drv_ops->addba_resp_tx_completion) 1259 return 0; 1260 1261 return soc->ops->cmn_drv_ops->addba_resp_tx_completion(peer_handle, tid, 1262 status); 1263 } 1264 1265 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 1266 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 1267 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 1268 { 1269 if (!soc || !soc->ops) { 1270 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1271 "%s: Invalid Instance:", __func__); 1272 QDF_BUG(0); 1273 return 0; 1274 } 1275 1276 if (!soc->ops->cmn_drv_ops || 1277 !soc->ops->cmn_drv_ops->addba_requestprocess) 1278 return 0; 1279 1280 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 1281 dialogtoken, tid, batimeout, buffersize, startseqnum); 1282 } 1283 1284 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 1285 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 1286 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 1287 { 1288 if (!soc || !soc->ops) { 1289 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1290 "%s: Invalid Instance:", __func__); 1291 QDF_BUG(0); 1292 return; 1293 } 1294 1295 if (!soc->ops->cmn_drv_ops || 1296 !soc->ops->cmn_drv_ops->addba_responsesetup) 1297 return; 1298 1299 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 1300 dialogtoken, statuscode, buffersize, batimeout); 1301 } 1302 1303 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 1304 void *peer_handle, int tid, uint16_t reasoncode) 1305 { 1306 if (!soc || !soc->ops) { 1307 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1308 "%s: Invalid Instance:", __func__); 1309 QDF_BUG(0); 1310 return 0; 1311 } 1312 1313 if (!soc->ops->cmn_drv_ops || 1314 !soc->ops->cmn_drv_ops->delba_process) 1315 return 0; 1316 1317 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 1318 tid, reasoncode); 1319 } 1320 1321 /** 1322 * cdp_delba_tx_completion() - Handle delba tx completion 1323 * to update stats and retry transmission if failed. 1324 * @soc: soc handle 1325 * @peer_handle: peer handle 1326 * @tid: Tid number 1327 * @status: Tx completion status 1328 * 1329 * Return: 0 on Success, 1 on failure 1330 */ 1331 1332 static inline int cdp_delba_tx_completion(ol_txrx_soc_handle soc, 1333 void *peer_handle, 1334 uint8_t tid, int status) 1335 { 1336 if (!soc || !soc->ops) { 1337 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1338 "%s: Invalid Instance:", __func__); 1339 QDF_BUG(0); 1340 return 0; 1341 } 1342 1343 if (!soc->ops->cmn_drv_ops || 1344 !soc->ops->cmn_drv_ops->delba_tx_completion) 1345 return 0; 1346 1347 return soc->ops->cmn_drv_ops->delba_tx_completion(peer_handle, 1348 tid, status); 1349 } 1350 1351 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1352 void *peer_handle, int tid, uint16_t statuscode) 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; 1359 } 1360 1361 if (!soc->ops->cmn_drv_ops || 1362 !soc->ops->cmn_drv_ops->set_addba_response) 1363 return; 1364 1365 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1366 } 1367 1368 /** 1369 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1370 * mac address 1371 * @soc: SOC handle 1372 * @peer_id: peer id of the peer for which mac_address is required 1373 * @mac_addr: reference to mac address 1374 * 1375 * reutm: vdev_id of the vap 1376 */ 1377 static inline uint8_t 1378 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1379 uint8_t *mac_addr) 1380 { 1381 if (!soc || !soc->ops) { 1382 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1383 "%s: Invalid Instance:", __func__); 1384 QDF_BUG(0); 1385 return CDP_INVALID_VDEV_ID; 1386 } 1387 1388 if (!soc->ops->cmn_drv_ops || 1389 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1390 return CDP_INVALID_VDEV_ID; 1391 1392 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1393 peer_id, mac_addr); 1394 } 1395 1396 /** 1397 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1398 * @vdev: vdev handle 1399 * @map_id: id of the tid map 1400 * 1401 * Return: void 1402 */ 1403 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1404 struct cdp_vdev *vdev, uint8_t map_id) 1405 { 1406 if (!soc || !soc->ops) { 1407 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1408 "%s: Invalid Instance:", __func__); 1409 QDF_BUG(0); 1410 return; 1411 } 1412 1413 if (!soc->ops->cmn_drv_ops || 1414 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1415 return; 1416 1417 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1418 map_id); 1419 } 1420 1421 /** 1422 * cdp_ath_get_total_per(): function to get hw retries 1423 * @soc : soc handle 1424 * @pdev: pdev handle 1425 * 1426 * Return: get hw retries 1427 */ 1428 static inline 1429 int cdp_ath_get_total_per(ol_txrx_soc_handle soc, 1430 struct cdp_pdev *pdev) 1431 { 1432 if (!soc || !soc->ops) { 1433 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1434 "%s: Invalid Instance:", __func__); 1435 QDF_BUG(0); 1436 return 0; 1437 } 1438 1439 if (!soc->ops->cmn_drv_ops || 1440 !soc->ops->cmn_drv_ops->txrx_get_total_per) 1441 return 0; 1442 1443 return soc->ops->cmn_drv_ops->txrx_get_total_per(pdev); 1444 } 1445 1446 /** 1447 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1448 * @pdev: pdev handle 1449 * @map_id: id of the tid map 1450 * @tos: index value in map that needs to be changed 1451 * @tid: tid value passed by user 1452 * 1453 * Return: void 1454 */ 1455 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1456 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 1457 { 1458 if (!soc || !soc->ops) { 1459 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1460 "%s: Invalid Instance:", __func__); 1461 QDF_BUG(0); 1462 return; 1463 } 1464 1465 if (!soc->ops->cmn_drv_ops || 1466 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1467 return; 1468 1469 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1470 map_id, tos, tid); 1471 } 1472 1473 /** 1474 * cdp_hmmc_tid_override_en(): Function to enable hmmc tid override. 1475 * @soc : soc handle 1476 * @pdev: pdev handle 1477 * @val: hmmc-dscp flag value 1478 * 1479 * Return: void 1480 */ 1481 static inline void cdp_hmmc_tid_override_en(ol_txrx_soc_handle soc, 1482 struct cdp_pdev *pdev, bool val) 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->hmmc_tid_override_en) 1493 return; 1494 1495 soc->ops->cmn_drv_ops->hmmc_tid_override_en(pdev, val); 1496 } 1497 1498 /** 1499 * cdp_set_hmmc_tid_val(): Function to set hmmc tid value. 1500 * @soc : soc handle 1501 * @pdev: pdev handle 1502 * @tid: tid value 1503 * 1504 * Return: void 1505 */ 1506 static inline void cdp_set_hmmc_tid_val(ol_txrx_soc_handle soc, 1507 struct cdp_pdev *pdev, uint8_t tid) 1508 { 1509 if (!soc || !soc->ops) { 1510 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1511 "%s: Invalid Instance:", __func__); 1512 QDF_BUG(0); 1513 return; 1514 } 1515 1516 if (!soc->ops->cmn_drv_ops || 1517 !soc->ops->cmn_drv_ops->set_hmmc_tid_val) 1518 return; 1519 1520 soc->ops->cmn_drv_ops->set_hmmc_tid_val(pdev, tid); 1521 } 1522 1523 /** 1524 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1525 * 1526 * Return: None 1527 */ 1528 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1529 { 1530 if (!soc || !soc->ops) { 1531 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1532 "%s: Invalid Instance:", __func__); 1533 QDF_BUG(0); 1534 return; 1535 } 1536 1537 if (!soc->ops->cmn_drv_ops || 1538 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1539 return; 1540 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1541 } 1542 1543 /** 1544 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1545 * @soc: soc handle 1546 * @vdev: virtual device 1547 * @req: stats request container 1548 * 1549 * return: status 1550 */ 1551 static inline 1552 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1553 struct cdp_txrx_stats_req *req) 1554 { 1555 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1556 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1557 "%s: Invalid Instance:", __func__); 1558 QDF_ASSERT(0); 1559 return 0; 1560 } 1561 1562 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1563 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1564 1565 return 0; 1566 } 1567 1568 /** 1569 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1570 * @soc: soc handle 1571 */ 1572 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1573 { 1574 if (!soc || !soc->ops) { 1575 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1576 "%s: Invalid Instance:", __func__); 1577 QDF_BUG(0); 1578 return 0; 1579 } 1580 1581 if (!soc->ops->cmn_drv_ops || 1582 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1583 return 0; 1584 1585 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1586 } 1587 1588 /** 1589 * cdp_txrx_intr_detach(): function to detach interrupt 1590 * @soc: soc handle 1591 */ 1592 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1593 { 1594 if (!soc || !soc->ops) { 1595 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1596 "%s: Invalid Instance:", __func__); 1597 QDF_BUG(0); 1598 return; 1599 } 1600 1601 if (!soc->ops->cmn_drv_ops || 1602 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1603 return; 1604 1605 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1606 } 1607 1608 /** 1609 * cdp_display_stats(): function to map to dump stats 1610 * @soc: soc handle 1611 * @value: statistics option 1612 */ 1613 static inline QDF_STATUS 1614 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1615 enum qdf_stats_verbosity_level level) 1616 { 1617 if (!soc || !soc->ops) { 1618 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1619 "%s: Invalid Instance:", __func__); 1620 QDF_BUG(0); 1621 return 0; 1622 } 1623 1624 if (!soc->ops->cmn_drv_ops || 1625 !soc->ops->cmn_drv_ops->display_stats) 1626 return 0; 1627 1628 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1629 } 1630 1631 1632 /** 1633 * cdp_set_pn_check(): function to set pn check 1634 * @soc: soc handle 1635 * @sec_type: security type 1636 * #rx_pn: receive pn 1637 */ 1638 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1639 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1640 { 1641 if (!soc || !soc->ops) { 1642 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1643 "%s: Invalid Instance:", __func__); 1644 QDF_BUG(0); 1645 return 0; 1646 } 1647 1648 if (!soc->ops->cmn_drv_ops || 1649 !soc->ops->cmn_drv_ops->set_pn_check) 1650 return 0; 1651 1652 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1653 sec_type, rx_pn); 1654 return 0; 1655 } 1656 1657 static inline int cdp_set_key(ol_txrx_soc_handle soc, 1658 struct cdp_peer *peer_handle, 1659 bool is_unicast, uint32_t *key) 1660 { 1661 if (!soc || !soc->ops) { 1662 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1663 "%s: Invalid Instance:", __func__); 1664 QDF_BUG(0); 1665 return 0; 1666 } 1667 1668 if (!soc->ops->ctrl_ops || 1669 !soc->ops->ctrl_ops->set_key) 1670 return 0; 1671 1672 soc->ops->ctrl_ops->set_key(peer_handle, 1673 is_unicast, key); 1674 return 0; 1675 } 1676 1677 /** 1678 * cdp_update_config_parameters(): function to propagate configuration 1679 * parameters to datapath 1680 * @soc: opaque soc handle 1681 * @cfg: configuration handle 1682 * 1683 * Return: status: 0 - Success, non-zero: Failure 1684 */ 1685 static inline 1686 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1687 struct cdp_config_params *cfg) 1688 { 1689 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1690 1691 if (!soc || !soc->ops) { 1692 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1693 "%s: Invalid Instance:", __func__); 1694 QDF_BUG(0); 1695 return 0; 1696 } 1697 1698 if (!soc->ops->cmn_drv_ops || 1699 !soc->ops->cmn_drv_ops->update_config_parameters) 1700 return QDF_STATUS_SUCCESS; 1701 1702 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1703 cfg); 1704 } 1705 1706 /** 1707 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1708 * @soc: opaque soc handle 1709 * @pdev: data path pdev handle 1710 * 1711 * Return: opaque dp handle 1712 */ 1713 static inline void * 1714 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1715 { 1716 if (!soc || !soc->ops) { 1717 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1718 "%s: Invalid Instance:", __func__); 1719 QDF_BUG(0); 1720 return 0; 1721 } 1722 1723 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1724 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1725 1726 return 0; 1727 } 1728 1729 /** 1730 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1731 * @soc: opaque soc handle 1732 * @pdev: data path pdev handle 1733 * @dp_hdl: opaque pointer for dp_txrx_handle 1734 * 1735 * Return: void 1736 */ 1737 static inline void 1738 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1739 { 1740 if (!soc || !soc->ops) { 1741 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1742 "%s: Invalid Instance:", __func__); 1743 QDF_BUG(0); 1744 return; 1745 } 1746 1747 if (!soc->ops->cmn_drv_ops || 1748 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1749 return; 1750 1751 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1752 } 1753 1754 /* 1755 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1756 * @soc: opaque soc handle 1757 * 1758 * Return: opaque extended dp handle 1759 */ 1760 static inline void * 1761 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1762 { 1763 if (!soc || !soc->ops) { 1764 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1765 "%s: Invalid Instance:", __func__); 1766 QDF_BUG(0); 1767 return NULL; 1768 } 1769 1770 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1771 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1772 (struct cdp_soc *) soc); 1773 1774 return NULL; 1775 } 1776 1777 /** 1778 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1779 * @soc: opaque soc handle 1780 * @dp_hdl: opaque pointer for dp_txrx_handle 1781 * 1782 * Return: void 1783 */ 1784 static inline void 1785 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1786 { 1787 if (!soc || !soc->ops) { 1788 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1789 "%s: Invalid Instance:", __func__); 1790 QDF_BUG(0); 1791 return; 1792 } 1793 1794 if (!soc->ops->cmn_drv_ops || 1795 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1796 return; 1797 1798 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1799 dp_handle); 1800 } 1801 1802 /** 1803 * cdp_tx_send() - enqueue frame for transmission 1804 * @soc: soc opaque handle 1805 * @vdev: VAP device 1806 * @nbuf: nbuf to be enqueued 1807 * 1808 * This API is used by Extended Datapath modules to enqueue frame for 1809 * transmission 1810 * 1811 * Return: void 1812 */ 1813 static inline void 1814 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1815 { 1816 if (!soc || !soc->ops) { 1817 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1818 "%s: Invalid Instance:", __func__); 1819 QDF_BUG(0); 1820 return; 1821 } 1822 1823 if (!soc->ops->cmn_drv_ops || 1824 !soc->ops->cmn_drv_ops->tx_send) 1825 return; 1826 1827 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1828 } 1829 1830 /* 1831 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1832 * @soc: opaque soc handle 1833 * @pdev: data path pdev handle 1834 * 1835 * Return: pdev_id 1836 */ 1837 static inline 1838 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1839 struct cdp_pdev *pdev) 1840 { 1841 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1842 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1843 return 0; 1844 } 1845 1846 /* 1847 * cdp_get_vow_config_frm_pdev() - return carrier_vow_config from pdev 1848 * @soc: opaque soc handle 1849 * @pdev: data path pdev handle 1850 * 1851 * Return: carrier_vow_config 1852 */ 1853 static inline 1854 bool cdp_get_vow_config_frm_pdev(ol_txrx_soc_handle soc, 1855 struct cdp_pdev *pdev) 1856 { 1857 if (soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev) 1858 return soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev( 1859 pdev); 1860 return 0; 1861 } 1862 1863 /** 1864 * cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer 1865 * @soc: opaque soc handle 1866 * @pdev: data path pdev handle 1867 * @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path 1868 * 1869 * Return: None 1870 */ 1871 static inline 1872 void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc, 1873 struct cdp_pdev *pdev, 1874 int16_t chan_noise_floor) 1875 { 1876 if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor) 1877 return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor( 1878 pdev, chan_noise_floor); 1879 } 1880 1881 /** 1882 * cdp_set_nac() - set nac 1883 * @soc: opaque soc handle 1884 * @peer: data path peer handle 1885 * 1886 */ 1887 static inline 1888 void cdp_set_nac(ol_txrx_soc_handle soc, 1889 struct cdp_peer *peer) 1890 { 1891 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1892 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1893 } 1894 1895 /** 1896 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1897 * @soc: opaque soc handle 1898 * @pdev: data path pdev handle 1899 * @val: value of pdev_tx_capture 1900 * 1901 * Return: status: 0 - Success, non-zero: Failure 1902 */ 1903 static inline 1904 QDF_STATUS cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1905 struct cdp_pdev *pdev, int val) 1906 { 1907 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1908 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1909 val); 1910 return QDF_STATUS_SUCCESS; 1911 } 1912 1913 /** 1914 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1915 * @soc: opaque soc handle 1916 * @pdev: data path pdev handle 1917 * @peer_id: data path peer id 1918 * @peer_mac: peer_mac 1919 * 1920 * Return: void 1921 */ 1922 static inline 1923 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1924 struct cdp_pdev *pdev_handle, 1925 uint32_t peer_id, uint8_t *peer_mac) 1926 { 1927 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1928 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1929 pdev_handle, peer_id, peer_mac); 1930 } 1931 1932 /** 1933 * cdp_vdev_tx_lock() - acquire lock 1934 * @soc: opaque soc handle 1935 * @vdev: data path vdev handle 1936 * 1937 * Return: void 1938 */ 1939 static inline 1940 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1941 struct cdp_vdev *vdev) 1942 { 1943 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1944 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1945 } 1946 1947 /** 1948 * cdp_vdev_tx_unlock() - release lock 1949 * @soc: opaque soc handle 1950 * @vdev: data path vdev handle 1951 * 1952 * Return: void 1953 */ 1954 static inline 1955 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1956 struct cdp_vdev *vdev) 1957 { 1958 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1959 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1960 } 1961 1962 /** 1963 * cdp_ath_getstats() - get updated athstats 1964 * @soc: opaque soc handle 1965 * @dev: dp interface handle 1966 * @stats: cdp network device stats structure 1967 * @type: device type pdev/vdev 1968 * 1969 * Return: void 1970 */ 1971 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1972 void *dev, struct cdp_dev_stats *stats, 1973 uint8_t type) 1974 { 1975 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1976 soc->ops->cmn_drv_ops->txrx_ath_getstats(dev, stats, type); 1977 } 1978 1979 /** 1980 * cdp_set_gid_flag() - set groupid flag 1981 * @soc: opaque soc handle 1982 * @pdev: data path pdev handle 1983 * @mem_status: member status from grp management frame 1984 * @user_position: user position from grp management frame 1985 * 1986 * Return: void 1987 */ 1988 static inline 1989 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1990 struct cdp_pdev *pdev, u_int8_t *mem_status, 1991 u_int8_t *user_position) 1992 { 1993 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1994 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1995 } 1996 1997 /** 1998 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1999 * @soc: opaque soc handle 2000 * @pdev: data path pdev handle 2001 * 2002 */ 2003 static inline 2004 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 2005 struct cdp_pdev *pdev) 2006 { 2007 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 2008 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 2009 return 0; 2010 } 2011 2012 /** 2013 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 2014 * @soc: opaque soc handle 2015 * @ni: associated node 2016 * @force: number of frame in SW queue 2017 * Return: void 2018 */ 2019 static inline 2020 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 2021 void *ni, int force) 2022 { 2023 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 2024 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 2025 } 2026 2027 /* cdp_peer_map_attach() - CDP API to allocate PEER map memory 2028 * @soc: opaque soc handle 2029 * @max_peers: number of peers created in FW 2030 * @peer_map_unmap_v2: flag indicates HTT peer map v2 is enabled in FW 2031 * 2032 * 2033 * Return: void 2034 */ 2035 static inline void 2036 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 2037 bool peer_map_unmap_v2) 2038 { 2039 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2040 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 2041 soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, max_peers, 2042 peer_map_unmap_v2); 2043 } 2044 2045 /** 2046 2047 * cdp_pdev_set_ctrl_pdev() - set UMAC ctrl pdev to dp pdev 2048 * @soc: opaque soc handle 2049 * @pdev: opaque dp pdev handle 2050 * @ctrl_pdev: opaque ctrl pdev handle 2051 * 2052 * Return: void 2053 */ 2054 static inline void 2055 cdp_pdev_set_ctrl_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *dp_pdev, 2056 struct cdp_ctrl_objmgr_pdev *ctrl_pdev) 2057 { 2058 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2059 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev) 2060 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev(dp_pdev, 2061 ctrl_pdev); 2062 } 2063 2064 /* cdp_txrx_classify_and_update() - To classify the packet and update stats 2065 * @soc: opaque soc handle 2066 * @vdev: opaque dp vdev handle 2067 * @skb: data 2068 * @dir: rx or tx packet 2069 * @nbuf_classify: packet classification object 2070 * 2071 * Return: 1 on success else return 0 2072 */ 2073 static inline int 2074 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 2075 struct cdp_vdev *vdev, qdf_nbuf_t skb, 2076 enum txrx_direction dir, 2077 struct ol_txrx_nbuf_classify *nbuf_class) 2078 { 2079 if (!soc || !soc->ops) { 2080 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2081 "%s: Invalid Instance", __func__); 2082 QDF_BUG(0); 2083 return 0; 2084 } 2085 2086 if (!soc->ops->cmn_drv_ops || 2087 !soc->ops->cmn_drv_ops->txrx_classify_update) 2088 return 0; 2089 2090 return soc->ops->cmn_drv_ops->txrx_classify_update(vdev, 2091 skb, 2092 dir, nbuf_class); 2093 } 2094 2095 /** 2096 * cdp_get_dp_capabilities() - get DP capabilities 2097 * @soc: opaque soc handle 2098 * @dp_cap: enum of DP capabilities 2099 * 2100 * Return: bool 2101 */ 2102 static inline bool 2103 cdp_get_dp_capabilities(struct cdp_soc_t *soc, enum cdp_capabilities dp_caps) 2104 { 2105 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2106 soc->ops->cmn_drv_ops->get_dp_capabilities) 2107 return soc->ops->cmn_drv_ops->get_dp_capabilities(soc, dp_caps); 2108 return false; 2109 } 2110 2111 #ifdef RECEIVE_OFFLOAD 2112 /** 2113 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 2114 * @soc - data path soc handle 2115 * @pdev - device instance pointer 2116 * 2117 * register rx offload flush callback function pointer 2118 * 2119 * return none 2120 */ 2121 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 2122 void (rx_ol_flush_cb)(void *)) 2123 { 2124 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2125 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2126 "%s invalid instance", __func__); 2127 return; 2128 } 2129 2130 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 2131 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 2132 rx_ol_flush_cb); 2133 } 2134 2135 /** 2136 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 2137 * @soc - data path soc handle 2138 * 2139 * deregister rx offload flush callback function pointer 2140 * 2141 * return none 2142 */ 2143 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 2144 { 2145 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2146 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2147 "%s invalid instance", __func__); 2148 return; 2149 } 2150 2151 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 2152 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 2153 } 2154 #endif /* RECEIVE_OFFLOAD */ 2155 2156 /** 2157 * @cdp_set_ba_timeout() - set ba aging timeout per AC 2158 * 2159 * @soc - pointer to the soc 2160 * @value - timeout value in millisec 2161 * @ac - Access category 2162 * 2163 * @return - void 2164 */ 2165 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 2166 uint8_t ac, uint32_t value) 2167 { 2168 if (!soc || !soc->ops) { 2169 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2170 "%s: Invalid Instance", __func__); 2171 QDF_BUG(0); 2172 return; 2173 } 2174 2175 if (!soc->ops->cmn_drv_ops || 2176 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 2177 return; 2178 2179 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 2180 } 2181 2182 /** 2183 * @cdp_get_ba_timeout() - return ba aging timeout per AC 2184 * 2185 * @soc - pointer to the soc 2186 * @ac - access category 2187 * @value - timeout value in millisec 2188 * 2189 * @return - void 2190 */ 2191 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 2192 uint8_t ac, uint32_t *value) 2193 { 2194 if (!soc || !soc->ops) { 2195 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2196 "%s: Invalid Instance", __func__); 2197 QDF_BUG(0); 2198 return; 2199 } 2200 2201 if (!soc->ops->cmn_drv_ops || 2202 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 2203 return; 2204 2205 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 2206 } 2207 2208 /** 2209 * cdp_cfg_get() - get cfg for dp enum 2210 * 2211 * @soc: pointer to the soc 2212 * @cfg: cfg enum 2213 * 2214 * Return - cfg value 2215 */ 2216 static inline uint32_t cdp_cfg_get(ol_txrx_soc_handle soc, enum cdp_dp_cfg cfg) 2217 { 2218 if (!soc || !soc->ops) { 2219 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2220 "%s: Invalid Instance", __func__); 2221 return 0; 2222 } 2223 2224 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_cfg) 2225 return 0; 2226 2227 return soc->ops->cmn_drv_ops->txrx_get_cfg(soc, cfg); 2228 } 2229 #endif /* _CDP_TXRX_CMN_H_ */ 2230