1 /* 2 * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #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 = qdf_mem_malloc(dbr_ring_cap->min_buf_size + 393 dbr_ring_cap->min_buf_align - 1); 394 if (!buf) { 395 direct_buf_rx_err("dir buf rx ring buf alloc failed"); 396 return QDF_STATUS_E_NOMEM; 397 } 398 dbr_buf_pool[idx].vaddr = buf; 399 buf_aligned = (void *)(uintptr_t)qdf_roundup( 400 (uint64_t)(uintptr_t)buf, DBR_RING_BASE_ALIGN); 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 static void *target_if_dbr_vaddr_lookup( 732 struct direct_buf_rx_module_param *mod_param, 733 qdf_dma_addr_t paddr, uint32_t cookie) 734 { 735 struct direct_buf_rx_buf_info *dbr_buf_pool; 736 737 dbr_buf_pool = mod_param->dbr_buf_pool; 738 739 if (dbr_buf_pool[cookie].paddr == paddr) { 740 return dbr_buf_pool[cookie].vaddr + 741 dbr_buf_pool[cookie].offset; 742 } 743 744 direct_buf_rx_err("Incorrect paddr found on cookie slot"); 745 return NULL; 746 } 747 748 static QDF_STATUS target_if_get_dbr_data(struct wlan_objmgr_pdev *pdev, 749 struct direct_buf_rx_module_param *mod_param, 750 struct direct_buf_rx_rsp *dbr_rsp, 751 struct direct_buf_rx_data *dbr_data, 752 uint8_t idx, uint32_t *cookie) 753 { 754 qdf_dma_addr_t paddr = 0; 755 uint32_t addr_hi; 756 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 757 struct direct_buf_rx_ring_cap *dbr_ring_cap; 758 struct wlan_objmgr_psoc *psoc; 759 760 psoc = wlan_pdev_get_psoc(pdev); 761 if (!psoc) { 762 direct_buf_rx_err("psoc is null"); 763 return QDF_STATUS_E_FAILURE; 764 } 765 766 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 767 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 768 769 if (dbr_psoc_obj == NULL) { 770 direct_buf_rx_err("dir buf rx psoc object is null"); 771 return QDF_STATUS_E_FAILURE; 772 } 773 774 dbr_ring_cap = mod_param->dbr_ring_cap; 775 addr_hi = (uint64_t)WMI_HOST_DBR_DATA_ADDR_HI_GET( 776 dbr_rsp->dbr_entries[idx].paddr_hi); 777 paddr = (qdf_dma_addr_t)((uint64_t)addr_hi << 32 | 778 dbr_rsp->dbr_entries[idx].paddr_lo); 779 *cookie = WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_GET( 780 dbr_rsp->dbr_entries[idx].paddr_hi); 781 direct_buf_rx_info("Cookie = %d", *cookie); 782 dbr_data->vaddr = target_if_dbr_vaddr_lookup(mod_param, paddr, *cookie); 783 direct_buf_rx_info("Vaddr look up = %x", dbr_data->vaddr); 784 dbr_data->dbr_len = dbr_rsp->dbr_entries[idx].len; 785 qdf_mem_unmap_nbytes_single(dbr_psoc_obj->osdev, (qdf_dma_addr_t)paddr, 786 QDF_DMA_FROM_DEVICE, 787 dbr_ring_cap->min_buf_size); 788 789 return QDF_STATUS_SUCCESS; 790 } 791 792 static int target_if_direct_buf_rx_rsp_event_handler(ol_scn_t scn, 793 uint8_t *data_buf, 794 uint32_t data_len) 795 { 796 int ret = 0; 797 uint8_t i = 0; 798 QDF_STATUS status; 799 uint32_t cookie = 0; 800 struct direct_buf_rx_rsp dbr_rsp = {0}; 801 struct direct_buf_rx_data dbr_data = {0}; 802 struct wlan_objmgr_psoc *psoc; 803 struct wlan_objmgr_pdev *pdev; 804 struct direct_buf_rx_buf_info *dbr_buf_pool; 805 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 806 struct direct_buf_rx_module_param *mod_param; 807 808 direct_buf_rx_enter(); 809 810 psoc = target_if_get_psoc_from_scn_hdl(scn); 811 if (!psoc) { 812 direct_buf_rx_err("psoc is null"); 813 return QDF_STATUS_E_FAILURE; 814 } 815 816 if (wmi_extract_dbr_buf_release_fixed(GET_WMI_HDL_FROM_PSOC(psoc), 817 data_buf, &dbr_rsp) != QDF_STATUS_SUCCESS) { 818 direct_buf_rx_err("unable to extract DBR rsp fixed param"); 819 return QDF_STATUS_E_FAILURE; 820 } 821 822 direct_buf_rx_info("Num buf release entry = %d", 823 dbr_rsp.num_buf_release_entry); 824 825 pdev = wlan_objmgr_get_pdev_by_id(psoc, dbr_rsp.pdev_id, 826 WLAN_DIRECT_BUF_RX_ID); 827 if (!pdev) { 828 direct_buf_rx_err("pdev is null"); 829 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 830 return QDF_STATUS_E_INVAL; 831 } 832 833 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 834 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 835 836 if (dbr_pdev_obj == NULL) { 837 direct_buf_rx_err("dir buf rx object is null"); 838 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 839 return QDF_STATUS_E_FAILURE; 840 } 841 842 mod_param = &(dbr_pdev_obj->dbr_mod_param[dbr_rsp.mod_id]); 843 844 if (!mod_param) { 845 direct_buf_rx_err("dir buf rx module param is null"); 846 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 847 return QDF_STATUS_E_FAILURE; 848 } 849 850 dbr_buf_pool = mod_param->dbr_buf_pool; 851 dbr_rsp.dbr_entries = qdf_mem_malloc(dbr_rsp.num_buf_release_entry * 852 sizeof(struct direct_buf_rx_entry)); 853 854 if (dbr_rsp.num_meta_data_entry > dbr_rsp.num_buf_release_entry) { 855 direct_buf_rx_err("More than expected number of metadata"); 856 wlan_objmgr_pdev_release_ref(pdev, 857 WLAN_DIRECT_BUF_RX_ID); 858 return QDF_STATUS_E_FAILURE; 859 } 860 861 for (i = 0; i < dbr_rsp.num_buf_release_entry; i++) { 862 if (wmi_extract_dbr_buf_release_entry( 863 GET_WMI_HDL_FROM_PSOC(psoc), data_buf, i, 864 &dbr_rsp.dbr_entries[i]) != QDF_STATUS_SUCCESS) { 865 direct_buf_rx_err("Unable to extract DBR buf entry %d", 866 i+1); 867 qdf_mem_free(dbr_rsp.dbr_entries); 868 wlan_objmgr_pdev_release_ref(pdev, 869 WLAN_DIRECT_BUF_RX_ID); 870 return QDF_STATUS_E_FAILURE; 871 } 872 status = target_if_get_dbr_data(pdev, mod_param, &dbr_rsp, 873 &dbr_data, i, &cookie); 874 875 if (QDF_IS_STATUS_ERROR(status)) { 876 direct_buf_rx_err("DBR data get failed"); 877 qdf_mem_free(dbr_rsp.dbr_entries); 878 wlan_objmgr_pdev_release_ref(pdev, 879 WLAN_DIRECT_BUF_RX_ID); 880 return QDF_STATUS_E_FAILURE; 881 } 882 883 dbr_data.meta_data_valid = false; 884 if (i < dbr_rsp.num_meta_data_entry) { 885 if (wmi_extract_dbr_buf_metadata( 886 GET_WMI_HDL_FROM_PSOC(psoc), data_buf, i, 887 &dbr_data.meta_data) == QDF_STATUS_SUCCESS) 888 dbr_data.meta_data_valid = true; 889 } 890 ret = mod_param->dbr_rsp_handler(pdev, &dbr_data); 891 status = target_if_dbr_replenish_ring(pdev, mod_param, 892 dbr_data.vaddr, cookie); 893 if (QDF_IS_STATUS_ERROR(status)) { 894 direct_buf_rx_err("dir buf rx ring replenish failed"); 895 qdf_mem_free(dbr_rsp.dbr_entries); 896 wlan_objmgr_pdev_release_ref(pdev, 897 WLAN_DIRECT_BUF_RX_ID); 898 return QDF_STATUS_E_FAILURE; 899 } 900 } 901 902 qdf_mem_free(dbr_rsp.dbr_entries); 903 wlan_objmgr_pdev_release_ref(pdev, WLAN_DIRECT_BUF_RX_ID); 904 905 return ret; 906 } 907 908 static QDF_STATUS target_if_dbr_empty_ring(struct wlan_objmgr_pdev *pdev, 909 struct direct_buf_rx_psoc_obj *dbr_psoc_obj, 910 struct direct_buf_rx_module_param *mod_param) 911 { 912 uint32_t idx; 913 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 914 struct direct_buf_rx_ring_cap *dbr_ring_cap; 915 struct direct_buf_rx_buf_info *dbr_buf_pool; 916 917 direct_buf_rx_enter(); 918 dbr_ring_cfg = mod_param->dbr_ring_cfg; 919 dbr_ring_cap = mod_param->dbr_ring_cap; 920 dbr_buf_pool = mod_param->dbr_buf_pool; 921 922 direct_buf_rx_info("dbr_ring_cfg %pK, dbr_ring_cap %pK dbr_buf_pool %pK", 923 dbr_ring_cfg, dbr_ring_cap, dbr_buf_pool); 924 925 for (idx = 0; idx < dbr_ring_cfg->num_ptr - 1; idx++) { 926 direct_buf_rx_info("dbr buf pool unmap and free for ptr %d", 927 idx); 928 qdf_mem_unmap_nbytes_single(dbr_psoc_obj->osdev, 929 (qdf_dma_addr_t)dbr_buf_pool[idx].paddr, 930 QDF_DMA_FROM_DEVICE, 931 dbr_ring_cap->min_buf_size); 932 qdf_mem_free(dbr_buf_pool[idx].vaddr); 933 } 934 935 return QDF_STATUS_SUCCESS; 936 } 937 938 static QDF_STATUS target_if_dbr_deinit_ring(struct wlan_objmgr_pdev *pdev, 939 struct direct_buf_rx_module_param *mod_param) 940 { 941 struct wlan_objmgr_psoc *psoc; 942 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 943 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 944 945 direct_buf_rx_enter(); 946 psoc = wlan_pdev_get_psoc(pdev); 947 if (!psoc) { 948 direct_buf_rx_err("psoc is null"); 949 return QDF_STATUS_E_FAILURE; 950 } 951 952 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 953 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 954 955 if (dbr_psoc_obj == NULL) { 956 direct_buf_rx_err("dir buf rx psoc object is null"); 957 return QDF_STATUS_E_FAILURE; 958 } 959 direct_buf_rx_info("dbr_psoc_obj %pK", dbr_psoc_obj); 960 961 dbr_ring_cfg = mod_param->dbr_ring_cfg; 962 if (dbr_ring_cfg) { 963 target_if_dbr_empty_ring(pdev, dbr_psoc_obj, mod_param); 964 hal_srng_cleanup(dbr_psoc_obj->hal_soc, dbr_ring_cfg->srng); 965 qdf_mem_free_consistent(dbr_psoc_obj->osdev, 966 dbr_psoc_obj->osdev->dev, 967 dbr_ring_cfg->ring_alloc_size, 968 dbr_ring_cfg->base_vaddr_unaligned, 969 (qdf_dma_addr_t)dbr_ring_cfg->base_paddr_unaligned, 0); 970 } 971 972 return QDF_STATUS_SUCCESS; 973 } 974 975 static QDF_STATUS target_if_dbr_deinit_srng( 976 struct wlan_objmgr_pdev *pdev, 977 struct direct_buf_rx_module_param *mod_param) 978 { 979 struct direct_buf_rx_buf_info *dbr_buf_pool; 980 981 direct_buf_rx_enter(); 982 dbr_buf_pool = mod_param->dbr_buf_pool; 983 direct_buf_rx_info("dbr buf pool %pK", dbr_buf_pool); 984 target_if_dbr_deinit_ring(pdev, mod_param); 985 qdf_mem_free(dbr_buf_pool); 986 mod_param->dbr_buf_pool = NULL; 987 988 return QDF_STATUS_SUCCESS; 989 } 990 991 QDF_STATUS target_if_deinit_dbr_ring(struct wlan_objmgr_pdev *pdev, 992 struct direct_buf_rx_pdev_obj *dbr_pdev_obj, 993 enum DBR_MODULE mod_id) 994 { 995 struct direct_buf_rx_module_param *mod_param; 996 997 direct_buf_rx_enter(); 998 mod_param = &(dbr_pdev_obj->dbr_mod_param[mod_id]); 999 1000 if (!mod_param) { 1001 direct_buf_rx_err("dir buf rx module param is null"); 1002 return QDF_STATUS_E_FAILURE; 1003 } 1004 direct_buf_rx_info("mod_param %pK", mod_param); 1005 direct_buf_rx_info("dbr_ring_cap %pK", mod_param->dbr_ring_cap); 1006 target_if_dbr_deinit_srng(pdev, mod_param); 1007 qdf_mem_free(mod_param->dbr_ring_cap); 1008 mod_param->dbr_ring_cap = NULL; 1009 qdf_mem_free(mod_param->dbr_ring_cfg); 1010 mod_param->dbr_ring_cfg = NULL; 1011 1012 return QDF_STATUS_SUCCESS; 1013 } 1014 1015 QDF_STATUS target_if_direct_buf_rx_register_events( 1016 struct wlan_objmgr_psoc *psoc) 1017 { 1018 int ret; 1019 1020 if (!psoc || !GET_WMI_HDL_FROM_PSOC(psoc)) { 1021 direct_buf_rx_err("psoc or psoc->tgt_if_handle is null"); 1022 return QDF_STATUS_E_INVAL; 1023 } 1024 1025 ret = wmi_unified_register_event_handler( 1026 get_wmi_unified_hdl_from_psoc(psoc), 1027 wmi_dma_buf_release_event_id, 1028 target_if_direct_buf_rx_rsp_event_handler, 1029 WMI_RX_UMAC_CTX); 1030 1031 if (ret) 1032 direct_buf_rx_info("event handler not supported", ret); 1033 1034 return QDF_STATUS_SUCCESS; 1035 } 1036 1037 QDF_STATUS target_if_direct_buf_rx_unregister_events( 1038 struct wlan_objmgr_psoc *psoc) 1039 { 1040 if (!psoc || !GET_WMI_HDL_FROM_PSOC(psoc)) { 1041 direct_buf_rx_err("psoc or psoc->tgt_if_handle is null"); 1042 return QDF_STATUS_E_INVAL; 1043 } 1044 1045 wmi_unified_unregister_event_handler( 1046 get_wmi_unified_hdl_from_psoc(psoc), 1047 wmi_dma_buf_release_event_id); 1048 1049 return QDF_STATUS_SUCCESS; 1050 } 1051 1052 QDF_STATUS target_if_direct_buf_rx_print_ring_stat( 1053 struct wlan_objmgr_pdev *pdev) 1054 { 1055 struct direct_buf_rx_psoc_obj *dbr_psoc_obj; 1056 struct direct_buf_rx_pdev_obj *dbr_pdev_obj; 1057 struct wlan_objmgr_psoc *psoc; 1058 void *srng, *hal_soc; 1059 uint32_t hp = 0, tp = 0; 1060 struct direct_buf_rx_module_param *mod_param; 1061 struct direct_buf_rx_ring_cfg *dbr_ring_cfg; 1062 uint8_t num_modules, mod_idx; 1063 1064 if (!pdev) { 1065 direct_buf_rx_err("pdev is null"); 1066 return QDF_STATUS_E_INVAL; 1067 } 1068 1069 psoc = wlan_pdev_get_psoc(pdev); 1070 dbr_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 1071 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 1072 dbr_psoc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 1073 WLAN_TARGET_IF_COMP_DIRECT_BUF_RX); 1074 hal_soc = dbr_psoc_obj->hal_soc; 1075 num_modules = dbr_pdev_obj->num_modules; 1076 direct_buf_rx_err("--------------------------------------------------"); 1077 direct_buf_rx_err("| Module ID | Module | Head Idx | Tail Idx |"); 1078 direct_buf_rx_err("--------------------------------------------------"); 1079 for (mod_idx = 0; mod_idx < num_modules; mod_idx++) { 1080 mod_param = &dbr_pdev_obj->dbr_mod_param[mod_idx]; 1081 dbr_ring_cfg = mod_param->dbr_ring_cfg; 1082 srng = dbr_ring_cfg->srng; 1083 hal_api_get_tphp(hal_soc, srng, &tp, &hp); 1084 direct_buf_rx_err("|%11d|%14s|%10x|%10x|", 1085 mod_idx, 1086 g_dbr_module_name[mod_idx].module_name_str, 1087 hp, tp); 1088 } 1089 direct_buf_rx_err("--------------------------------------------------"); 1090 1091 return QDF_STATUS_SUCCESS; 1092 } 1093