1 /* 2 * Copyright (c) 2017-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 #include "target_if.h" 20 #include "wlan_lmac_if_def.h" 21 #include "target_if_direct_buf_rx_main.h" 22 #include <target_if_direct_buf_rx_api.h> 23 #include "hal_api.h" 24 #include <service_ready_util.h> 25 #include <init_deinit_lmac.h> 26 27 /** 28 * struct module_name : Module name information structure 29 * @module_name_str : Module name subscribing to DBR 30 */ 31 struct module_name { 32 unsigned char module_name_str[QDF_MAX_NAME_SIZE]; 33 }; 34 35 static const struct module_name g_dbr_module_name[DBR_MODULE_MAX] = { 36 [DBR_MODULE_SPECTRAL] = {"SPECTRAL"}, 37 }; 38 39 static uint8_t get_num_dbr_modules_per_pdev(struct wlan_objmgr_pdev *pdev) 40 { 41 struct wlan_objmgr_psoc *psoc; 42 struct wlan_psoc_host_dbr_ring_caps *dbr_ring_cap; 43 uint8_t num_dbr_ring_caps, cap_idx, pdev_id, num_modules; 44 struct target_psoc_info *tgt_psoc_info; 45 struct wlan_psoc_host_service_ext_param *ext_svc_param; 46 47 psoc = wlan_pdev_get_psoc(pdev); 48 49 if (psoc == NULL) { 50 direct_buf_rx_err("psoc is null"); 51 return 0; 52 } 53 54 tgt_psoc_info = wlan_psoc_get_tgt_if_handle(psoc); 55 if (tgt_psoc_info == NULL) { 56 direct_buf_rx_err("target_psoc_info is null"); 57 return 0; 58 } 59 ext_svc_param = target_psoc_get_service_ext_param(tgt_psoc_info); 60 num_dbr_ring_caps = ext_svc_param->num_dbr_ring_caps; 61 dbr_ring_cap = target_psoc_get_dbr_ring_caps(tgt_psoc_info); 62 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 63 num_modules = 0; 64 65 for (cap_idx = 0; cap_idx < num_dbr_ring_caps; cap_idx++) { 66 if (dbr_ring_cap[cap_idx].pdev_id == pdev_id) 67 num_modules++; 68 } 69 70 return num_modules; 71 } 72 73 static QDF_STATUS populate_dbr_cap_mod_param(struct wlan_objmgr_pdev *pdev, 74 struct direct_buf_rx_module_param *mod_param) 75 { 76 struct wlan_objmgr_psoc *psoc; 77 struct wlan_psoc_host_dbr_ring_caps *dbr_ring_cap; 78 uint8_t cap_idx; 79 bool cap_found = false; 80 enum DBR_MODULE mod_id = mod_param->mod_id; 81 uint32_t num_dbr_ring_caps, pdev_id; 82 struct target_psoc_info *tgt_psoc_info; 83 struct wlan_psoc_host_service_ext_param *ext_svc_param; 84 85 psoc = wlan_pdev_get_psoc(pdev); 86 87 if (psoc == NULL) { 88 direct_buf_rx_err("psoc is null"); 89 return QDF_STATUS_E_INVAL; 90 } 91 92 tgt_psoc_info = wlan_psoc_get_tgt_if_handle(psoc); 93 if (tgt_psoc_info == NULL) { 94 direct_buf_rx_err("target_psoc_info is null"); 95 return QDF_STATUS_E_INVAL; 96 } 97 98 ext_svc_param = target_psoc_get_service_ext_param(tgt_psoc_info); 99 num_dbr_ring_caps = ext_svc_param->num_dbr_ring_caps; 100 dbr_ring_cap = target_psoc_get_dbr_ring_caps(tgt_psoc_info); 101 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 102 103 for (cap_idx = 0; cap_idx < num_dbr_ring_caps; cap_idx++) { 104 if (dbr_ring_cap[cap_idx].pdev_id == pdev_id) { 105 if (dbr_ring_cap[cap_idx].mod_id == mod_id) { 106 mod_param->dbr_ring_cap->ring_elems_min = 107 dbr_ring_cap[cap_idx].ring_elems_min; 108 mod_param->dbr_ring_cap->min_buf_size = 109 dbr_ring_cap[cap_idx].min_buf_size; 110 mod_param->dbr_ring_cap->min_buf_align = 111 dbr_ring_cap[cap_idx].min_buf_align; 112 cap_found = true; 113 } 114 } 115 } 116 117 if (!cap_found) { 118 direct_buf_rx_err("No cap found for module %d in pdev %d", 119 mod_id, pdev_id); 120 return QDF_STATUS_E_FAILURE; 121 } 122 123 return QDF_STATUS_SUCCESS; 124 } 125 126 QDF_STATUS target_if_direct_buf_rx_pdev_create_handler( 127 struct wlan_objmgr_pdev *pdev, void *data) 128 { 129 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 130 struct wlan_objmgr_psoc *psoc; 131 uint8_t num_modules; 132 QDF_STATUS status; 133 134 direct_buf_rx_enter(); 135 136 if (pdev == NULL) { 137 direct_buf_rx_err("pdev context passed is null"); 138 return QDF_STATUS_E_INVAL; 139 } 140 141 psoc = wlan_pdev_get_psoc(pdev); 142 143 if (psoc == NULL) { 144 direct_buf_rx_err("psoc is null"); 145 return QDF_STATUS_E_INVAL; 146 } 147 148 dbr_pdev_obj = qdf_mem_malloc(sizeof(*dbr_pdev_obj)); 149 150 if (dbr_pdev_obj == NULL) { 151 direct_buf_rx_err("Failed to allocate dir buf rx pdev obj"); 152 return QDF_STATUS_E_NOMEM; 153 } 154 155 direct_buf_rx_info("Dbr pdev obj %pK", dbr_pdev_obj); 156 157 status = wlan_objmgr_pdev_component_obj_attach(pdev, 158 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX, 159 dbr_pdev_obj, QDF_STATUS_SUCCESS); 160 161 if (status != QDF_STATUS_SUCCESS) { 162 direct_buf_rx_err("Failed to attach dir buf rx component %d", 163 status); 164 qdf_mem_free(dbr_pdev_obj); 165 return status; 166 } 167 168 num_modules = get_num_dbr_modules_per_pdev(pdev); 169 direct_buf_rx_info("Number of modules = %d pdev %d", num_modules, 170 wlan_objmgr_pdev_get_pdev_id(pdev)); 171 dbr_pdev_obj->num_modules = num_modules; 172 173 if (!dbr_pdev_obj->num_modules) { 174 direct_buf_rx_info("Number of modules = %d", num_modules); 175 return QDF_STATUS_SUCCESS; 176 } 177 178 dbr_pdev_obj->dbr_mod_param = qdf_mem_malloc(num_modules * 179 sizeof(struct direct_buf_rx_module_param)); 180 181 if (dbr_pdev_obj->dbr_mod_param == NULL) { 182 direct_buf_rx_err("Failed to allocate dir buf rx mod param"); 183 wlan_objmgr_pdev_component_obj_detach(pdev, 184 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX, 185 dbr_pdev_obj); 186 qdf_mem_free(dbr_pdev_obj); 187 return QDF_STATUS_E_NOMEM; 188 } 189 190 191 return QDF_STATUS_SUCCESS; 192 } 193 194 QDF_STATUS target_if_direct_buf_rx_pdev_destroy_handler( 195 struct wlan_objmgr_pdev *pdev, void *data) 196 { 197 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 198 QDF_STATUS status; 199 uint8_t num_modules, mod_idx; 200 201 if (pdev == NULL) { 202 direct_buf_rx_err("pdev context passed is null"); 203 return QDF_STATUS_E_INVAL; 204 } 205 206 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 207 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 208 209 if (dbr_pdev_obj == NULL) { 210 direct_buf_rx_err("dir buf rx object is null"); 211 return QDF_STATUS_E_FAILURE; 212 } 213 214 num_modules = dbr_pdev_obj->num_modules; 215 for (mod_idx = 0; mod_idx < num_modules; mod_idx++) 216 target_if_deinit_dbr_ring(pdev, dbr_pdev_obj, mod_idx); 217 218 qdf_mem_free(dbr_pdev_obj->dbr_mod_param); 219 dbr_pdev_obj->dbr_mod_param = NULL; 220 221 status = wlan_objmgr_pdev_component_obj_detach(pdev, 222 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX, 223 dbr_pdev_obj); 224 225 if (status != QDF_STATUS_SUCCESS) { 226 direct_buf_rx_err("failed to detach dir buf rx component %d", 227 status); 228 } 229 230 qdf_mem_free(dbr_pdev_obj); 231 232 return status; 233 } 234 235 QDF_STATUS target_if_direct_buf_rx_psoc_create_handler( 236 struct wlan_objmgr_psoc *psoc, void *data) 237 { 238 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 239 QDF_STATUS status; 240 241 direct_buf_rx_enter(); 242 243 if (psoc == NULL) { 244 direct_buf_rx_err("psoc context passed is null"); 245 return QDF_STATUS_E_INVAL; 246 } 247 248 dbr_psoc_obj = qdf_mem_malloc(sizeof(*dbr_psoc_obj)); 249 250 if (!dbr_psoc_obj) { 251 direct_buf_rx_err("failed to alloc dir buf rx psoc obj"); 252 return QDF_STATUS_E_NOMEM; 253 } 254 255 direct_buf_rx_info("Dbr psoc obj %pK", dbr_psoc_obj); 256 257 status = wlan_objmgr_psoc_component_obj_attach(psoc, 258 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX, dbr_psoc_obj, 259 QDF_STATUS_SUCCESS); 260 261 if (status != QDF_STATUS_SUCCESS) { 262 direct_buf_rx_err("Failed to attach dir buf rx component %d", 263 status); 264 goto attach_error; 265 } 266 267 return status; 268 269 attach_error: 270 qdf_mem_free(dbr_psoc_obj); 271 272 return status; 273 } 274 275 QDF_STATUS target_if_direct_buf_rx_psoc_destroy_handler( 276 struct wlan_objmgr_psoc *psoc, void *data) 277 { 278 QDF_STATUS status; 279 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 280 281 direct_buf_rx_enter(); 282 283 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 284 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 285 286 if (!dbr_psoc_obj) { 287 direct_buf_rx_err("dir buf rx psoc obj is null"); 288 return QDF_STATUS_E_FAILURE; 289 } 290 291 status = wlan_objmgr_psoc_component_obj_detach(psoc, 292 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX, 293 dbr_psoc_obj); 294 295 if (status != QDF_STATUS_SUCCESS) { 296 direct_buf_rx_err("failed to detach dir buf rx component %d", 297 status); 298 } 299 300 qdf_mem_free(dbr_psoc_obj); 301 302 return status; 303 } 304 305 static QDF_STATUS target_if_dbr_replenish_ring(struct wlan_objmgr_pdev *pdev, 306 struct direct_buf_rx_module_param *mod_param, 307 void *aligned_vaddr, uint32_t cookie) 308 { 309 uint64_t *ring_entry; 310 uint32_t dw_lo, dw_hi = 0, map_status; 311 void *hal_soc, *srng; 312 qdf_dma_addr_t paddr; 313 struct wlan_objmgr_psoc *psoc; 314 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 315 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 316 struct direct_buf_rx_ring_cap *dbr_ring_cap; 317 struct direct_buf_rx_buf_info *dbr_buf_pool; 318 319 direct_buf_rx_enter(); 320 321 dbr_ring_cfg = mod_param->dbr_ring_cfg; 322 dbr_ring_cap = mod_param->dbr_ring_cap; 323 dbr_buf_pool = mod_param->dbr_buf_pool; 324 325 psoc = wlan_pdev_get_psoc(pdev); 326 327 if (!psoc) { 328 direct_buf_rx_err("psoc is null"); 329 return QDF_STATUS_E_FAILURE; 330 } 331 332 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 333 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 334 335 if (dbr_psoc_obj == NULL) { 336 direct_buf_rx_err("dir buf rx psoc object is null"); 337 return QDF_STATUS_E_FAILURE; 338 } 339 340 hal_soc = dbr_psoc_obj->hal_soc; 341 srng = dbr_ring_cfg->srng; 342 if (!aligned_vaddr) { 343 direct_buf_rx_err("aligned vaddr is null"); 344 return QDF_STATUS_SUCCESS; 345 } 346 347 map_status = qdf_mem_map_nbytes_single(dbr_psoc_obj->osdev, 348 aligned_vaddr, 349 QDF_DMA_FROM_DEVICE, 350 dbr_ring_cap->min_buf_size, 351 &paddr); 352 if (map_status) { 353 direct_buf_rx_err("mem map failed status = %d", map_status); 354 return QDF_STATUS_E_FAILURE; 355 } 356 357 QDF_ASSERT(!((uint64_t)paddr % dbr_ring_cap->min_buf_align)); 358 dbr_buf_pool[cookie].paddr = paddr; 359 360 hal_srng_access_start(hal_soc, srng); 361 ring_entry = hal_srng_src_get_next(hal_soc, srng); 362 QDF_ASSERT(ring_entry != NULL); 363 dw_lo = (uint64_t)paddr & 0xFFFFFFFF; 364 WMI_HOST_DBR_RING_ADDR_HI_SET(dw_hi, (uint64_t)paddr >> 32); 365 WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_SET(dw_hi, cookie); 366 direct_buf_rx_info("Cookie = %d", cookie); 367 direct_buf_rx_info("dw_lo = %x dw_hi = %x", dw_lo, dw_hi); 368 *ring_entry = (uint64_t)dw_hi << 32 | dw_lo; 369 direct_buf_rx_info("Valid ring entry"); 370 hal_srng_access_end(hal_soc, srng); 371 372 return QDF_STATUS_SUCCESS; 373 } 374 375 static QDF_STATUS target_if_dbr_fill_ring(struct wlan_objmgr_pdev *pdev, 376 struct direct_buf_rx_module_param *mod_param) 377 { 378 uint32_t idx; 379 void *buf, *buf_aligned; 380 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 381 struct direct_buf_rx_ring_cap *dbr_ring_cap; 382 struct direct_buf_rx_buf_info *dbr_buf_pool; 383 QDF_STATUS status; 384 385 direct_buf_rx_enter(); 386 387 dbr_ring_cfg = mod_param->dbr_ring_cfg; 388 dbr_ring_cap = mod_param->dbr_ring_cap; 389 dbr_buf_pool = mod_param->dbr_buf_pool; 390 391 for (idx = 0; idx < dbr_ring_cfg->num_ptr - 1; idx++) { 392 buf_aligned = qdf_aligned_malloc(dbr_ring_cap->min_buf_size, 393 dbr_ring_cap->min_buf_align, 394 &buf); 395 if (!buf_aligned) { 396 direct_buf_rx_err( 397 "dir buf rx ring buf_aligned alloc failed"); 398 return QDF_STATUS_E_NOMEM; 399 } 400 dbr_buf_pool[idx].vaddr = buf; 401 dbr_buf_pool[idx].offset = buf_aligned - buf; 402 dbr_buf_pool[idx].cookie = idx; 403 status = target_if_dbr_replenish_ring(pdev, mod_param, 404 buf_aligned, idx); 405 if (QDF_IS_STATUS_ERROR(status)) { 406 direct_buf_rx_err("replenish failed with status : %d", 407 status); 408 qdf_mem_free(buf); 409 return QDF_STATUS_E_FAILURE; 410 } 411 } 412 413 return QDF_STATUS_SUCCESS; 414 } 415 416 static QDF_STATUS target_if_dbr_init_ring(struct wlan_objmgr_pdev *pdev, 417 struct direct_buf_rx_module_param *mod_param) 418 { 419 void *srng; 420 uint32_t num_entries, ring_alloc_size, max_entries, entry_size; 421 qdf_dma_addr_t paddr; 422 struct hal_srng_params ring_params = {0}; 423 struct wlan_objmgr_psoc *psoc; 424 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 425 struct direct_buf_rx_ring_cap *dbr_ring_cap; 426 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 427 QDF_STATUS status; 428 429 direct_buf_rx_enter(); 430 431 psoc = wlan_pdev_get_psoc(pdev); 432 433 if (!psoc) { 434 direct_buf_rx_err("psoc is null"); 435 return QDF_STATUS_E_FAILURE; 436 } 437 438 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 439 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 440 441 if (dbr_psoc_obj == NULL) { 442 direct_buf_rx_err("dir buf rx psoc object is null"); 443 return QDF_STATUS_E_FAILURE; 444 } 445 446 if (dbr_psoc_obj->hal_soc == NULL || 447 dbr_psoc_obj->osdev == NULL) { 448 direct_buf_rx_err("dir buf rx target attach failed"); 449 return QDF_STATUS_E_FAILURE; 450 } 451 452 max_entries = hal_srng_max_entries(dbr_psoc_obj->hal_soc, 453 DIR_BUF_RX_DMA_SRC); 454 entry_size = hal_srng_get_entrysize(dbr_psoc_obj->hal_soc, 455 DIR_BUF_RX_DMA_SRC); 456 direct_buf_rx_info("Max Entries = %d", max_entries); 457 direct_buf_rx_info("Entry Size = %d", entry_size); 458 459 status = populate_dbr_cap_mod_param(pdev, mod_param); 460 if (QDF_IS_STATUS_ERROR(status)) { 461 direct_buf_rx_err("Module cap population failed"); 462 return QDF_STATUS_E_FAILURE; 463 } 464 465 dbr_ring_cap = mod_param->dbr_ring_cap; 466 dbr_ring_cfg = mod_param->dbr_ring_cfg; 467 num_entries = dbr_ring_cap->ring_elems_min > max_entries ? 468 max_entries : dbr_ring_cap->ring_elems_min; 469 direct_buf_rx_info("Num entries = %d", num_entries); 470 dbr_ring_cfg->num_ptr = num_entries; 471 mod_param->dbr_buf_pool = qdf_mem_malloc(num_entries * sizeof( 472 struct direct_buf_rx_buf_info)); 473 if (!mod_param->dbr_buf_pool) { 474 direct_buf_rx_err("dir buf rx buf pool alloc failed"); 475 return QDF_STATUS_E_NOMEM; 476 } 477 478 ring_alloc_size = (num_entries * entry_size) + DBR_RING_BASE_ALIGN - 1; 479 dbr_ring_cfg->ring_alloc_size = ring_alloc_size; 480 direct_buf_rx_info("dbr_psoc_obj %pK", dbr_psoc_obj); 481 dbr_ring_cfg->base_vaddr_unaligned = qdf_mem_alloc_consistent( 482 dbr_psoc_obj->osdev, dbr_psoc_obj->osdev->dev, ring_alloc_size, 483 &paddr); 484 direct_buf_rx_info("vaddr aligned allocated"); 485 dbr_ring_cfg->base_paddr_unaligned = paddr; 486 if (!dbr_ring_cfg->base_vaddr_unaligned) { 487 direct_buf_rx_err("dir buf rx vaddr alloc failed"); 488 qdf_mem_free(mod_param->dbr_buf_pool); 489 return QDF_STATUS_E_NOMEM; 490 } 491 492 /* Alignment is defined to 8 for now. Will be advertised by FW */ 493 dbr_ring_cfg->base_vaddr_aligned = (void *)(uintptr_t)qdf_roundup( 494 (uint64_t)(uintptr_t)dbr_ring_cfg->base_vaddr_unaligned, 495 DBR_RING_BASE_ALIGN); 496 ring_params.ring_base_vaddr = dbr_ring_cfg->base_vaddr_aligned; 497 dbr_ring_cfg->base_paddr_aligned = qdf_roundup( 498 (uint64_t)dbr_ring_cfg->base_paddr_unaligned, 499 DBR_RING_BASE_ALIGN); 500 ring_params.ring_base_paddr = 501 (qdf_dma_addr_t)dbr_ring_cfg->base_paddr_aligned; 502 ring_params.num_entries = num_entries; 503 srng = hal_srng_setup(dbr_psoc_obj->hal_soc, DIR_BUF_RX_DMA_SRC, 0, 504 wlan_objmgr_pdev_get_pdev_id(pdev), &ring_params); 505 506 if (!srng) { 507 direct_buf_rx_err("srng setup failed"); 508 qdf_mem_free(mod_param->dbr_buf_pool); 509 qdf_mem_free_consistent(dbr_psoc_obj->osdev, 510 dbr_psoc_obj->osdev->dev, 511 ring_alloc_size, 512 dbr_ring_cfg->base_vaddr_unaligned, 513 (qdf_dma_addr_t)dbr_ring_cfg->base_paddr_unaligned, 0); 514 return QDF_STATUS_E_FAILURE; 515 } 516 dbr_ring_cfg->srng = srng; 517 dbr_ring_cfg->tail_idx_addr = 518 hal_srng_get_tp_addr(dbr_psoc_obj->hal_soc, srng); 519 dbr_ring_cfg->head_idx_addr = 520 hal_srng_get_hp_addr(dbr_psoc_obj->hal_soc, srng); 521 dbr_ring_cfg->buf_size = dbr_ring_cap->min_buf_size; 522 523 return target_if_dbr_fill_ring(pdev, mod_param); 524 } 525 526 static QDF_STATUS target_if_dbr_init_srng(struct wlan_objmgr_pdev *pdev, 527 struct direct_buf_rx_module_param *mod_param) 528 { 529 QDF_STATUS status; 530 531 direct_buf_rx_info("Init DBR srng"); 532 533 if (!mod_param) { 534 direct_buf_rx_err("dir buf rx module param is null"); 535 return QDF_STATUS_E_INVAL; 536 } 537 538 mod_param->dbr_ring_cap = qdf_mem_malloc(sizeof( 539 struct direct_buf_rx_ring_cap)); 540 541 if (!mod_param->dbr_ring_cap) { 542 direct_buf_rx_err("Ring cap alloc failed"); 543 return QDF_STATUS_E_NOMEM; 544 } 545 546 /* Allocate memory for DBR Ring Config */ 547 mod_param->dbr_ring_cfg = qdf_mem_malloc(sizeof( 548 struct direct_buf_rx_ring_cfg)); 549 550 if (!mod_param->dbr_ring_cfg) { 551 direct_buf_rx_err("Ring config alloc failed"); 552 qdf_mem_free(mod_param->dbr_ring_cap); 553 return QDF_STATUS_E_NOMEM; 554 } 555 556 status = target_if_dbr_init_ring(pdev, mod_param); 557 558 if (QDF_IS_STATUS_ERROR(status)) { 559 direct_buf_rx_err("DBR ring init failed"); 560 qdf_mem_free(mod_param->dbr_ring_cfg); 561 qdf_mem_free(mod_param->dbr_ring_cap); 562 return QDF_STATUS_E_FAILURE; 563 } 564 565 return QDF_STATUS_SUCCESS; 566 } 567 568 static QDF_STATUS target_if_dbr_cfg_tgt(struct wlan_objmgr_pdev *pdev, 569 struct direct_buf_rx_module_param *mod_param) 570 { 571 QDF_STATUS status; 572 struct wlan_objmgr_psoc *psoc; 573 void *wmi_hdl; 574 struct direct_buf_rx_cfg_req dbr_cfg_req = {0}; 575 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 576 struct direct_buf_rx_ring_cap *dbr_ring_cap; 577 578 direct_buf_rx_enter(); 579 580 psoc = wlan_pdev_get_psoc(pdev); 581 if (!psoc) { 582 direct_buf_rx_err("psoc is null"); 583 return QDF_STATUS_E_FAILURE; 584 } 585 586 dbr_ring_cfg = mod_param->dbr_ring_cfg; 587 dbr_ring_cap = mod_param->dbr_ring_cap; 588 wmi_hdl = lmac_get_pdev_wmi_handle(pdev); 589 if (!wmi_hdl) { 590 direct_buf_rx_err("WMI handle null. Can't send WMI CMD"); 591 return QDF_STATUS_E_INVAL; 592 } 593 594 direct_buf_rx_debug("Sending DBR Ring CFG to target"); 595 dbr_cfg_req.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 596 /* Module ID numbering starts from 1 in FW. need to fix it */ 597 dbr_cfg_req.mod_id = mod_param->mod_id; 598 dbr_cfg_req.base_paddr_lo = (uint64_t)dbr_ring_cfg->base_paddr_aligned 599 & 0xFFFFFFFF; 600 dbr_cfg_req.base_paddr_hi = (uint64_t)dbr_ring_cfg->base_paddr_aligned 601 & 0xFFFFFFFF00000000; 602 dbr_cfg_req.head_idx_paddr_lo = (uint64_t)dbr_ring_cfg->head_idx_addr 603 & 0xFFFFFFFF; 604 dbr_cfg_req.head_idx_paddr_hi = (uint64_t)dbr_ring_cfg->head_idx_addr 605 & 0xFFFFFFFF00000000; 606 dbr_cfg_req.tail_idx_paddr_lo = (uint64_t)dbr_ring_cfg->tail_idx_addr 607 & 0xFFFFFFFF; 608 dbr_cfg_req.tail_idx_paddr_hi = (uint64_t)dbr_ring_cfg->tail_idx_addr 609 & 0xFFFFFFFF00000000; 610 dbr_cfg_req.num_elems = dbr_ring_cap->ring_elems_min; 611 dbr_cfg_req.buf_size = dbr_ring_cap->min_buf_size; 612 dbr_cfg_req.num_resp_per_event = DBR_NUM_RESP_PER_EVENT; 613 dbr_cfg_req.event_timeout_ms = DBR_EVENT_TIMEOUT_IN_MS; 614 direct_buf_rx_info("pdev id %d mod id %d base addr lo %x\n" 615 "base addr hi %x head idx addr lo %x\n" 616 "head idx addr hi %x tail idx addr lo %x\n" 617 "tail idx addr hi %x num ptr %d\n" 618 "num resp %d event timeout %d\n", 619 dbr_cfg_req.pdev_id, dbr_cfg_req.mod_id, 620 dbr_cfg_req.base_paddr_lo, dbr_cfg_req.base_paddr_hi, 621 dbr_cfg_req.head_idx_paddr_lo, 622 dbr_cfg_req.head_idx_paddr_hi, 623 dbr_cfg_req.tail_idx_paddr_lo, 624 dbr_cfg_req.tail_idx_paddr_hi, 625 dbr_cfg_req.num_elems, 626 dbr_cfg_req.num_resp_per_event, 627 dbr_cfg_req.event_timeout_ms); 628 status = wmi_unified_dbr_ring_cfg(wmi_hdl, &dbr_cfg_req); 629 630 return status; 631 } 632 633 static QDF_STATUS target_if_init_dbr_ring(struct wlan_objmgr_pdev *pdev, 634 struct direct_buf_rx_pdev_obj *dbr_pdev_obj, 635 enum DBR_MODULE mod_id) 636 { 637 QDF_STATUS status = QDF_STATUS_SUCCESS; 638 struct direct_buf_rx_module_param *mod_param; 639 640 direct_buf_rx_info("Init DBR ring for module %d", mod_id); 641 642 if (!dbr_pdev_obj) { 643 direct_buf_rx_err("dir buf rx object is null"); 644 return QDF_STATUS_E_INVAL; 645 } 646 647 mod_param = &(dbr_pdev_obj->dbr_mod_param[mod_id]); 648 649 if (!mod_param) { 650 direct_buf_rx_err("dir buf rx module param is null"); 651 return QDF_STATUS_E_FAILURE; 652 } 653 654 direct_buf_rx_info("mod_param %pK", mod_param); 655 656 mod_param->mod_id = mod_id; 657 658 /* Initialize DMA ring now */ 659 status = target_if_dbr_init_srng(pdev, mod_param); 660 if (QDF_IS_STATUS_ERROR(status)) { 661 direct_buf_rx_err("DBR ring init failed %d", status); 662 return status; 663 } 664 665 /* Send CFG request command to firmware */ 666 status = target_if_dbr_cfg_tgt(pdev, mod_param); 667 if (QDF_IS_STATUS_ERROR(status)) { 668 direct_buf_rx_err("DBR config to target failed %d", status); 669 goto dbr_srng_init_failed; 670 } 671 672 return QDF_STATUS_SUCCESS; 673 674 dbr_srng_init_failed: 675 target_if_deinit_dbr_ring(pdev, dbr_pdev_obj, mod_id); 676 return status; 677 } 678 679 QDF_STATUS target_if_direct_buf_rx_module_register( 680 struct wlan_objmgr_pdev *pdev, uint8_t mod_id, 681 int (*dbr_rsp_handler)(struct wlan_objmgr_pdev *pdev, 682 struct direct_buf_rx_data *dbr_data)) 683 { 684 QDF_STATUS status; 685 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 686 687 if (pdev == NULL) { 688 direct_buf_rx_err("pdev context passed is null"); 689 return QDF_STATUS_E_INVAL; 690 } 691 692 if (dbr_rsp_handler == NULL) { 693 direct_buf_rx_err("Response handler is null"); 694 return QDF_STATUS_E_INVAL; 695 } 696 697 if (mod_id >= DBR_MODULE_MAX) { 698 direct_buf_rx_err("Invalid module id"); 699 return QDF_STATUS_E_INVAL; 700 } 701 702 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 703 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 704 705 if (dbr_pdev_obj == NULL) { 706 direct_buf_rx_err("dir buf rx object is null"); 707 return QDF_STATUS_E_FAILURE; 708 } 709 710 direct_buf_rx_info("Dbr pdev obj %pK", dbr_pdev_obj); 711 712 if (!dbr_pdev_obj->dbr_mod_param) { 713 direct_buf_rx_err("dbr_pdev_obj->dbr_mod_param is NULL"); 714 return QDF_STATUS_E_FAILURE; 715 } 716 717 if (mod_id >= dbr_pdev_obj->num_modules) { 718 direct_buf_rx_err("Module %d not supported in target", mod_id); 719 return QDF_STATUS_E_FAILURE; 720 } 721 722 dbr_pdev_obj->dbr_mod_param[mod_id].dbr_rsp_handler = 723 dbr_rsp_handler; 724 725 status = target_if_init_dbr_ring(pdev, dbr_pdev_obj, 726 (enum DBR_MODULE)mod_id); 727 728 return status; 729 } 730 731 QDF_STATUS target_if_direct_buf_rx_module_unregister( 732 struct wlan_objmgr_pdev *pdev, uint8_t mod_id) 733 { 734 QDF_STATUS status; 735 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 736 737 if (!pdev) { 738 direct_buf_rx_err("pdev context passed is null"); 739 return QDF_STATUS_E_INVAL; 740 } 741 742 if (mod_id >= DBR_MODULE_MAX) { 743 direct_buf_rx_err("Invalid module id"); 744 return QDF_STATUS_E_INVAL; 745 } 746 747 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj 748 (pdev, 749 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 750 751 if (!dbr_pdev_obj) { 752 direct_buf_rx_err("dir buf rx object is null"); 753 return QDF_STATUS_E_FAILURE; 754 } 755 756 direct_buf_rx_info("Dbr pdev obj %pK", dbr_pdev_obj); 757 758 if (!dbr_pdev_obj->dbr_mod_param) { 759 direct_buf_rx_err("dbr_pdev_obj->dbr_mod_param is NULL"); 760 return QDF_STATUS_E_FAILURE; 761 } 762 763 if (mod_id >= dbr_pdev_obj->num_modules) { 764 direct_buf_rx_err("Module %d not supported in target", mod_id); 765 return QDF_STATUS_E_FAILURE; 766 } 767 768 status = target_if_deinit_dbr_ring(pdev, dbr_pdev_obj, mod_id); 769 770 return status; 771 } 772 773 static void *target_if_dbr_vaddr_lookup( 774 struct direct_buf_rx_module_param *mod_param, 775 qdf_dma_addr_t paddr, uint32_t cookie) 776 { 777 struct direct_buf_rx_buf_info *dbr_buf_pool; 778 779 dbr_buf_pool = mod_param->dbr_buf_pool; 780 781 if (dbr_buf_pool[cookie].paddr == paddr) { 782 return dbr_buf_pool[cookie].vaddr + 783 dbr_buf_pool[cookie].offset; 784 } 785 786 direct_buf_rx_err("Incorrect paddr found on cookie slot"); 787 return NULL; 788 } 789 790 static QDF_STATUS target_if_get_dbr_data(struct wlan_objmgr_pdev *pdev, 791 struct direct_buf_rx_module_param *mod_param, 792 struct direct_buf_rx_rsp *dbr_rsp, 793 struct direct_buf_rx_data *dbr_data, 794 uint8_t idx, uint32_t *cookie) 795 { 796 qdf_dma_addr_t paddr = 0; 797 uint32_t addr_hi; 798 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 799 struct direct_buf_rx_ring_cap *dbr_ring_cap; 800 struct wlan_objmgr_psoc *psoc; 801 802 psoc = wlan_pdev_get_psoc(pdev); 803 if (!psoc) { 804 direct_buf_rx_err("psoc is null"); 805 return QDF_STATUS_E_FAILURE; 806 } 807 808 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 809 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 810 811 if (dbr_psoc_obj == NULL) { 812 direct_buf_rx_err("dir buf rx psoc object is null"); 813 return QDF_STATUS_E_FAILURE; 814 } 815 816 dbr_ring_cap = mod_param->dbr_ring_cap; 817 addr_hi = (uint64_t)WMI_HOST_DBR_DATA_ADDR_HI_GET( 818 dbr_rsp->dbr_entries[idx].paddr_hi); 819 paddr = (qdf_dma_addr_t)((uint64_t)addr_hi << 32 | 820 dbr_rsp->dbr_entries[idx].paddr_lo); 821 *cookie = WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_GET( 822 dbr_rsp->dbr_entries[idx].paddr_hi); 823 direct_buf_rx_info("Cookie = %d", *cookie); 824 dbr_data->vaddr = target_if_dbr_vaddr_lookup(mod_param, paddr, *cookie); 825 direct_buf_rx_info("Vaddr look up = %x", dbr_data->vaddr); 826 dbr_data->dbr_len = dbr_rsp->dbr_entries[idx].len; 827 qdf_mem_unmap_nbytes_single(dbr_psoc_obj->osdev, (qdf_dma_addr_t)paddr, 828 QDF_DMA_FROM_DEVICE, 829 dbr_ring_cap->min_buf_size); 830 831 return QDF_STATUS_SUCCESS; 832 } 833 834 static int target_if_direct_buf_rx_rsp_event_handler(ol_scn_t scn, 835 uint8_t *data_buf, 836 uint32_t data_len) 837 { 838 int ret = 0; 839 uint8_t i = 0; 840 QDF_STATUS status; 841 uint32_t cookie = 0; 842 struct direct_buf_rx_rsp dbr_rsp = {0}; 843 struct direct_buf_rx_data dbr_data = {0}; 844 struct wlan_objmgr_psoc *psoc; 845 struct wlan_objmgr_pdev *pdev; 846 struct direct_buf_rx_buf_info *dbr_buf_pool; 847 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 848 struct direct_buf_rx_module_param *mod_param; 849 struct common_wmi_handle *wmi_handle; 850 851 direct_buf_rx_enter(); 852 853 psoc = target_if_get_psoc_from_scn_hdl(scn); 854 if (!psoc) { 855 direct_buf_rx_err("psoc is null"); 856 return QDF_STATUS_E_FAILURE; 857 } 858 859 wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); 860 if (!wmi_handle) { 861 direct_buf_rx_err("WMI handle is null"); 862 return QDF_STATUS_E_FAILURE; 863 } 864 865 if (wmi_extract_dbr_buf_release_fixed( 866 wmi_handle, data_buf, &dbr_rsp) != QDF_STATUS_SUCCESS) { 867 direct_buf_rx_err("unable to extract DBR rsp fixed param"); 868 return QDF_STATUS_E_FAILURE; 869 } 870 871 direct_buf_rx_info("Num buf release entry = %d", 872 dbr_rsp.num_buf_release_entry); 873 874 pdev = wlan_objmgr_get_pdev_by_id(psoc, dbr_rsp.pdev_id, 875 WLAN_DIRECT_BUF_RX_ID); 876 if (!pdev) { 877 direct_buf_rx_err("pdev is null"); 878 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 879 return QDF_STATUS_E_INVAL; 880 } 881 882 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 883 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 884 885 if (dbr_pdev_obj == NULL) { 886 direct_buf_rx_err("dir buf rx object is null"); 887 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 888 return QDF_STATUS_E_FAILURE; 889 } 890 891 mod_param = &(dbr_pdev_obj->dbr_mod_param[dbr_rsp.mod_id]); 892 893 if (!mod_param) { 894 direct_buf_rx_err("dir buf rx module param is null"); 895 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 896 return QDF_STATUS_E_FAILURE; 897 } 898 899 dbr_buf_pool = mod_param->dbr_buf_pool; 900 dbr_rsp.dbr_entries = qdf_mem_malloc(dbr_rsp.num_buf_release_entry * 901 sizeof(struct direct_buf_rx_entry)); 902 903 if (dbr_rsp.num_meta_data_entry > dbr_rsp.num_buf_release_entry) { 904 direct_buf_rx_err("More than expected number of metadata"); 905 wlan_objmgr_pdev_release_ref(pdev, 906 WLAN_DIRECT_BUF_RX_ID); 907 return QDF_STATUS_E_FAILURE; 908 } 909 910 for (i = 0; i < dbr_rsp.num_buf_release_entry; i++) { 911 if (wmi_extract_dbr_buf_release_entry( 912 wmi_handle, data_buf, i, 913 &dbr_rsp.dbr_entries[i]) != QDF_STATUS_SUCCESS) { 914 direct_buf_rx_err("Unable to extract DBR buf entry %d", 915 i+1); 916 qdf_mem_free(dbr_rsp.dbr_entries); 917 wlan_objmgr_pdev_release_ref(pdev, 918 WLAN_DIRECT_BUF_RX_ID); 919 return QDF_STATUS_E_FAILURE; 920 } 921 status = target_if_get_dbr_data(pdev, mod_param, &dbr_rsp, 922 &dbr_data, i, &cookie); 923 924 if (QDF_IS_STATUS_ERROR(status)) { 925 direct_buf_rx_err("DBR data get failed"); 926 qdf_mem_free(dbr_rsp.dbr_entries); 927 wlan_objmgr_pdev_release_ref(pdev, 928 WLAN_DIRECT_BUF_RX_ID); 929 return QDF_STATUS_E_FAILURE; 930 } 931 932 dbr_data.meta_data_valid = false; 933 if (i < dbr_rsp.num_meta_data_entry) { 934 if (wmi_extract_dbr_buf_metadata( 935 wmi_handle, data_buf, i, 936 &dbr_data.meta_data) == QDF_STATUS_SUCCESS) 937 dbr_data.meta_data_valid = true; 938 } 939 ret = mod_param->dbr_rsp_handler(pdev, &dbr_data); 940 status = target_if_dbr_replenish_ring(pdev, mod_param, 941 dbr_data.vaddr, cookie); 942 if (QDF_IS_STATUS_ERROR(status)) { 943 direct_buf_rx_err("dir buf rx ring replenish failed"); 944 qdf_mem_free(dbr_rsp.dbr_entries); 945 wlan_objmgr_pdev_release_ref(pdev, 946 WLAN_DIRECT_BUF_RX_ID); 947 return QDF_STATUS_E_FAILURE; 948 } 949 } 950 951 qdf_mem_free(dbr_rsp.dbr_entries); 952 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 953 954 return ret; 955 } 956 957 static QDF_STATUS target_if_dbr_empty_ring(struct wlan_objmgr_pdev *pdev, 958 struct direct_buf_rx_psoc_obj *dbr_psoc_obj, 959 struct direct_buf_rx_module_param *mod_param) 960 { 961 uint32_t idx; 962 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 963 struct direct_buf_rx_ring_cap *dbr_ring_cap; 964 struct direct_buf_rx_buf_info *dbr_buf_pool; 965 966 direct_buf_rx_enter(); 967 dbr_ring_cfg = mod_param->dbr_ring_cfg; 968 dbr_ring_cap = mod_param->dbr_ring_cap; 969 dbr_buf_pool = mod_param->dbr_buf_pool; 970 971 direct_buf_rx_info("dbr_ring_cfg %pK, dbr_ring_cap %pK dbr_buf_pool %pK", 972 dbr_ring_cfg, dbr_ring_cap, dbr_buf_pool); 973 974 for (idx = 0; idx < dbr_ring_cfg->num_ptr - 1; idx++) { 975 direct_buf_rx_info("dbr buf pool unmap and free for ptr %d", 976 idx); 977 qdf_mem_unmap_nbytes_single(dbr_psoc_obj->osdev, 978 (qdf_dma_addr_t)dbr_buf_pool[idx].paddr, 979 QDF_DMA_FROM_DEVICE, 980 dbr_ring_cap->min_buf_size); 981 qdf_mem_free(dbr_buf_pool[idx].vaddr); 982 } 983 984 return QDF_STATUS_SUCCESS; 985 } 986 987 static QDF_STATUS target_if_dbr_deinit_ring(struct wlan_objmgr_pdev *pdev, 988 struct direct_buf_rx_module_param *mod_param) 989 { 990 struct wlan_objmgr_psoc *psoc; 991 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 992 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 993 994 direct_buf_rx_enter(); 995 psoc = wlan_pdev_get_psoc(pdev); 996 if (!psoc) { 997 direct_buf_rx_err("psoc is null"); 998 return QDF_STATUS_E_FAILURE; 999 } 1000 1001 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 1002 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 1003 1004 if (dbr_psoc_obj == NULL) { 1005 direct_buf_rx_err("dir buf rx psoc object is null"); 1006 return QDF_STATUS_E_FAILURE; 1007 } 1008 direct_buf_rx_info("dbr_psoc_obj %pK", dbr_psoc_obj); 1009 1010 dbr_ring_cfg = mod_param->dbr_ring_cfg; 1011 if (dbr_ring_cfg) { 1012 target_if_dbr_empty_ring(pdev, dbr_psoc_obj, mod_param); 1013 hal_srng_cleanup(dbr_psoc_obj->hal_soc, dbr_ring_cfg->srng); 1014 qdf_mem_free_consistent(dbr_psoc_obj->osdev, 1015 dbr_psoc_obj->osdev->dev, 1016 dbr_ring_cfg->ring_alloc_size, 1017 dbr_ring_cfg->base_vaddr_unaligned, 1018 (qdf_dma_addr_t)dbr_ring_cfg->base_paddr_unaligned, 0); 1019 } 1020 1021 return QDF_STATUS_SUCCESS; 1022 } 1023 1024 static QDF_STATUS target_if_dbr_deinit_srng( 1025 struct wlan_objmgr_pdev *pdev, 1026 struct direct_buf_rx_module_param *mod_param) 1027 { 1028 struct direct_buf_rx_buf_info *dbr_buf_pool; 1029 1030 direct_buf_rx_enter(); 1031 dbr_buf_pool = mod_param->dbr_buf_pool; 1032 direct_buf_rx_info("dbr buf pool %pK", dbr_buf_pool); 1033 target_if_dbr_deinit_ring(pdev, mod_param); 1034 if (mod_param->dbr_buf_pool) 1035 qdf_mem_free(dbr_buf_pool); 1036 mod_param->dbr_buf_pool = NULL; 1037 1038 return QDF_STATUS_SUCCESS; 1039 } 1040 1041 QDF_STATUS target_if_deinit_dbr_ring(struct wlan_objmgr_pdev *pdev, 1042 struct direct_buf_rx_pdev_obj *dbr_pdev_obj, 1043 enum DBR_MODULE mod_id) 1044 { 1045 struct direct_buf_rx_module_param *mod_param; 1046 1047 direct_buf_rx_enter(); 1048 mod_param = &(dbr_pdev_obj->dbr_mod_param[mod_id]); 1049 1050 if (!mod_param) { 1051 direct_buf_rx_err("dir buf rx module param is null"); 1052 return QDF_STATUS_E_FAILURE; 1053 } 1054 direct_buf_rx_info("mod_param %pK", mod_param); 1055 direct_buf_rx_info("dbr_ring_cap %pK", mod_param->dbr_ring_cap); 1056 target_if_dbr_deinit_srng(pdev, mod_param); 1057 if (mod_param->dbr_ring_cap) 1058 qdf_mem_free(mod_param->dbr_ring_cap); 1059 mod_param->dbr_ring_cap = NULL; 1060 if (mod_param->dbr_ring_cfg) 1061 qdf_mem_free(mod_param->dbr_ring_cfg); 1062 mod_param->dbr_ring_cfg = NULL; 1063 1064 return QDF_STATUS_SUCCESS; 1065 } 1066 1067 QDF_STATUS target_if_direct_buf_rx_register_events( 1068 struct wlan_objmgr_psoc *psoc) 1069 { 1070 int ret; 1071 1072 if (!psoc || !GET_WMI_HDL_FROM_PSOC(psoc)) { 1073 direct_buf_rx_err("psoc or psoc->tgt_if_handle is null"); 1074 return QDF_STATUS_E_INVAL; 1075 } 1076 1077 ret = wmi_unified_register_event_handler( 1078 get_wmi_unified_hdl_from_psoc(psoc), 1079 wmi_dma_buf_release_event_id, 1080 target_if_direct_buf_rx_rsp_event_handler, 1081 WMI_RX_UMAC_CTX); 1082 1083 if (ret) 1084 direct_buf_rx_info("event handler not supported", ret); 1085 1086 return QDF_STATUS_SUCCESS; 1087 } 1088 1089 QDF_STATUS target_if_direct_buf_rx_unregister_events( 1090 struct wlan_objmgr_psoc *psoc) 1091 { 1092 if (!psoc || !GET_WMI_HDL_FROM_PSOC(psoc)) { 1093 direct_buf_rx_err("psoc or psoc->tgt_if_handle is null"); 1094 return QDF_STATUS_E_INVAL; 1095 } 1096 1097 wmi_unified_unregister_event_handler( 1098 get_wmi_unified_hdl_from_psoc(psoc), 1099 wmi_dma_buf_release_event_id); 1100 1101 return QDF_STATUS_SUCCESS; 1102 } 1103 1104 QDF_STATUS target_if_direct_buf_rx_print_ring_stat( 1105 struct wlan_objmgr_pdev *pdev) 1106 { 1107 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 1108 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 1109 struct wlan_objmgr_psoc *psoc; 1110 void *srng, *hal_soc; 1111 uint32_t hp = 0, tp = 0; 1112 struct direct_buf_rx_module_param *mod_param; 1113 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 1114 uint8_t num_modules, mod_idx; 1115 1116 if (!pdev) { 1117 direct_buf_rx_err("pdev is null"); 1118 return QDF_STATUS_E_INVAL; 1119 } 1120 1121 psoc = wlan_pdev_get_psoc(pdev); 1122 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 1123 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 1124 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 1125 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 1126 hal_soc = dbr_psoc_obj->hal_soc; 1127 num_modules = dbr_pdev_obj->num_modules; 1128 direct_buf_rx_err("--------------------------------------------------"); 1129 direct_buf_rx_err("| Module ID | Module | Head Idx | Tail Idx |"); 1130 direct_buf_rx_err("--------------------------------------------------"); 1131 for (mod_idx = 0; mod_idx < num_modules; mod_idx++) { 1132 mod_param = &dbr_pdev_obj->dbr_mod_param[mod_idx]; 1133 dbr_ring_cfg = mod_param->dbr_ring_cfg; 1134 srng = dbr_ring_cfg->srng; 1135 hal_get_sw_hptp(hal_soc, srng, &tp, &hp); 1136 direct_buf_rx_err("|%11d|%14s|%10x|%10x|", 1137 mod_idx, 1138 g_dbr_module_name[mod_idx].module_name_str, 1139 hp, tp); 1140 } 1141 direct_buf_rx_err("--------------------------------------------------"); 1142 1143 return QDF_STATUS_SUCCESS; 1144 } 1145