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