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_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 594 { 595 if (!soc || !soc->ops) { 596 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 597 "%s: Invalid Instance:", __func__); 598 QDF_BUG(0); 599 return; 600 } 601 602 if (!soc->ops->cmn_drv_ops || 603 !soc->ops->cmn_drv_ops->txrx_peer_delete) 604 return; 605 606 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 607 } 608 609 static inline void 610 cdp_peer_delete_sync(ol_txrx_soc_handle soc, void *peer, 611 QDF_STATUS(*delete_cb)( 612 uint8_t vdev_id, 613 uint32_t peerid_cnt, 614 uint16_t *peerid_list), 615 uint32_t bitmap) 616 { 617 if (!soc || !soc->ops) { 618 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 619 "%s: Invalid Instance:", __func__); 620 QDF_BUG(0); 621 return; 622 } 623 624 if (!soc->ops->cmn_drv_ops || 625 !soc->ops->cmn_drv_ops->txrx_peer_delete_sync) 626 return; 627 628 soc->ops->cmn_drv_ops->txrx_peer_delete_sync(peer, 629 delete_cb, 630 bitmap); 631 } 632 633 static inline int 634 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 635 uint8_t smart_monitor) 636 { 637 if (!soc || !soc->ops) { 638 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 639 "%s: Invalid Instance:", __func__); 640 QDF_BUG(0); 641 return 0; 642 } 643 644 if (!soc->ops->cmn_drv_ops || 645 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 646 return 0; 647 648 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 649 smart_monitor); 650 } 651 652 static inline void 653 cdp_set_curchan(ol_txrx_soc_handle soc, 654 struct cdp_pdev *pdev, 655 uint32_t chan_mhz) 656 { 657 if (!soc || !soc->ops) { 658 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 659 "%s: Invalid Instance:", __func__); 660 QDF_BUG(0); 661 return; 662 } 663 664 if (!soc->ops->cmn_drv_ops || 665 !soc->ops->cmn_drv_ops->txrx_set_curchan) 666 return; 667 668 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 669 } 670 671 static inline void 672 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 673 void *filter, uint32_t num) 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_privacy_filters) 684 return; 685 686 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 687 filter, num); 688 } 689 690 static inline int 691 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 692 struct cdp_monitor_filter *filter_val) 693 { 694 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 695 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 696 filter_val); 697 return 0; 698 } 699 700 701 /****************************************************************************** 702 * Data Interface (B Interface) 703 *****************************************************************************/ 704 static inline void 705 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 706 void *osif_vdev, struct cdp_ctrl_objmgr_vdev *ctrl_vdev, 707 struct ol_txrx_ops *txrx_ops) 708 { 709 if (!soc || !soc->ops) { 710 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 711 "%s: Invalid Instance:", __func__); 712 QDF_BUG(0); 713 return; 714 } 715 716 if (!soc->ops->cmn_drv_ops || 717 !soc->ops->cmn_drv_ops->txrx_vdev_register) 718 return; 719 720 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 721 osif_vdev, ctrl_vdev, txrx_ops); 722 } 723 724 static inline int 725 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 726 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 727 { 728 if (!soc || !soc->ops) { 729 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 730 "%s: Invalid Instance:", __func__); 731 QDF_BUG(0); 732 return 0; 733 } 734 735 if (!soc->ops->cmn_drv_ops || 736 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 737 return 0; 738 739 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 740 tx_mgmt_frm, type); 741 } 742 743 static inline int 744 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 745 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 746 uint8_t use_6mbps, uint16_t chanfreq) 747 { 748 if (!soc || !soc->ops) { 749 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 750 "%s: Invalid Instance:", __func__); 751 QDF_BUG(0); 752 return 0; 753 } 754 755 if (!soc->ops->cmn_drv_ops || 756 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 757 return 0; 758 759 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 760 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 761 } 762 763 764 static inline void 765 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 766 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 767 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 768 { 769 if (!soc || !soc->ops) { 770 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 771 "%s: Invalid Instance:", __func__); 772 QDF_BUG(0); 773 return; 774 } 775 776 if (!soc->ops->cmn_drv_ops || 777 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 778 return; 779 780 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 781 (pdev, type, download_cb, ota_ack_cb, ctxt); 782 } 783 784 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 785 struct cdp_pdev *pdev) 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 0; 792 } 793 794 if (!soc->ops->cmn_drv_ops || 795 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 796 return 0; 797 798 799 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 800 } 801 802 static inline void 803 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 804 ol_txrx_data_tx_cb callback, void *ctxt) 805 { 806 if (!soc || !soc->ops) { 807 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 808 "%s: Invalid Instance:", __func__); 809 QDF_BUG(0); 810 return; 811 } 812 813 if (!soc->ops->cmn_drv_ops || 814 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 815 return; 816 817 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 818 callback, ctxt); 819 } 820 821 /****************************************************************************** 822 * Statistics and Debugging Interface (C Interface) 823 *****************************************************************************/ 824 /** 825 * External Device physical address types 826 * 827 * Currently, both MAC and IPA uController use the same size addresses 828 * and descriptors are exchanged between these two depending on the mode. 829 * 830 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 831 * operations. However, external device physical address sizes 832 * may be different from host-specific physical address sizes. 833 * This calls for the following definitions for target devices 834 * (MAC, IPA uc). 835 */ 836 #if HTT_PADDR64 837 typedef uint64_t target_paddr_t; 838 #else 839 typedef uint32_t target_paddr_t; 840 #endif /*HTT_PADDR64 */ 841 842 static inline int 843 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 844 int max_subfrms_ampdu, 845 int max_subfrms_amsdu) 846 { 847 if (!soc || !soc->ops) { 848 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 849 "%s: Invalid Instance:", __func__); 850 QDF_BUG(0); 851 return 0; 852 } 853 854 if (!soc->ops->cmn_drv_ops || 855 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 856 return 0; 857 858 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 859 max_subfrms_ampdu, max_subfrms_amsdu); 860 } 861 862 static inline int 863 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 864 struct ol_txrx_stats_req *req, bool per_vdev, 865 bool response_expected) 866 { 867 if (!soc || !soc->ops) { 868 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 869 "%s: Invalid Instance:", __func__); 870 QDF_BUG(0); 871 return 0; 872 } 873 874 if (!soc->ops->cmn_drv_ops || 875 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 876 return 0; 877 878 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 879 per_vdev, response_expected); 880 } 881 882 static inline int 883 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 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_debug) 894 return 0; 895 896 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 897 } 898 899 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 900 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 901 { 902 if (!soc || !soc->ops) { 903 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 904 "%s: Invalid Instance:", __func__); 905 QDF_BUG(0); 906 return; 907 } 908 909 if (!soc->ops->cmn_drv_ops || 910 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 911 return; 912 913 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 914 cfg_stats_type, cfg_val); 915 } 916 917 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 918 { 919 if (!soc || !soc->ops) { 920 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 921 "%s: Invalid Instance:", __func__); 922 QDF_BUG(0); 923 return; 924 } 925 926 if (!soc->ops->cmn_drv_ops || 927 !soc->ops->cmn_drv_ops->txrx_print_level_set) 928 return; 929 930 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 931 } 932 933 static inline uint8_t * 934 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 935 { 936 if (!soc || !soc->ops) { 937 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 938 "%s: Invalid Instance:", __func__); 939 QDF_BUG(0); 940 return NULL; 941 } 942 943 if (!soc->ops->cmn_drv_ops || 944 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 945 return NULL; 946 947 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 948 949 } 950 951 /** 952 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 953 * vdev 954 * @vdev: vdev handle 955 * 956 * Return: Handle to struct qdf_mac_addr 957 */ 958 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 959 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 960 { 961 if (!soc || !soc->ops) { 962 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 963 "%s: Invalid Instance:", __func__); 964 QDF_BUG(0); 965 return NULL; 966 } 967 968 if (!soc->ops->cmn_drv_ops || 969 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 970 return NULL; 971 972 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 973 (vdev); 974 975 } 976 977 /** 978 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 979 * @vdev: vdev handle 980 * 981 * Return: Handle to pdev 982 */ 983 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 984 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 985 { 986 if (!soc || !soc->ops) { 987 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 988 "%s: Invalid Instance:", __func__); 989 QDF_BUG(0); 990 return NULL; 991 } 992 993 if (!soc->ops->cmn_drv_ops || 994 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 995 return NULL; 996 997 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 998 } 999 1000 /** 1001 * cdp_get_os_rx_handles_from_vdev() - Return os rx handles for a vdev 1002 * @soc: ol_txrx_soc_handle handle 1003 * @vdev: vdev for which os rx handles are needed 1004 * @stack_fn_p: pointer to stack function pointer 1005 * @osif_handle_p: pointer to ol_osif_vdev_handle 1006 * 1007 * Return: void 1008 */ 1009 static inline 1010 void cdp_get_os_rx_handles_from_vdev(ol_txrx_soc_handle soc, 1011 struct cdp_vdev *vdev, 1012 ol_txrx_rx_fp *stack_fn_p, 1013 ol_osif_vdev_handle *osif_handle_p) 1014 { 1015 if (!soc || !soc->ops) { 1016 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1017 "%s: Invalid Instance:", __func__); 1018 QDF_BUG(0); 1019 return; 1020 } 1021 1022 if (!soc->ops->cmn_drv_ops || 1023 !soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev) 1024 return; 1025 1026 soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev(vdev, 1027 stack_fn_p, 1028 osif_handle_p); 1029 } 1030 1031 /** 1032 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 1033 * @vdev: vdev handle 1034 * 1035 * Return: Handle to control pdev 1036 */ 1037 static inline struct cdp_cfg * 1038 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 1039 { 1040 if (!soc || !soc->ops) { 1041 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1042 "%s: Invalid Instance:", __func__); 1043 QDF_BUG(0); 1044 return NULL; 1045 } 1046 1047 if (!soc->ops->cmn_drv_ops || 1048 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 1049 return NULL; 1050 1051 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 1052 (vdev); 1053 } 1054 1055 static inline struct cdp_vdev * 1056 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 1057 uint8_t vdev_id) 1058 { 1059 if (!soc || !soc->ops) { 1060 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1061 "%s: Invalid Instance:", __func__); 1062 QDF_BUG(0); 1063 return NULL; 1064 } 1065 1066 if (!soc->ops->cmn_drv_ops || 1067 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 1068 return NULL; 1069 1070 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 1071 (pdev, vdev_id); 1072 } 1073 1074 static inline struct cdp_vdev * 1075 cdp_get_mon_vdev_from_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 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_mon_vdev_from_pdev) 1086 return NULL; 1087 1088 return soc->ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev 1089 (pdev); 1090 } 1091 1092 static inline void 1093 cdp_soc_detach(ol_txrx_soc_handle soc) 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; 1100 } 1101 1102 if (!soc->ops->cmn_drv_ops || 1103 !soc->ops->cmn_drv_ops->txrx_soc_detach) 1104 return; 1105 1106 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 1107 } 1108 1109 /** 1110 * cdp_soc_init() - Initialize txrx SOC 1111 * @soc: ol_txrx_soc_handle handle 1112 * @devid: Device ID 1113 * @hif_handle: Opaque HIF handle 1114 * @psoc: Opaque Objmgr handle 1115 * @htc_handle: Opaque HTC handle 1116 * @qdf_dev: QDF device 1117 * @dp_ol_if_ops: Offload Operations 1118 * 1119 * Return: DP SOC handle on success, NULL on failure 1120 */ 1121 static inline ol_txrx_soc_handle 1122 cdp_soc_init(ol_txrx_soc_handle soc, u_int16_t devid, void *hif_handle, 1123 void *psoc, void *htc_handle, qdf_device_t qdf_dev, 1124 struct ol_if_ops *dp_ol_if_ops) 1125 { 1126 if (!soc || !soc->ops) { 1127 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1128 "%s: Invalid Instance:", __func__); 1129 QDF_BUG(0); 1130 return NULL; 1131 } 1132 1133 if (!soc->ops->cmn_drv_ops || 1134 !soc->ops->cmn_drv_ops->txrx_soc_init) 1135 return NULL; 1136 1137 return soc->ops->cmn_drv_ops->txrx_soc_init(soc, psoc, 1138 hif_handle, 1139 htc_handle, qdf_dev, 1140 dp_ol_if_ops, devid); 1141 } 1142 1143 /** 1144 * cdp_soc_deinit() - Deinitialize txrx SOC 1145 * @soc: Opaque DP SOC handle 1146 * 1147 * Return: None 1148 */ 1149 static inline void 1150 cdp_soc_deinit(ol_txrx_soc_handle soc) 1151 { 1152 if (!soc || !soc->ops) { 1153 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1154 "%s: Invalid Instance:", __func__); 1155 QDF_BUG(0); 1156 return; 1157 } 1158 1159 if (!soc->ops->cmn_drv_ops || 1160 !soc->ops->cmn_drv_ops->txrx_soc_deinit) 1161 return; 1162 1163 soc->ops->cmn_drv_ops->txrx_soc_deinit((void *)soc); 1164 } 1165 1166 /** 1167 * cdp_tso_soc_attach() - TSO attach function 1168 * @soc: ol_txrx_soc_handle handle 1169 * 1170 * Reserve TSO descriptor buffers 1171 * 1172 * Return: QDF_STATUS_SUCCESS on Success or 1173 * QDF_STATUS_E_FAILURE on failure 1174 */ 1175 static inline QDF_STATUS 1176 cdp_tso_soc_attach(ol_txrx_soc_handle soc) 1177 { 1178 if (!soc || !soc->ops) { 1179 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1180 "%s: Invalid Instance:", __func__); 1181 QDF_BUG(0); 1182 return 0; 1183 } 1184 1185 if (!soc->ops->cmn_drv_ops || 1186 !soc->ops->cmn_drv_ops->txrx_tso_soc_attach) 1187 return 0; 1188 1189 return soc->ops->cmn_drv_ops->txrx_tso_soc_attach((void *)soc); 1190 } 1191 1192 /** 1193 * cdp_tso_soc_detach() - TSO detach function 1194 * @soc: ol_txrx_soc_handle handle 1195 * 1196 * Release TSO descriptor buffers 1197 * 1198 * Return: QDF_STATUS_SUCCESS on Success or 1199 * QDF_STATUS_E_FAILURE on failure 1200 */ 1201 static inline QDF_STATUS 1202 cdp_tso_soc_detach(ol_txrx_soc_handle soc) 1203 { 1204 if (!soc || !soc->ops) { 1205 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1206 "%s: Invalid Instance:", __func__); 1207 QDF_BUG(0); 1208 return 0; 1209 } 1210 1211 if (!soc->ops->cmn_drv_ops || 1212 !soc->ops->cmn_drv_ops->txrx_tso_soc_detach) 1213 return 0; 1214 1215 return soc->ops->cmn_drv_ops->txrx_tso_soc_detach((void *)soc); 1216 } 1217 1218 /** 1219 * cdp_addba_resp_tx_completion() - Indicate addba response tx 1220 * completion to dp to change tid state. 1221 * @soc: soc handle 1222 * @peer_handle: peer handle 1223 * @tid: tid 1224 * @status: Tx completion status 1225 * 1226 * Return: success/failure of tid update 1227 */ 1228 static inline int cdp_addba_resp_tx_completion(ol_txrx_soc_handle soc, 1229 void *peer_handle, 1230 uint8_t tid, int status) 1231 { 1232 if (!soc || !soc->ops) { 1233 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1234 "%s: Invalid Instance:", __func__); 1235 QDF_BUG(0); 1236 return 0; 1237 } 1238 1239 if (!soc->ops->cmn_drv_ops || 1240 !soc->ops->cmn_drv_ops->addba_resp_tx_completion) 1241 return 0; 1242 1243 return soc->ops->cmn_drv_ops->addba_resp_tx_completion(peer_handle, tid, 1244 status); 1245 } 1246 1247 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 1248 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 1249 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 1250 { 1251 if (!soc || !soc->ops) { 1252 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1253 "%s: Invalid Instance:", __func__); 1254 QDF_BUG(0); 1255 return 0; 1256 } 1257 1258 if (!soc->ops->cmn_drv_ops || 1259 !soc->ops->cmn_drv_ops->addba_requestprocess) 1260 return 0; 1261 1262 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 1263 dialogtoken, tid, batimeout, buffersize, startseqnum); 1264 } 1265 1266 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 1267 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 1268 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 1269 { 1270 if (!soc || !soc->ops) { 1271 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1272 "%s: Invalid Instance:", __func__); 1273 QDF_BUG(0); 1274 return; 1275 } 1276 1277 if (!soc->ops->cmn_drv_ops || 1278 !soc->ops->cmn_drv_ops->addba_responsesetup) 1279 return; 1280 1281 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 1282 dialogtoken, statuscode, buffersize, batimeout); 1283 } 1284 1285 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 1286 void *peer_handle, int tid, uint16_t reasoncode) 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 0; 1293 } 1294 1295 if (!soc->ops->cmn_drv_ops || 1296 !soc->ops->cmn_drv_ops->delba_process) 1297 return 0; 1298 1299 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 1300 tid, reasoncode); 1301 } 1302 1303 /** 1304 * cdp_delba_tx_completion() - Handle delba tx completion 1305 * to update stats and retry transmission if failed. 1306 * @soc: soc handle 1307 * @peer_handle: peer handle 1308 * @tid: Tid number 1309 * @status: Tx completion status 1310 * 1311 * Return: 0 on Success, 1 on failure 1312 */ 1313 1314 static inline int cdp_delba_tx_completion(ol_txrx_soc_handle soc, 1315 void *peer_handle, 1316 uint8_t tid, int status) 1317 { 1318 if (!soc || !soc->ops) { 1319 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1320 "%s: Invalid Instance:", __func__); 1321 QDF_BUG(0); 1322 return 0; 1323 } 1324 1325 if (!soc->ops->cmn_drv_ops || 1326 !soc->ops->cmn_drv_ops->delba_tx_completion) 1327 return 0; 1328 1329 return soc->ops->cmn_drv_ops->delba_tx_completion(peer_handle, 1330 tid, status); 1331 } 1332 1333 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1334 void *peer_handle, int tid, uint16_t statuscode) 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; 1341 } 1342 1343 if (!soc->ops->cmn_drv_ops || 1344 !soc->ops->cmn_drv_ops->set_addba_response) 1345 return; 1346 1347 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1348 } 1349 1350 /** 1351 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1352 * mac address 1353 * @soc: SOC handle 1354 * @peer_id: peer id of the peer for which mac_address is required 1355 * @mac_addr: reference to mac address 1356 * 1357 * reutm: vdev_id of the vap 1358 */ 1359 static inline uint8_t 1360 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1361 uint8_t *mac_addr) 1362 { 1363 if (!soc || !soc->ops) { 1364 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1365 "%s: Invalid Instance:", __func__); 1366 QDF_BUG(0); 1367 return CDP_INVALID_VDEV_ID; 1368 } 1369 1370 if (!soc->ops->cmn_drv_ops || 1371 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1372 return CDP_INVALID_VDEV_ID; 1373 1374 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1375 peer_id, mac_addr); 1376 } 1377 1378 /** 1379 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1380 * @vdev: vdev handle 1381 * @map_id: id of the tid map 1382 * 1383 * Return: void 1384 */ 1385 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1386 struct cdp_vdev *vdev, uint8_t map_id) 1387 { 1388 if (!soc || !soc->ops) { 1389 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1390 "%s: Invalid Instance:", __func__); 1391 QDF_BUG(0); 1392 return; 1393 } 1394 1395 if (!soc->ops->cmn_drv_ops || 1396 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1397 return; 1398 1399 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1400 map_id); 1401 } 1402 1403 /** 1404 * cdp_ath_get_total_per(): function to get hw retries 1405 * @soc : soc handle 1406 * @pdev: pdev handle 1407 * 1408 * Return: get hw retries 1409 */ 1410 static inline 1411 int cdp_ath_get_total_per(ol_txrx_soc_handle soc, 1412 struct cdp_pdev *pdev) 1413 { 1414 if (!soc || !soc->ops) { 1415 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1416 "%s: Invalid Instance:", __func__); 1417 QDF_BUG(0); 1418 return 0; 1419 } 1420 1421 if (!soc->ops->cmn_drv_ops || 1422 !soc->ops->cmn_drv_ops->txrx_get_total_per) 1423 return 0; 1424 1425 return soc->ops->cmn_drv_ops->txrx_get_total_per(pdev); 1426 } 1427 1428 /** 1429 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1430 * @pdev: pdev handle 1431 * @map_id: id of the tid map 1432 * @tos: index value in map that needs to be changed 1433 * @tid: tid value passed by user 1434 * 1435 * Return: void 1436 */ 1437 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1438 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 1439 { 1440 if (!soc || !soc->ops) { 1441 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1442 "%s: Invalid Instance:", __func__); 1443 QDF_BUG(0); 1444 return; 1445 } 1446 1447 if (!soc->ops->cmn_drv_ops || 1448 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1449 return; 1450 1451 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1452 map_id, tos, tid); 1453 } 1454 1455 /** 1456 * cdp_hmmc_tid_override_en(): Function to enable hmmc tid override. 1457 * @soc : soc handle 1458 * @pdev: pdev handle 1459 * @val: hmmc-dscp flag value 1460 * 1461 * Return: void 1462 */ 1463 static inline void cdp_hmmc_tid_override_en(ol_txrx_soc_handle soc, 1464 struct cdp_pdev *pdev, bool val) 1465 { 1466 if (!soc || !soc->ops) { 1467 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1468 "%s: Invalid Instance:", __func__); 1469 QDF_BUG(0); 1470 return; 1471 } 1472 1473 if (!soc->ops->cmn_drv_ops || 1474 !soc->ops->cmn_drv_ops->hmmc_tid_override_en) 1475 return; 1476 1477 soc->ops->cmn_drv_ops->hmmc_tid_override_en(pdev, val); 1478 } 1479 1480 /** 1481 * cdp_set_hmmc_tid_val(): Function to set hmmc tid value. 1482 * @soc : soc handle 1483 * @pdev: pdev handle 1484 * @tid: tid value 1485 * 1486 * Return: void 1487 */ 1488 static inline void cdp_set_hmmc_tid_val(ol_txrx_soc_handle soc, 1489 struct cdp_pdev *pdev, uint8_t tid) 1490 { 1491 if (!soc || !soc->ops) { 1492 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1493 "%s: Invalid Instance:", __func__); 1494 QDF_BUG(0); 1495 return; 1496 } 1497 1498 if (!soc->ops->cmn_drv_ops || 1499 !soc->ops->cmn_drv_ops->set_hmmc_tid_val) 1500 return; 1501 1502 soc->ops->cmn_drv_ops->set_hmmc_tid_val(pdev, tid); 1503 } 1504 1505 /** 1506 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1507 * 1508 * Return: None 1509 */ 1510 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1511 { 1512 if (!soc || !soc->ops) { 1513 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1514 "%s: Invalid Instance:", __func__); 1515 QDF_BUG(0); 1516 return; 1517 } 1518 1519 if (!soc->ops->cmn_drv_ops || 1520 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1521 return; 1522 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1523 } 1524 1525 /** 1526 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1527 * @soc: soc handle 1528 * @vdev: virtual device 1529 * @req: stats request container 1530 * 1531 * return: status 1532 */ 1533 static inline 1534 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1535 struct cdp_txrx_stats_req *req) 1536 { 1537 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1538 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1539 "%s: Invalid Instance:", __func__); 1540 QDF_ASSERT(0); 1541 return 0; 1542 } 1543 1544 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1545 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1546 1547 return 0; 1548 } 1549 1550 /** 1551 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1552 * @soc: soc handle 1553 */ 1554 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1555 { 1556 if (!soc || !soc->ops) { 1557 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1558 "%s: Invalid Instance:", __func__); 1559 QDF_BUG(0); 1560 return 0; 1561 } 1562 1563 if (!soc->ops->cmn_drv_ops || 1564 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1565 return 0; 1566 1567 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1568 } 1569 1570 /** 1571 * cdp_txrx_intr_detach(): function to detach interrupt 1572 * @soc: soc handle 1573 */ 1574 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1575 { 1576 if (!soc || !soc->ops) { 1577 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1578 "%s: Invalid Instance:", __func__); 1579 QDF_BUG(0); 1580 return; 1581 } 1582 1583 if (!soc->ops->cmn_drv_ops || 1584 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1585 return; 1586 1587 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1588 } 1589 1590 /** 1591 * cdp_display_stats(): function to map to dump stats 1592 * @soc: soc handle 1593 * @value: statistics option 1594 */ 1595 static inline QDF_STATUS 1596 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1597 enum qdf_stats_verbosity_level level) 1598 { 1599 if (!soc || !soc->ops) { 1600 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1601 "%s: Invalid Instance:", __func__); 1602 QDF_BUG(0); 1603 return 0; 1604 } 1605 1606 if (!soc->ops->cmn_drv_ops || 1607 !soc->ops->cmn_drv_ops->display_stats) 1608 return 0; 1609 1610 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1611 } 1612 1613 1614 /** 1615 * cdp_set_pn_check(): function to set pn check 1616 * @soc: soc handle 1617 * @sec_type: security type 1618 * #rx_pn: receive pn 1619 */ 1620 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1621 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1622 { 1623 if (!soc || !soc->ops) { 1624 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1625 "%s: Invalid Instance:", __func__); 1626 QDF_BUG(0); 1627 return 0; 1628 } 1629 1630 if (!soc->ops->cmn_drv_ops || 1631 !soc->ops->cmn_drv_ops->set_pn_check) 1632 return 0; 1633 1634 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1635 sec_type, rx_pn); 1636 return 0; 1637 } 1638 1639 static inline int cdp_set_key(ol_txrx_soc_handle soc, 1640 struct cdp_peer *peer_handle, 1641 bool is_unicast, uint32_t *key) 1642 { 1643 if (!soc || !soc->ops) { 1644 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1645 "%s: Invalid Instance:", __func__); 1646 QDF_BUG(0); 1647 return 0; 1648 } 1649 1650 if (!soc->ops->ctrl_ops || 1651 !soc->ops->ctrl_ops->set_key) 1652 return 0; 1653 1654 soc->ops->ctrl_ops->set_key(peer_handle, 1655 is_unicast, key); 1656 return 0; 1657 } 1658 1659 /** 1660 * cdp_update_config_parameters(): function to propagate configuration 1661 * parameters to datapath 1662 * @soc: opaque soc handle 1663 * @cfg: configuration handle 1664 * 1665 * Return: status: 0 - Success, non-zero: Failure 1666 */ 1667 static inline 1668 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1669 struct cdp_config_params *cfg) 1670 { 1671 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1672 1673 if (!soc || !soc->ops) { 1674 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1675 "%s: Invalid Instance:", __func__); 1676 QDF_BUG(0); 1677 return 0; 1678 } 1679 1680 if (!soc->ops->cmn_drv_ops || 1681 !soc->ops->cmn_drv_ops->update_config_parameters) 1682 return QDF_STATUS_SUCCESS; 1683 1684 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1685 cfg); 1686 } 1687 1688 /** 1689 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1690 * @soc: opaque soc handle 1691 * @pdev: data path pdev handle 1692 * 1693 * Return: opaque dp handle 1694 */ 1695 static inline void * 1696 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1697 { 1698 if (!soc || !soc->ops) { 1699 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1700 "%s: Invalid Instance:", __func__); 1701 QDF_BUG(0); 1702 return 0; 1703 } 1704 1705 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1706 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1707 1708 return 0; 1709 } 1710 1711 /** 1712 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1713 * @soc: opaque soc handle 1714 * @pdev: data path pdev handle 1715 * @dp_hdl: opaque pointer for dp_txrx_handle 1716 * 1717 * Return: void 1718 */ 1719 static inline void 1720 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1721 { 1722 if (!soc || !soc->ops) { 1723 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1724 "%s: Invalid Instance:", __func__); 1725 QDF_BUG(0); 1726 return; 1727 } 1728 1729 if (!soc->ops->cmn_drv_ops || 1730 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1731 return; 1732 1733 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1734 } 1735 1736 /* 1737 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1738 * @soc: opaque soc handle 1739 * 1740 * Return: opaque extended dp handle 1741 */ 1742 static inline void * 1743 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1744 { 1745 if (!soc || !soc->ops) { 1746 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1747 "%s: Invalid Instance:", __func__); 1748 QDF_BUG(0); 1749 return NULL; 1750 } 1751 1752 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1753 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1754 (struct cdp_soc *) soc); 1755 1756 return NULL; 1757 } 1758 1759 /** 1760 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1761 * @soc: opaque soc handle 1762 * @dp_hdl: opaque pointer for dp_txrx_handle 1763 * 1764 * Return: void 1765 */ 1766 static inline void 1767 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1768 { 1769 if (!soc || !soc->ops) { 1770 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1771 "%s: Invalid Instance:", __func__); 1772 QDF_BUG(0); 1773 return; 1774 } 1775 1776 if (!soc->ops->cmn_drv_ops || 1777 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1778 return; 1779 1780 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1781 dp_handle); 1782 } 1783 1784 /** 1785 * cdp_tx_send() - enqueue frame for transmission 1786 * @soc: soc opaque handle 1787 * @vdev: VAP device 1788 * @nbuf: nbuf to be enqueued 1789 * 1790 * This API is used by Extended Datapath modules to enqueue frame for 1791 * transmission 1792 * 1793 * Return: void 1794 */ 1795 static inline void 1796 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1797 { 1798 if (!soc || !soc->ops) { 1799 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1800 "%s: Invalid Instance:", __func__); 1801 QDF_BUG(0); 1802 return; 1803 } 1804 1805 if (!soc->ops->cmn_drv_ops || 1806 !soc->ops->cmn_drv_ops->tx_send) 1807 return; 1808 1809 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1810 } 1811 1812 /* 1813 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1814 * @soc: opaque soc handle 1815 * @pdev: data path pdev handle 1816 * 1817 * Return: pdev_id 1818 */ 1819 static inline 1820 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1821 struct cdp_pdev *pdev) 1822 { 1823 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1824 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1825 return 0; 1826 } 1827 1828 /* 1829 * cdp_get_vow_config_frm_pdev() - return carrier_vow_config from pdev 1830 * @soc: opaque soc handle 1831 * @pdev: data path pdev handle 1832 * 1833 * Return: carrier_vow_config 1834 */ 1835 static inline 1836 bool cdp_get_vow_config_frm_pdev(ol_txrx_soc_handle soc, 1837 struct cdp_pdev *pdev) 1838 { 1839 if (soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev) 1840 return soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev( 1841 pdev); 1842 return 0; 1843 } 1844 1845 /** 1846 * cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer 1847 * @soc: opaque soc handle 1848 * @pdev: data path pdev handle 1849 * @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path 1850 * 1851 * Return: None 1852 */ 1853 static inline 1854 void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc, 1855 struct cdp_pdev *pdev, 1856 int16_t chan_noise_floor) 1857 { 1858 if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor) 1859 return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor( 1860 pdev, chan_noise_floor); 1861 } 1862 1863 /** 1864 * cdp_set_nac() - set nac 1865 * @soc: opaque soc handle 1866 * @peer: data path peer handle 1867 * 1868 */ 1869 static inline 1870 void cdp_set_nac(ol_txrx_soc_handle soc, 1871 struct cdp_peer *peer) 1872 { 1873 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1874 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1875 } 1876 1877 /** 1878 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1879 * @soc: opaque soc handle 1880 * @pdev: data path pdev handle 1881 * @val: value of pdev_tx_capture 1882 * 1883 * Return: status: 0 - Success, non-zero: Failure 1884 */ 1885 static inline 1886 QDF_STATUS cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1887 struct cdp_pdev *pdev, int val) 1888 { 1889 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1890 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1891 val); 1892 return QDF_STATUS_SUCCESS; 1893 } 1894 1895 /** 1896 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1897 * @soc: opaque soc handle 1898 * @pdev: data path pdev handle 1899 * @peer_id: data path peer id 1900 * @peer_mac: peer_mac 1901 * 1902 * Return: void 1903 */ 1904 static inline 1905 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1906 struct cdp_pdev *pdev_handle, 1907 uint32_t peer_id, uint8_t *peer_mac) 1908 { 1909 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1910 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1911 pdev_handle, peer_id, peer_mac); 1912 } 1913 1914 /** 1915 * cdp_vdev_tx_lock() - acquire lock 1916 * @soc: opaque soc handle 1917 * @vdev: data path vdev handle 1918 * 1919 * Return: void 1920 */ 1921 static inline 1922 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1923 struct cdp_vdev *vdev) 1924 { 1925 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1926 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1927 } 1928 1929 /** 1930 * cdp_vdev_tx_unlock() - release lock 1931 * @soc: opaque soc handle 1932 * @vdev: data path vdev handle 1933 * 1934 * Return: void 1935 */ 1936 static inline 1937 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1938 struct cdp_vdev *vdev) 1939 { 1940 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1941 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1942 } 1943 1944 /** 1945 * cdp_ath_getstats() - get updated athstats 1946 * @soc: opaque soc handle 1947 * @dev: dp interface handle 1948 * @stats: cdp network device stats structure 1949 * @type: device type pdev/vdev 1950 * 1951 * Return: void 1952 */ 1953 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1954 void *dev, struct cdp_dev_stats *stats, 1955 uint8_t type) 1956 { 1957 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1958 soc->ops->cmn_drv_ops->txrx_ath_getstats(dev, stats, type); 1959 } 1960 1961 /** 1962 * cdp_set_gid_flag() - set groupid flag 1963 * @soc: opaque soc handle 1964 * @pdev: data path pdev handle 1965 * @mem_status: member status from grp management frame 1966 * @user_position: user position from grp management frame 1967 * 1968 * Return: void 1969 */ 1970 static inline 1971 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1972 struct cdp_pdev *pdev, u_int8_t *mem_status, 1973 u_int8_t *user_position) 1974 { 1975 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1976 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1977 } 1978 1979 /** 1980 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1981 * @soc: opaque soc handle 1982 * @pdev: data path pdev handle 1983 * 1984 */ 1985 static inline 1986 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1987 struct cdp_pdev *pdev) 1988 { 1989 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1990 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1991 return 0; 1992 } 1993 1994 /** 1995 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1996 * @soc: opaque soc handle 1997 * @ni: associated node 1998 * @force: number of frame in SW queue 1999 * Return: void 2000 */ 2001 static inline 2002 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 2003 void *ni, int force) 2004 { 2005 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 2006 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 2007 } 2008 2009 /* cdp_peer_map_attach() - CDP API to allocate PEER map memory 2010 * @soc: opaque soc handle 2011 * @max_peers: number of peers created in FW 2012 * @peer_map_unmap_v2: flag indicates HTT peer map v2 is enabled in FW 2013 * 2014 * 2015 * Return: void 2016 */ 2017 static inline void 2018 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 2019 bool peer_map_unmap_v2) 2020 { 2021 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2022 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 2023 soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, max_peers, 2024 peer_map_unmap_v2); 2025 } 2026 2027 /** 2028 2029 * cdp_pdev_set_ctrl_pdev() - set UMAC ctrl pdev to dp pdev 2030 * @soc: opaque soc handle 2031 * @pdev: opaque dp pdev handle 2032 * @ctrl_pdev: opaque ctrl pdev handle 2033 * 2034 * Return: void 2035 */ 2036 static inline void 2037 cdp_pdev_set_ctrl_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *dp_pdev, 2038 struct cdp_ctrl_objmgr_pdev *ctrl_pdev) 2039 { 2040 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2041 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev) 2042 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev(dp_pdev, 2043 ctrl_pdev); 2044 } 2045 2046 /* cdp_txrx_classify_and_update() - To classify the packet and update stats 2047 * @soc: opaque soc handle 2048 * @vdev: opaque dp vdev handle 2049 * @skb: data 2050 * @dir: rx or tx packet 2051 * @nbuf_classify: packet classification object 2052 * 2053 * Return: 1 on success else return 0 2054 */ 2055 static inline int 2056 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 2057 struct cdp_vdev *vdev, qdf_nbuf_t skb, 2058 enum txrx_direction dir, 2059 struct ol_txrx_nbuf_classify *nbuf_class) 2060 { 2061 if (!soc || !soc->ops) { 2062 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2063 "%s: Invalid Instance", __func__); 2064 QDF_BUG(0); 2065 return 0; 2066 } 2067 2068 if (!soc->ops->cmn_drv_ops || 2069 !soc->ops->cmn_drv_ops->txrx_classify_update) 2070 return 0; 2071 2072 return soc->ops->cmn_drv_ops->txrx_classify_update(vdev, 2073 skb, 2074 dir, nbuf_class); 2075 } 2076 2077 /** 2078 * cdp_get_dp_capabilities() - get DP capabilities 2079 * @soc: opaque soc handle 2080 * @dp_cap: enum of DP capabilities 2081 * 2082 * Return: bool 2083 */ 2084 static inline bool 2085 cdp_get_dp_capabilities(struct cdp_soc_t *soc, enum cdp_capabilities dp_caps) 2086 { 2087 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2088 soc->ops->cmn_drv_ops->get_dp_capabilities) 2089 return soc->ops->cmn_drv_ops->get_dp_capabilities(soc, dp_caps); 2090 return false; 2091 } 2092 2093 #ifdef RECEIVE_OFFLOAD 2094 /** 2095 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 2096 * @soc - data path soc handle 2097 * @pdev - device instance pointer 2098 * 2099 * register rx offload flush callback function pointer 2100 * 2101 * return none 2102 */ 2103 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 2104 void (rx_ol_flush_cb)(void *)) 2105 { 2106 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2107 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2108 "%s invalid instance", __func__); 2109 return; 2110 } 2111 2112 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 2113 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 2114 rx_ol_flush_cb); 2115 } 2116 2117 /** 2118 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 2119 * @soc - data path soc handle 2120 * 2121 * deregister rx offload flush callback function pointer 2122 * 2123 * return none 2124 */ 2125 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 2126 { 2127 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2128 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2129 "%s invalid instance", __func__); 2130 return; 2131 } 2132 2133 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 2134 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 2135 } 2136 #endif /* RECEIVE_OFFLOAD */ 2137 2138 /** 2139 * @cdp_set_ba_timeout() - set ba aging timeout per AC 2140 * 2141 * @soc - pointer to the soc 2142 * @value - timeout value in millisec 2143 * @ac - Access category 2144 * 2145 * @return - void 2146 */ 2147 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 2148 uint8_t ac, uint32_t value) 2149 { 2150 if (!soc || !soc->ops) { 2151 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2152 "%s: Invalid Instance", __func__); 2153 QDF_BUG(0); 2154 return; 2155 } 2156 2157 if (!soc->ops->cmn_drv_ops || 2158 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 2159 return; 2160 2161 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 2162 } 2163 2164 /** 2165 * @cdp_get_ba_timeout() - return ba aging timeout per AC 2166 * 2167 * @soc - pointer to the soc 2168 * @ac - access category 2169 * @value - timeout value in millisec 2170 * 2171 * @return - void 2172 */ 2173 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 2174 uint8_t ac, uint32_t *value) 2175 { 2176 if (!soc || !soc->ops) { 2177 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2178 "%s: Invalid Instance", __func__); 2179 QDF_BUG(0); 2180 return; 2181 } 2182 2183 if (!soc->ops->cmn_drv_ops || 2184 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 2185 return; 2186 2187 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 2188 } 2189 2190 /** 2191 * cdp_cfg_get() - get cfg for dp enum 2192 * 2193 * @soc: pointer to the soc 2194 * @cfg: cfg enum 2195 * 2196 * Return - cfg value 2197 */ 2198 static inline uint32_t cdp_cfg_get(ol_txrx_soc_handle soc, enum cdp_dp_cfg cfg) 2199 { 2200 if (!soc || !soc->ops) { 2201 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 2202 "%s: Invalid Instance", __func__); 2203 return 0; 2204 } 2205 2206 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_cfg) 2207 return 0; 2208 2209 return soc->ops->cmn_drv_ops->txrx_get_cfg(soc, cfg); 2210 } 2211 #endif /* _CDP_TXRX_CMN_H_ */ 2212