1 /* 2 * Copyright (c) 2016-2021 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 * DOC: Public APIs to perform operations on Global objects 20 */ 21 22 #include <wlan_objmgr_cmn.h> 23 #include <wlan_objmgr_global_obj.h> 24 #include <wlan_objmgr_psoc_obj.h> 25 #include <wlan_objmgr_pdev_obj.h> 26 #include <wlan_objmgr_vdev_obj.h> 27 #include <wlan_objmgr_peer_obj.h> 28 #include <wlan_objmgr_debug.h> 29 #include <qdf_mem.h> 30 #include <qdf_types.h> 31 #include <qdf_module.h> 32 #include "wlan_objmgr_global_obj_i.h" 33 #include "wlan_objmgr_psoc_obj_i.h" 34 #include "wlan_objmgr_pdev_obj_i.h" 35 #include "wlan_objmgr_vdev_obj_i.h" 36 #include <wlan_utility.h> 37 38 /** 39 ** APIs to Create/Delete Global object APIs 40 */ 41 static QDF_STATUS wlan_objmgr_psoc_object_status( 42 struct wlan_objmgr_psoc *psoc) 43 { 44 uint8_t id; 45 QDF_STATUS status = QDF_STATUS_SUCCESS; 46 47 wlan_psoc_obj_lock(psoc); 48 /* Iterate through all components to derive the object status */ 49 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 50 /* If component disabled, Ignore */ 51 if (psoc->obj_status[id] == QDF_STATUS_COMP_DISABLED) 52 continue; 53 /* If component operates in Async, status is Partially created, 54 * break 55 */ 56 else if (psoc->obj_status[id] == QDF_STATUS_COMP_ASYNC) { 57 if (!psoc->soc_comp_priv_obj[id]) { 58 status = QDF_STATUS_COMP_ASYNC; 59 break; 60 } 61 /* 62 * If component failed to allocate its object, treat it as 63 * failure, complete object need to be cleaned up 64 */ 65 } else if ((psoc->obj_status[id] == QDF_STATUS_E_NOMEM) || 66 (psoc->obj_status[id] == QDF_STATUS_E_FAILURE)) { 67 status = QDF_STATUS_E_FAILURE; 68 break; 69 } 70 } 71 wlan_psoc_obj_unlock(psoc); 72 73 return status; 74 } 75 76 static void wlan_objmgr_psoc_peer_list_init(struct wlan_peer_list *peer_list) 77 { 78 uint8_t i; 79 80 qdf_spinlock_create(&peer_list->peer_list_lock); 81 for (i = 0; i < WLAN_PEER_HASHSIZE; i++) 82 qdf_list_create(&peer_list->peer_hash[i], 83 WLAN_UMAC_PSOC_MAX_PEERS + 84 WLAN_MAX_PSOC_TEMP_PEERS); 85 } 86 87 static void wlan_objmgr_psoc_peer_list_deinit(struct wlan_peer_list *peer_list) 88 { 89 uint8_t i; 90 91 /* deinit the lock */ 92 qdf_spinlock_destroy(&peer_list->peer_list_lock); 93 for (i = 0; i < WLAN_PEER_HASHSIZE; i++) 94 qdf_list_destroy(&peer_list->peer_hash[i]); 95 } 96 97 static QDF_STATUS wlan_objmgr_psoc_obj_free(struct wlan_objmgr_psoc *psoc) 98 { 99 /* Detach PSOC from global object's psoc list */ 100 if (wlan_objmgr_psoc_object_detach(psoc) == QDF_STATUS_E_FAILURE) { 101 obj_mgr_err("PSOC object detach failed"); 102 return QDF_STATUS_E_FAILURE; 103 } 104 wlan_objmgr_psoc_peer_list_deinit(&psoc->soc_objmgr.peer_list); 105 106 qdf_spinlock_destroy(&psoc->psoc_lock); 107 qdf_mem_free(psoc); 108 109 return QDF_STATUS_SUCCESS; 110 } 111 112 struct wlan_objmgr_psoc *wlan_objmgr_psoc_obj_create(uint32_t phy_version, 113 WLAN_DEV_TYPE dev_type) 114 { 115 uint8_t id; 116 struct wlan_objmgr_psoc *psoc = NULL; 117 wlan_objmgr_psoc_create_handler handler; 118 wlan_objmgr_psoc_status_handler stat_handler; 119 struct wlan_objmgr_psoc_objmgr *objmgr; 120 QDF_STATUS obj_status; 121 void *arg; 122 123 psoc = qdf_mem_malloc(sizeof(*psoc)); 124 if (!psoc) 125 return NULL; 126 127 psoc->obj_state = WLAN_OBJ_STATE_ALLOCATED; 128 qdf_spinlock_create(&psoc->psoc_lock); 129 /* Initialize with default values */ 130 objmgr = &psoc->soc_objmgr; 131 objmgr->wlan_pdev_count = 0; 132 objmgr->wlan_vdev_count = 0; 133 objmgr->max_vdev_count = WLAN_UMAC_PSOC_MAX_VDEVS; 134 objmgr->wlan_peer_count = 0; 135 objmgr->temp_peer_count = 0; 136 objmgr->max_peer_count = WLAN_UMAC_PSOC_MAX_PEERS; 137 qdf_atomic_init(&objmgr->ref_cnt); 138 objmgr->print_cnt = 0; 139 /* set phy version, dev_type in psoc */ 140 wlan_psoc_set_nif_phy_version(psoc, phy_version); 141 wlan_psoc_set_dev_type(psoc, dev_type); 142 /* Initialize peer list */ 143 wlan_objmgr_psoc_peer_list_init(&objmgr->peer_list); 144 wlan_objmgr_psoc_get_ref(psoc, WLAN_OBJMGR_ID); 145 /* Invoke registered create handlers */ 146 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 147 handler = g_umac_glb_obj->psoc_create_handler[id]; 148 arg = g_umac_glb_obj->psoc_create_handler_arg[id]; 149 if (handler) 150 psoc->obj_status[id] = handler(psoc, arg); 151 else 152 psoc->obj_status[id] = QDF_STATUS_COMP_DISABLED; 153 } 154 /* Derive object status */ 155 obj_status = wlan_objmgr_psoc_object_status(psoc); 156 157 if (obj_status == QDF_STATUS_SUCCESS) { 158 /* Object status is SUCCESS, Object is created */ 159 psoc->obj_state = WLAN_OBJ_STATE_CREATED; 160 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 161 stat_handler = g_umac_glb_obj->psoc_status_handler[id]; 162 arg = g_umac_glb_obj->psoc_status_handler_arg[id]; 163 if (stat_handler) 164 stat_handler(psoc, arg, 165 QDF_STATUS_SUCCESS); 166 } 167 } else if (obj_status == QDF_STATUS_COMP_ASYNC) { 168 /* 169 * Few components operates in Asynchrous communction 170 * Object state partially created 171 */ 172 psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 173 } else if (obj_status == QDF_STATUS_E_FAILURE) { 174 /* Component object failed to be created, clean up the object */ 175 obj_mgr_err("PSOC component objects allocation failed"); 176 /* Clean up the psoc */ 177 wlan_objmgr_psoc_obj_delete(psoc); 178 return NULL; 179 } 180 181 if (wlan_objmgr_psoc_object_attach(psoc) != 182 QDF_STATUS_SUCCESS) { 183 obj_mgr_err("PSOC object attach failed"); 184 wlan_objmgr_psoc_obj_delete(psoc); 185 return NULL; 186 } 187 wlan_minidump_log(psoc, sizeof(*psoc), psoc, 188 WLAN_MD_OBJMGR_PSOC, "wlan_objmgr_psoc"); 189 obj_mgr_info("Created psoc %d", psoc->soc_objmgr.psoc_id); 190 191 return psoc; 192 } 193 qdf_export_symbol(wlan_objmgr_psoc_obj_create); 194 195 static QDF_STATUS wlan_objmgr_psoc_obj_destroy(struct wlan_objmgr_psoc *psoc) 196 { 197 uint8_t id; 198 wlan_objmgr_psoc_destroy_handler handler; 199 QDF_STATUS obj_status; 200 void *arg; 201 202 if (!psoc) { 203 obj_mgr_err("psoc is NULL"); 204 return QDF_STATUS_E_FAILURE; 205 } 206 wlan_objmgr_notify_destroy(psoc, WLAN_PSOC_OP); 207 208 wlan_print_psoc_info(psoc); 209 obj_mgr_info("Physically deleting psoc %d", psoc->soc_objmgr.psoc_id); 210 211 if (psoc->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) { 212 obj_mgr_err("PSOC object delete is not invoked obj_state:%d", 213 psoc->obj_state); 214 WLAN_OBJMGR_BUG(0); 215 } 216 217 wlan_minidump_remove(psoc, sizeof(*psoc), psoc, 218 WLAN_MD_OBJMGR_PSOC, "wlan_objmgr_psoc"); 219 220 /* Invoke registered create handlers */ 221 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 222 handler = g_umac_glb_obj->psoc_destroy_handler[id]; 223 arg = g_umac_glb_obj->psoc_destroy_handler_arg[id]; 224 if (handler && 225 (psoc->obj_status[id] == QDF_STATUS_SUCCESS || 226 psoc->obj_status[id] == QDF_STATUS_COMP_ASYNC)) 227 psoc->obj_status[id] = handler(psoc, arg); 228 else 229 psoc->obj_status[id] = QDF_STATUS_COMP_DISABLED; 230 } 231 /* Derive object status */ 232 obj_status = wlan_objmgr_psoc_object_status(psoc); 233 234 if (obj_status == QDF_STATUS_E_FAILURE) { 235 obj_mgr_err("PSOC component object free failed"); 236 /* Ideally should not happen 237 * This leads to memleak, BUG_ON to find which component 238 * delete notification failed and fix it. 239 */ 240 QDF_BUG(0); 241 return QDF_STATUS_E_FAILURE; 242 } 243 /* Deletion is in progress */ 244 if (obj_status == QDF_STATUS_COMP_ASYNC) { 245 psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_DELETED; 246 return QDF_STATUS_COMP_ASYNC; 247 } 248 249 /* Free psoc object */ 250 return wlan_objmgr_psoc_obj_free(psoc); 251 } 252 253 254 QDF_STATUS wlan_objmgr_psoc_obj_delete(struct wlan_objmgr_psoc *psoc) 255 { 256 uint8_t print_idx; 257 258 if (!psoc) { 259 obj_mgr_err("psoc is NULL"); 260 return QDF_STATUS_E_FAILURE; 261 } 262 263 obj_mgr_info("Logically deleting psoc %d", psoc->soc_objmgr.psoc_id); 264 265 print_idx = qdf_get_pidx(); 266 wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, 267 QDF_TRACE_LEVEL_DEBUG); 268 /* 269 * Update PSOC object state to LOGICALLY DELETED 270 * It prevents further access of this object 271 */ 272 wlan_psoc_obj_lock(psoc); 273 psoc->obj_state = WLAN_OBJ_STATE_LOGICALLY_DELETED; 274 wlan_psoc_obj_unlock(psoc); 275 wlan_objmgr_notify_log_delete(psoc, WLAN_PSOC_OP); 276 wlan_objmgr_psoc_release_ref(psoc, WLAN_OBJMGR_ID); 277 278 return QDF_STATUS_SUCCESS; 279 } 280 qdf_export_symbol(wlan_objmgr_psoc_obj_delete); 281 282 QDF_STATUS wlan_objmgr_psoc_component_obj_attach( 283 struct wlan_objmgr_psoc *psoc, 284 enum wlan_umac_comp_id id, 285 void *comp_priv_obj, 286 QDF_STATUS status) 287 { 288 wlan_objmgr_psoc_status_handler stat_handler; 289 void *arg = NULL; 290 QDF_STATUS obj_status; 291 uint8_t i; 292 293 /* component id is invalid */ 294 if (id >= WLAN_UMAC_MAX_COMPONENTS) 295 return QDF_STATUS_MAXCOMP_FAIL; 296 297 wlan_psoc_obj_lock(psoc); 298 /* If there is a valid entry, return failure */ 299 if (psoc->soc_comp_priv_obj[id]) { 300 wlan_psoc_obj_unlock(psoc); 301 return QDF_STATUS_E_FAILURE; 302 } 303 /* Save component's pointer and status */ 304 psoc->soc_comp_priv_obj[id] = comp_priv_obj; 305 psoc->obj_status[id] = status; 306 307 wlan_psoc_obj_unlock(psoc); 308 309 if (psoc->obj_state != WLAN_OBJ_STATE_PARTIALLY_CREATED) 310 return QDF_STATUS_SUCCESS; 311 /* If PSOC object status is partially created means, this API is 312 * invoked with differnt context, this block should be executed for 313 * async components only 314 */ 315 /* Derive status */ 316 obj_status = wlan_objmgr_psoc_object_status(psoc); 317 /* STATUS_SUCCESS means, object is CREATED */ 318 if (obj_status == QDF_STATUS_SUCCESS) 319 psoc->obj_state = WLAN_OBJ_STATE_CREATED; 320 /* update state as CREATION failed, caller has to delete the 321 * PSOC object 322 */ 323 else if (obj_status == QDF_STATUS_E_FAILURE) 324 psoc->obj_state = WLAN_OBJ_STATE_CREATION_FAILED; 325 326 /* Notify components about the CREATION success/failure */ 327 if ((obj_status == QDF_STATUS_SUCCESS) || 328 (obj_status == QDF_STATUS_E_FAILURE)) { 329 /* nofity object status */ 330 for (i = 0; i < WLAN_UMAC_MAX_COMPONENTS; i++) { 331 stat_handler = g_umac_glb_obj->psoc_status_handler[i]; 332 arg = g_umac_glb_obj->psoc_status_handler_arg[i]; 333 if (stat_handler) 334 stat_handler(psoc, arg, obj_status); 335 } 336 } 337 338 return QDF_STATUS_SUCCESS; 339 } 340 qdf_export_symbol(wlan_objmgr_psoc_component_obj_attach); 341 342 QDF_STATUS wlan_objmgr_psoc_component_obj_detach( 343 struct wlan_objmgr_psoc *psoc, 344 enum wlan_umac_comp_id id, 345 void *comp_priv_obj) 346 { 347 QDF_STATUS obj_status; 348 349 /* component id is invalid */ 350 if (id >= WLAN_UMAC_MAX_COMPONENTS) 351 return QDF_STATUS_MAXCOMP_FAIL; 352 353 wlan_psoc_obj_lock(psoc); 354 /* If there is a valid entry, return failure */ 355 if (psoc->soc_comp_priv_obj[id] != comp_priv_obj) { 356 psoc->obj_status[id] = QDF_STATUS_E_FAILURE; 357 wlan_psoc_obj_unlock(psoc); 358 return QDF_STATUS_E_FAILURE; 359 } 360 /* Reset pointers to NULL, update the status*/ 361 psoc->soc_comp_priv_obj[id] = NULL; 362 psoc->obj_status[id] = QDF_STATUS_SUCCESS; 363 wlan_psoc_obj_unlock(psoc); 364 365 /* If PSOC object status is partially created means, this API is 366 * invoked with differnt context, this block should be executed for 367 * async components only 368 */ 369 if ((psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) || 370 (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS)) { 371 /* Derive object status */ 372 obj_status = wlan_objmgr_psoc_object_status(psoc); 373 if (obj_status == QDF_STATUS_SUCCESS) { 374 /* Update the status as Deleted, if full object 375 * deletion is in progress 376 */ 377 if (psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) 378 psoc->obj_state = WLAN_OBJ_STATE_DELETED; 379 380 /* Move to creation state, since this component 381 * deletion alone requested 382 */ 383 if (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 384 psoc->obj_state = WLAN_OBJ_STATE_CREATED; 385 /* Object status is failure */ 386 } else if (obj_status == QDF_STATUS_E_FAILURE) { 387 /* Update the status as Deletion failed, if full object 388 * deletion is in progress 389 */ 390 if (psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) 391 psoc->obj_state = 392 WLAN_OBJ_STATE_DELETION_FAILED; 393 394 /* Move to creation state, since this component 395 * deletion alone requested (do not block other 396 * components) 397 */ 398 if (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 399 psoc->obj_state = WLAN_OBJ_STATE_CREATED; 400 } 401 402 /* Delete psoc object */ 403 if ((obj_status == QDF_STATUS_SUCCESS) && 404 (psoc->obj_state == WLAN_OBJ_STATE_DELETED)) { 405 /* Free psoc object */ 406 return wlan_objmgr_psoc_obj_free(psoc); 407 } 408 } 409 410 return QDF_STATUS_SUCCESS; 411 } 412 qdf_export_symbol(wlan_objmgr_psoc_component_obj_detach); 413 414 QDF_STATUS wlan_objmgr_iterate_obj_list( 415 struct wlan_objmgr_psoc *psoc, 416 enum wlan_objmgr_obj_type obj_type, 417 wlan_objmgr_op_handler handler, 418 void *arg, uint8_t lock_free_op, 419 wlan_objmgr_ref_dbgid dbg_id) 420 { 421 uint16_t obj_id; 422 uint8_t i; 423 struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; 424 struct wlan_peer_list *peer_list; 425 struct wlan_objmgr_pdev *pdev; 426 struct wlan_objmgr_vdev *vdev; 427 struct wlan_objmgr_peer *peer; 428 struct wlan_objmgr_peer *peer_next; 429 uint16_t max_vdev_cnt; 430 431 switch (obj_type) { 432 case WLAN_PDEV_OP: 433 /* Iterate through PDEV list, invoke handler for each pdev */ 434 for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { 435 pdev = wlan_objmgr_get_pdev_by_id(psoc, obj_id, dbg_id); 436 if (pdev) { 437 handler(psoc, (void *)pdev, arg); 438 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 439 } 440 } 441 break; 442 case WLAN_VDEV_OP: 443 /* Iterate through VDEV list, invoke handler for each vdev */ 444 max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); 445 for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { 446 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, 447 obj_id, dbg_id); 448 if (vdev) { 449 handler(psoc, vdev, arg); 450 wlan_objmgr_vdev_release_ref(vdev, dbg_id); 451 } 452 } 453 break; 454 case WLAN_PEER_OP: 455 /* Iterate through PEER list, invoke handler for each peer */ 456 peer_list = &objmgr->peer_list; 457 /* Since peer list has sublist, iterate through sublists */ 458 for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { 459 peer = wlan_psoc_peer_list_peek_active_head(peer_list, 460 i, dbg_id); 461 while (peer) { 462 handler(psoc, (void *)peer, arg); 463 /* Get next peer */ 464 peer_next = 465 wlan_peer_get_next_active_peer_of_psoc( 466 peer_list, i, peer, dbg_id); 467 wlan_objmgr_peer_release_ref(peer, dbg_id); 468 peer = peer_next; 469 } 470 } 471 break; 472 default: 473 break; 474 } 475 476 return QDF_STATUS_SUCCESS; 477 } 478 qdf_export_symbol(wlan_objmgr_iterate_obj_list); 479 480 QDF_STATUS wlan_objmgr_iterate_obj_list_all( 481 struct wlan_objmgr_psoc *psoc, 482 enum wlan_objmgr_obj_type obj_type, 483 wlan_objmgr_op_handler handler, 484 void *arg, uint8_t lock_free_op, 485 wlan_objmgr_ref_dbgid dbg_id) 486 { 487 uint16_t obj_id; 488 uint8_t i; 489 struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; 490 struct wlan_peer_list *peer_list; 491 struct wlan_objmgr_pdev *pdev; 492 struct wlan_objmgr_vdev *vdev; 493 struct wlan_objmgr_peer *peer; 494 struct wlan_objmgr_peer *peer_next; 495 uint16_t max_vdev_cnt; 496 497 /* If caller requests for lock free opeation, do not acquire, 498 * handler will handle the synchronization 499 */ 500 501 switch (obj_type) { 502 case WLAN_PDEV_OP: 503 /* Iterate through PDEV list, invoke handler for each pdev */ 504 for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { 505 pdev = wlan_objmgr_get_pdev_by_id_no_state(psoc, 506 obj_id, dbg_id); 507 if (pdev) { 508 handler(psoc, (void *)pdev, arg); 509 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 510 } 511 } 512 break; 513 case WLAN_VDEV_OP: 514 /* Iterate through VDEV list, invoke handler for each vdev */ 515 max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); 516 for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { 517 vdev = wlan_objmgr_get_vdev_by_id_from_psoc_no_state( 518 psoc, obj_id, dbg_id); 519 if (vdev) { 520 handler(psoc, vdev, arg); 521 wlan_objmgr_vdev_release_ref(vdev, dbg_id); 522 } 523 } 524 break; 525 case WLAN_PEER_OP: 526 /* Iterate through PEER list, invoke handler for each peer */ 527 peer_list = &objmgr->peer_list; 528 /* Since peer list has sublist, iterate through sublists */ 529 for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { 530 peer = wlan_psoc_peer_list_peek_head_ref(peer_list, i, 531 dbg_id); 532 533 while (peer) { 534 handler(psoc, (void *)peer, arg); 535 /* Get next peer */ 536 peer_next = wlan_peer_get_next_peer_of_psoc_ref( 537 peer_list, i, 538 peer, dbg_id); 539 wlan_objmgr_peer_release_ref(peer, dbg_id); 540 peer = peer_next; 541 } 542 } 543 break; 544 default: 545 break; 546 } 547 548 return QDF_STATUS_SUCCESS; 549 } 550 qdf_export_symbol(wlan_objmgr_iterate_obj_list_all); 551 552 /** 553 * wlan_objmgr_iterate_obj_list_all_noref() - iterate through all psoc objects 554 * without taking ref 555 * @psoc: PSOC object 556 * @obj_type: PDEV_OP/VDEV_OP/PEER_OP 557 * @handler: the handler will be called for each object of requested type 558 * the handler should be implemented to perform required operation 559 * @arg: agruments passed by caller 560 * 561 * API to be used for performing the operations on all PDEV/VDEV/PEER objects 562 * of psoc with lock protected 563 * 564 * Return: SUCCESS/FAILURE 565 */ 566 static QDF_STATUS wlan_objmgr_iterate_obj_list_all_noref( 567 struct wlan_objmgr_psoc *psoc, 568 enum wlan_objmgr_obj_type obj_type, 569 wlan_objmgr_op_handler handler, 570 void *arg) 571 { 572 uint16_t obj_id; 573 uint8_t i; 574 struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; 575 struct wlan_peer_list *peer_list; 576 qdf_list_t *obj_list; 577 struct wlan_objmgr_pdev *pdev; 578 struct wlan_objmgr_vdev *vdev; 579 struct wlan_objmgr_peer *peer; 580 struct wlan_objmgr_peer *peer_next; 581 uint16_t max_vdev_cnt; 582 583 /* If caller requests for lock free opeation, do not acquire, 584 * handler will handle the synchronization 585 */ 586 wlan_psoc_obj_lock(psoc); 587 588 switch (obj_type) { 589 case WLAN_PDEV_OP: 590 /* Iterate through PDEV list, invoke handler for each pdev */ 591 for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { 592 pdev = objmgr->wlan_pdev_list[obj_id]; 593 if (pdev) 594 handler(psoc, (void *)pdev, arg); 595 } 596 break; 597 case WLAN_VDEV_OP: 598 /* Iterate through VDEV list, invoke handler for each vdev */ 599 max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); 600 for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { 601 vdev = objmgr->wlan_vdev_list[obj_id]; 602 if (vdev) 603 handler(psoc, vdev, arg); 604 } 605 break; 606 case WLAN_PEER_OP: 607 /* Iterate through PEER list, invoke handler for each peer */ 608 peer_list = &objmgr->peer_list; 609 /* psoc lock should be taken before list lock */ 610 qdf_spin_lock_bh(&peer_list->peer_list_lock); 611 /* Since peer list has sublist, iterate through sublists */ 612 for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { 613 obj_list = &peer_list->peer_hash[i]; 614 peer = wlan_psoc_peer_list_peek_head(obj_list); 615 while (peer) { 616 /* Get next peer */ 617 peer_next = wlan_peer_get_next_peer_of_psoc( 618 obj_list, peer); 619 handler(psoc, (void *)peer, arg); 620 peer = peer_next; 621 } 622 } 623 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 624 break; 625 default: 626 break; 627 } 628 wlan_psoc_obj_unlock(psoc); 629 630 return QDF_STATUS_SUCCESS; 631 } 632 633 static void wlan_objmgr_psoc_peer_delete(struct wlan_objmgr_psoc *psoc, 634 void *obj, void *args) 635 { 636 struct wlan_objmgr_peer *peer = (struct wlan_objmgr_peer *)obj; 637 638 wlan_objmgr_peer_obj_delete(peer); 639 } 640 641 static void wlan_objmgr_psoc_vdev_delete(struct wlan_objmgr_psoc *psoc, 642 void *obj, void *args) 643 { 644 struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; 645 646 wlan_objmgr_vdev_obj_delete(vdev); 647 } 648 649 static void wlan_objmgr_psoc_pdev_delete(struct wlan_objmgr_psoc *psoc, 650 void *obj, void *args) 651 { 652 struct wlan_objmgr_pdev *pdev = (struct wlan_objmgr_pdev *)obj; 653 654 wlan_objmgr_pdev_obj_delete(pdev); 655 } 656 657 QDF_STATUS wlan_objmgr_free_all_objects_per_psoc( 658 struct wlan_objmgr_psoc *psoc) 659 { 660 /* Free all peers */ 661 wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, 662 wlan_objmgr_psoc_peer_delete, NULL, 1, 663 WLAN_OBJMGR_ID); 664 /* Free all vdevs */ 665 wlan_objmgr_iterate_obj_list(psoc, WLAN_VDEV_OP, 666 wlan_objmgr_psoc_vdev_delete, NULL, 1, 667 WLAN_OBJMGR_ID); 668 /* Free all PDEVs */ 669 wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP, 670 wlan_objmgr_psoc_pdev_delete, NULL, 1, 671 WLAN_OBJMGR_ID); 672 673 return QDF_STATUS_SUCCESS; 674 } 675 676 QDF_STATUS wlan_objmgr_trigger_psoc_comp_priv_object_creation( 677 struct wlan_objmgr_psoc *psoc, 678 enum wlan_umac_comp_id id) 679 { 680 wlan_objmgr_psoc_create_handler handler; 681 void *arg; 682 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 683 684 /* Component id is invalid */ 685 if (id >= WLAN_UMAC_MAX_COMPONENTS) 686 return QDF_STATUS_MAXCOMP_FAIL; 687 688 wlan_psoc_obj_lock(psoc); 689 /* If component object is already created, delete old 690 * component object, then invoke creation 691 */ 692 if (psoc->soc_comp_priv_obj[id]) { 693 wlan_psoc_obj_unlock(psoc); 694 return QDF_STATUS_E_FAILURE; 695 } 696 wlan_psoc_obj_unlock(psoc); 697 /* Invoke registered create handlers */ 698 handler = g_umac_glb_obj->psoc_create_handler[id]; 699 arg = g_umac_glb_obj->psoc_create_handler_arg[id]; 700 if (handler) 701 psoc->obj_status[id] = handler(psoc, arg); 702 else 703 return QDF_STATUS_E_FAILURE; 704 705 /* If object status is created, then only handle this object status */ 706 if (psoc->obj_state == WLAN_OBJ_STATE_CREATED) { 707 /* Derive object status */ 708 obj_status = wlan_objmgr_psoc_object_status(psoc); 709 /* Move PSOC object state to Partially created state */ 710 if (obj_status == QDF_STATUS_COMP_ASYNC) { 711 /*TODO atomic */ 712 psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 713 } 714 } 715 716 return obj_status; 717 } 718 719 QDF_STATUS wlan_objmgr_trigger_psoc_comp_priv_object_deletion( 720 struct wlan_objmgr_psoc *psoc, 721 enum wlan_umac_comp_id id) 722 { 723 wlan_objmgr_psoc_destroy_handler handler; 724 void *arg; 725 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 726 727 /* component id is invalid */ 728 if (id >= WLAN_UMAC_MAX_COMPONENTS) 729 return QDF_STATUS_MAXCOMP_FAIL; 730 731 wlan_psoc_obj_lock(psoc); 732 /* Component object was never created, invalid operation */ 733 if (!psoc->soc_comp_priv_obj[id]) { 734 wlan_psoc_obj_unlock(psoc); 735 return QDF_STATUS_E_FAILURE; 736 } 737 wlan_psoc_obj_unlock(psoc); 738 /* Invoke registered create handlers */ 739 handler = g_umac_glb_obj->psoc_destroy_handler[id]; 740 arg = g_umac_glb_obj->psoc_destroy_handler_arg[id]; 741 if (handler) 742 psoc->obj_status[id] = handler(psoc, arg); 743 else 744 return QDF_STATUS_E_FAILURE; 745 746 /* If object status is created, then only handle this object status */ 747 if (psoc->obj_state == WLAN_OBJ_STATE_CREATED) { 748 obj_status = wlan_objmgr_psoc_object_status(psoc); 749 /* move object state to DEL progress */ 750 if (obj_status == QDF_STATUS_COMP_ASYNC) 751 psoc->obj_state = WLAN_OBJ_STATE_COMP_DEL_PROGRESS; 752 } 753 754 return obj_status; 755 } 756 757 /* Util APIs */ 758 759 QDF_STATUS wlan_objmgr_psoc_pdev_attach(struct wlan_objmgr_psoc *psoc, 760 struct wlan_objmgr_pdev *pdev) 761 { 762 struct wlan_objmgr_psoc_objmgr *objmgr; 763 uint8_t id = 0; 764 QDF_STATUS status; 765 766 wlan_psoc_obj_lock(psoc); 767 objmgr = &psoc->soc_objmgr; 768 /* 769 * Derive pdev id from pdev map 770 * First free pdev id is assigned 771 */ 772 while ((id < WLAN_UMAC_MAX_PDEVS) && 773 (objmgr->wlan_pdev_id_map & (1<<id))) 774 id++; 775 776 if (id == WLAN_UMAC_MAX_PDEVS) { 777 status = QDF_STATUS_E_FAILURE; 778 } else { 779 /* Update the map for reserving the id */ 780 objmgr->wlan_pdev_id_map |= (1<<id); 781 /* store pdev in pdev list */ 782 objmgr->wlan_pdev_list[id] = pdev; 783 /* Increment pdev count */ 784 objmgr->wlan_pdev_count++; 785 /* save pdev id */ 786 pdev->pdev_objmgr.wlan_pdev_id = id; 787 status = QDF_STATUS_SUCCESS; 788 /* Inrement psoc ref count to block its free before pdev */ 789 wlan_objmgr_psoc_get_ref(psoc, WLAN_OBJMGR_ID); 790 } 791 wlan_psoc_obj_unlock(psoc); 792 793 return status; 794 } 795 796 QDF_STATUS wlan_objmgr_psoc_pdev_detach(struct wlan_objmgr_psoc *psoc, 797 struct wlan_objmgr_pdev *pdev) 798 { 799 struct wlan_objmgr_psoc_objmgr *objmgr; 800 uint8_t id; 801 802 id = pdev->pdev_objmgr.wlan_pdev_id; 803 /* If id is invalid, return */ 804 if (id >= WLAN_UMAC_MAX_PDEVS) 805 return QDF_STATUS_E_FAILURE; 806 807 wlan_psoc_obj_lock(psoc); 808 objmgr = &psoc->soc_objmgr; 809 /* Free pdev id slot */ 810 objmgr->wlan_pdev_id_map &= ~(1<<id); 811 objmgr->wlan_pdev_list[id] = NULL; 812 objmgr->wlan_pdev_count--; 813 pdev->pdev_objmgr.wlan_pdev_id = 0xff; 814 wlan_psoc_obj_unlock(psoc); 815 /* Release ref count of psoc */ 816 wlan_objmgr_psoc_release_ref(psoc, WLAN_OBJMGR_ID); 817 818 return QDF_STATUS_SUCCESS; 819 } 820 821 struct wlan_objmgr_pdev *wlan_objmgr_get_pdev_by_id( 822 struct wlan_objmgr_psoc *psoc, uint8_t id, 823 wlan_objmgr_ref_dbgid dbg_id) 824 { 825 struct wlan_objmgr_psoc_objmgr *objmgr; 826 struct wlan_objmgr_pdev *pdev = NULL; 827 828 /* If id is invalid, return */ 829 if (id >= WLAN_UMAC_MAX_PDEVS) 830 return NULL; 831 832 wlan_psoc_obj_lock(psoc); 833 objmgr = &psoc->soc_objmgr; 834 /* get pdev from pdev list */ 835 pdev = objmgr->wlan_pdev_list[id]; 836 /* Do not return object, if it is not CREATED state */ 837 if (pdev) { 838 if (wlan_objmgr_pdev_try_get_ref(pdev, dbg_id) != 839 QDF_STATUS_SUCCESS) 840 pdev = NULL; 841 } 842 843 wlan_psoc_obj_unlock(psoc); 844 845 return pdev; 846 } 847 qdf_export_symbol(wlan_objmgr_get_pdev_by_id); 848 849 struct wlan_objmgr_pdev *wlan_objmgr_get_pdev_by_id_no_state( 850 struct wlan_objmgr_psoc *psoc, uint8_t id, 851 wlan_objmgr_ref_dbgid dbg_id) 852 { 853 struct wlan_objmgr_psoc_objmgr *objmgr; 854 struct wlan_objmgr_pdev *pdev = NULL; 855 856 /* If id is invalid, return */ 857 if (id >= WLAN_UMAC_MAX_PDEVS) 858 return NULL; 859 860 wlan_psoc_obj_lock(psoc); 861 objmgr = &psoc->soc_objmgr; 862 /* get pdev from pdev list */ 863 pdev = objmgr->wlan_pdev_list[id]; 864 /* Do not return object, if it is not CREATED state */ 865 if (pdev) 866 wlan_objmgr_pdev_get_ref(pdev, dbg_id); 867 868 wlan_psoc_obj_unlock(psoc); 869 870 return pdev; 871 } 872 QDF_STATUS wlan_objmgr_psoc_vdev_attach(struct wlan_objmgr_psoc *psoc, 873 struct wlan_objmgr_vdev *vdev) 874 { 875 struct wlan_objmgr_psoc_objmgr *objmgr; 876 uint8_t id = 0; 877 QDF_STATUS status; 878 879 wlan_psoc_obj_lock(psoc); 880 objmgr = &psoc->soc_objmgr; 881 /* Find first free vdev id */ 882 while ((id < objmgr->max_vdev_count)) { 883 if (qdf_test_bit(id, objmgr->wlan_vdev_id_map)) { 884 id++; 885 continue; 886 } 887 break; 888 } 889 890 /* If no free slot, return failure */ 891 if (id < objmgr->max_vdev_count) { 892 /* set free vdev id index */ 893 qdf_set_bit(id, objmgr->wlan_vdev_id_map); 894 /* store vdev pointer in vdev list */ 895 objmgr->wlan_vdev_list[id] = vdev; 896 /* increment vdev counter */ 897 objmgr->wlan_vdev_count++; 898 /* save vdev id */ 899 vdev->vdev_objmgr.vdev_id = id; 900 status = QDF_STATUS_SUCCESS; 901 } else { 902 status = QDF_STATUS_E_FAILURE; 903 } 904 wlan_psoc_obj_unlock(psoc); 905 906 return status; 907 } 908 909 QDF_STATUS wlan_objmgr_psoc_vdev_detach(struct wlan_objmgr_psoc *psoc, 910 struct wlan_objmgr_vdev *vdev) 911 { 912 struct wlan_objmgr_psoc_objmgr *objmgr; 913 uint8_t id = 0; 914 915 id = vdev->vdev_objmgr.vdev_id; 916 /* Invalid vdev id */ 917 if (id >= wlan_psoc_get_max_vdev_count(psoc)) 918 return QDF_STATUS_E_FAILURE; 919 920 wlan_psoc_obj_lock(psoc); 921 objmgr = &psoc->soc_objmgr; 922 /* unset bit, to free the slot */ 923 qdf_clear_bit(id, objmgr->wlan_vdev_id_map); 924 /* reset VDEV pointer to NULL in VDEV list array */ 925 objmgr->wlan_vdev_list[id] = NULL; 926 /* decrement vdev count */ 927 objmgr->wlan_vdev_count--; 928 vdev->vdev_objmgr.vdev_id = 0xff; 929 wlan_psoc_obj_unlock(psoc); 930 931 return QDF_STATUS_SUCCESS; 932 } 933 934 #ifdef WLAN_OBJMGR_REF_ID_TRACE 935 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_debug( 936 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 937 wlan_objmgr_ref_dbgid dbg_id, 938 const char *func, int line) 939 { 940 struct wlan_objmgr_vdev *vdev; 941 942 /* if PSOC is NULL, return */ 943 if (!psoc) 944 return NULL; 945 /* vdev id is invalid */ 946 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 947 return NULL; 948 949 wlan_psoc_obj_lock(psoc); 950 /* retrieve vdev pointer from vdev list */ 951 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 952 if (vdev) { 953 if (wlan_objmgr_vdev_try_get_ref_debug(vdev, dbg_id, 954 func, line) != 955 QDF_STATUS_SUCCESS) 956 vdev = NULL; 957 } 958 wlan_psoc_obj_unlock(psoc); 959 960 return vdev; 961 } 962 963 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_debug); 964 #else 965 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc( 966 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 967 wlan_objmgr_ref_dbgid dbg_id) 968 { 969 struct wlan_objmgr_vdev *vdev; 970 971 /* if PSOC is NULL, return */ 972 if (!psoc) 973 return NULL; 974 /* vdev id is invalid */ 975 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 976 return NULL; 977 978 wlan_psoc_obj_lock(psoc); 979 /* retrieve vdev pointer from vdev list */ 980 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 981 if (vdev) { 982 if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) != 983 QDF_STATUS_SUCCESS) 984 vdev = NULL; 985 } 986 wlan_psoc_obj_unlock(psoc); 987 988 return vdev; 989 } 990 991 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc); 992 #endif 993 994 #ifdef WLAN_OBJMGR_REF_ID_TRACE 995 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_no_state_debug( 996 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 997 wlan_objmgr_ref_dbgid dbg_id, 998 const char *func, int line) 999 { 1000 struct wlan_objmgr_vdev *vdev; 1001 1002 /* if PSOC is NULL, return */ 1003 if (!psoc) 1004 return NULL; 1005 /* vdev id is invalid */ 1006 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 1007 return NULL; 1008 1009 wlan_psoc_obj_lock(psoc); 1010 /* retrieve vdev pointer from vdev list */ 1011 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 1012 if (vdev) 1013 wlan_objmgr_vdev_get_ref_debug(vdev, dbg_id, func, line); 1014 1015 wlan_psoc_obj_unlock(psoc); 1016 1017 return vdev; 1018 } 1019 1020 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_no_state_debug); 1021 #else 1022 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_no_state( 1023 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 1024 wlan_objmgr_ref_dbgid dbg_id) 1025 { 1026 struct wlan_objmgr_vdev *vdev; 1027 1028 /* if PSOC is NULL, return */ 1029 if (!psoc) 1030 return NULL; 1031 /* vdev id is invalid */ 1032 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 1033 return NULL; 1034 1035 wlan_psoc_obj_lock(psoc); 1036 /* retrieve vdev pointer from vdev list */ 1037 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 1038 if (vdev) 1039 wlan_objmgr_vdev_get_ref(vdev, dbg_id); 1040 1041 wlan_psoc_obj_unlock(psoc); 1042 1043 return vdev; 1044 } 1045 1046 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_no_state); 1047 #endif 1048 1049 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1050 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_not_log_del_debug( 1051 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 1052 wlan_objmgr_ref_dbgid dbg_id, 1053 const char *func, int line) 1054 { 1055 struct wlan_objmgr_vdev *vdev; 1056 1057 /* if PSOC is NULL, return */ 1058 if (!psoc) 1059 return NULL; 1060 /* vdev id is invalid */ 1061 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 1062 return NULL; 1063 1064 wlan_psoc_obj_lock(psoc); 1065 /* retrieve vdev pointer from vdev list */ 1066 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 1067 if (vdev && vdev->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) 1068 wlan_objmgr_vdev_get_ref_debug(vdev, dbg_id, func, line); 1069 else 1070 vdev = NULL; 1071 wlan_psoc_obj_unlock(psoc); 1072 1073 return vdev; 1074 } 1075 1076 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_not_log_del_debug); 1077 #else 1078 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_not_log_del( 1079 struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 1080 wlan_objmgr_ref_dbgid dbg_id) 1081 { 1082 struct wlan_objmgr_vdev *vdev; 1083 1084 /* if PSOC is NULL, return */ 1085 if (!psoc) 1086 return NULL; 1087 /* vdev id is invalid */ 1088 if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) 1089 return NULL; 1090 1091 wlan_psoc_obj_lock(psoc); 1092 /* retrieve vdev pointer from vdev list */ 1093 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; 1094 1095 if (vdev && vdev->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) 1096 wlan_objmgr_vdev_get_ref(vdev, dbg_id); 1097 else 1098 vdev = NULL; 1099 wlan_psoc_obj_unlock(psoc); 1100 1101 return vdev; 1102 } 1103 1104 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_not_log_del); 1105 #endif 1106 1107 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1108 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_opmode_from_psoc_debug( 1109 struct wlan_objmgr_psoc *psoc, 1110 enum QDF_OPMODE opmode, 1111 wlan_objmgr_ref_dbgid dbg_id, 1112 const char *func, int line) 1113 { 1114 struct wlan_objmgr_vdev *vdev = NULL; 1115 int vdev_cnt = 0; 1116 uint16_t max_vdev_cnt; 1117 1118 /* if PSOC is NULL, return */ 1119 if (!psoc) 1120 return NULL; 1121 1122 wlan_psoc_obj_lock(psoc); 1123 1124 max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); 1125 /* retrieve vdev pointer from vdev list */ 1126 while (vdev_cnt < max_vdev_cnt) { 1127 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_cnt]; 1128 vdev_cnt++; 1129 if (!vdev) 1130 continue; 1131 wlan_vdev_obj_lock(vdev); 1132 if (vdev->vdev_mlme.vdev_opmode == opmode) { 1133 wlan_vdev_obj_unlock(vdev); 1134 if (wlan_objmgr_vdev_try_get_ref_debug(vdev, dbg_id, 1135 func, line) != 1136 QDF_STATUS_SUCCESS) { 1137 vdev = NULL; 1138 continue; 1139 } 1140 break; 1141 } 1142 wlan_vdev_obj_unlock(vdev); 1143 vdev = NULL; 1144 } 1145 wlan_psoc_obj_unlock(psoc); 1146 1147 return vdev; 1148 } 1149 #else 1150 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_opmode_from_psoc( 1151 struct wlan_objmgr_psoc *psoc, 1152 enum QDF_OPMODE opmode, 1153 wlan_objmgr_ref_dbgid dbg_id) 1154 { 1155 struct wlan_objmgr_vdev *vdev = NULL; 1156 int vdev_cnt = 0; 1157 uint16_t max_vdev_cnt; 1158 1159 /* if PSOC is NULL, return */ 1160 if (!psoc) 1161 return NULL; 1162 1163 wlan_psoc_obj_lock(psoc); 1164 1165 max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); 1166 /* retrieve vdev pointer from vdev list */ 1167 while (vdev_cnt < max_vdev_cnt) { 1168 vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_cnt]; 1169 vdev_cnt++; 1170 if (!vdev) 1171 continue; 1172 wlan_vdev_obj_lock(vdev); 1173 if (vdev->vdev_mlme.vdev_opmode == opmode) { 1174 wlan_vdev_obj_unlock(vdev); 1175 if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) != 1176 QDF_STATUS_SUCCESS) { 1177 vdev = NULL; 1178 continue; 1179 } 1180 break; 1181 } 1182 wlan_vdev_obj_unlock(vdev); 1183 vdev = NULL; 1184 } 1185 wlan_psoc_obj_unlock(psoc); 1186 1187 return vdev; 1188 } 1189 #endif 1190 1191 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1192 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_psoc_debug( 1193 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 1194 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id, 1195 const char *func, int line) 1196 { 1197 struct wlan_objmgr_vdev *vdev; 1198 struct wlan_objmgr_pdev *pdev; 1199 1200 /* if PSOC is NULL, return */ 1201 if (!psoc) 1202 return NULL; 1203 1204 if (!macaddr) 1205 return NULL; 1206 1207 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); 1208 if (!pdev) { 1209 obj_mgr_err("pdev is null"); 1210 return NULL; 1211 } 1212 vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev_debug(pdev, macaddr, 1213 dbg_id, 1214 func, line); 1215 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 1216 1217 return vdev; 1218 } 1219 1220 qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc_debug); 1221 #else 1222 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_psoc( 1223 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 1224 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) 1225 { 1226 struct wlan_objmgr_vdev *vdev; 1227 struct wlan_objmgr_pdev *pdev; 1228 1229 /* if PSOC is NULL, return */ 1230 if (!psoc) 1231 return NULL; 1232 1233 if (!macaddr) 1234 return NULL; 1235 1236 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); 1237 if (!pdev) { 1238 obj_mgr_err("pdev is null"); 1239 return NULL; 1240 } 1241 vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev(pdev, macaddr, dbg_id); 1242 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 1243 1244 return vdev; 1245 } 1246 1247 qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc); 1248 #endif 1249 1250 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1251 struct wlan_objmgr_vdev 1252 *wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state_debug( 1253 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 1254 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id, 1255 const char *func, int line) 1256 { 1257 struct wlan_objmgr_vdev *vdev; 1258 struct wlan_objmgr_pdev *pdev; 1259 1260 /* if PSOC is NULL, return */ 1261 if (!psoc) 1262 return NULL; 1263 1264 if (!macaddr) 1265 return NULL; 1266 1267 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); 1268 if (!pdev) { 1269 obj_mgr_err("pdev is null"); 1270 return NULL; 1271 } 1272 vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev_no_state_debug(pdev, 1273 macaddr, 1274 dbg_id, 1275 func, 1276 line); 1277 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 1278 1279 return vdev; 1280 } 1281 1282 qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state_debug); 1283 #else 1284 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state( 1285 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 1286 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) 1287 { 1288 struct wlan_objmgr_vdev *vdev; 1289 struct wlan_objmgr_pdev *pdev; 1290 1291 /* if PSOC is NULL, return */ 1292 if (!psoc) 1293 return NULL; 1294 1295 if (!macaddr) 1296 return NULL; 1297 1298 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); 1299 if (!pdev) { 1300 obj_mgr_err("pdev is null"); 1301 return NULL; 1302 } 1303 vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev_no_state(pdev, macaddr, dbg_id); 1304 wlan_objmgr_pdev_release_ref(pdev, dbg_id); 1305 1306 return vdev; 1307 } 1308 1309 qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state); 1310 #endif 1311 1312 static void wlan_obj_psoc_peerlist_add_tail(qdf_list_t *obj_list, 1313 struct wlan_objmgr_peer *obj) 1314 { 1315 qdf_list_insert_back(obj_list, &obj->psoc_peer); 1316 } 1317 1318 static QDF_STATUS wlan_obj_psoc_peerlist_remove_peer( 1319 qdf_list_t *obj_list, 1320 struct wlan_objmgr_peer *peer) 1321 { 1322 qdf_list_node_t *psoc_node = NULL; 1323 1324 if (!peer) 1325 return QDF_STATUS_E_FAILURE; 1326 /* get vdev list node element */ 1327 psoc_node = &peer->psoc_peer; 1328 /* list is empty, return failure */ 1329 if (qdf_list_remove_node(obj_list, psoc_node) != QDF_STATUS_SUCCESS) 1330 return QDF_STATUS_E_FAILURE; 1331 1332 return QDF_STATUS_SUCCESS; 1333 } 1334 1335 static QDF_STATUS wlan_peer_bssid_match(struct wlan_objmgr_peer *peer, 1336 uint8_t *bssid) 1337 { 1338 struct wlan_objmgr_vdev *vdev = wlan_peer_get_vdev(peer); 1339 uint8_t *peer_bssid = wlan_vdev_mlme_get_macaddr(vdev); 1340 1341 if (WLAN_ADDR_EQ(peer_bssid, bssid) == QDF_STATUS_SUCCESS) 1342 return QDF_STATUS_SUCCESS; 1343 else 1344 return QDF_STATUS_E_FAILURE; 1345 } 1346 1347 /** 1348 * wlan_obj_psoc_peerlist_get_peer_by_pdev_id() - get peer from 1349 * psoc peer list 1350 * @psoc: PSOC object 1351 * @macaddr: MAC address 1352 * #pdev_id: Pdev id 1353 * 1354 * API to finds peer object pointer by MAC addr and pdev id from hash list 1355 * 1356 * Return: peer pointer 1357 * NULL on FAILURE 1358 */ 1359 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1360 static struct wlan_objmgr_peer 1361 *wlan_obj_psoc_peerlist_get_peer_by_pdev_id_debug( 1362 qdf_list_t *obj_list, uint8_t *macaddr, 1363 uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id, 1364 const char *func, int line) 1365 { 1366 struct wlan_objmgr_peer *peer; 1367 struct wlan_objmgr_peer *peer_temp; 1368 1369 /* Iterate through hash list to get the peer */ 1370 peer = wlan_psoc_peer_list_peek_head(obj_list); 1371 while (peer) { 1372 /* For peer, macaddr is key */ 1373 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1374 == QDF_STATUS_SUCCESS) && 1375 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1376 if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id, 1377 func, line) == 1378 QDF_STATUS_SUCCESS) { 1379 return peer; 1380 } 1381 } 1382 /* Move to next peer */ 1383 peer_temp = peer; 1384 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1385 } 1386 1387 /* Not found, return NULL */ 1388 return NULL; 1389 } 1390 #else 1391 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_by_pdev_id( 1392 qdf_list_t *obj_list, uint8_t *macaddr, 1393 uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id) 1394 { 1395 struct wlan_objmgr_peer *peer; 1396 struct wlan_objmgr_peer *peer_temp; 1397 1398 /* Iterate through hash list to get the peer */ 1399 peer = wlan_psoc_peer_list_peek_head(obj_list); 1400 while (peer) { 1401 /* For peer, macaddr is key */ 1402 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1403 == QDF_STATUS_SUCCESS) && 1404 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1405 if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == 1406 QDF_STATUS_SUCCESS) { 1407 return peer; 1408 } 1409 } 1410 /* Move to next peer */ 1411 peer_temp = peer; 1412 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1413 } 1414 1415 /* Not found, return NULL */ 1416 return NULL; 1417 } 1418 #endif 1419 1420 /** 1421 * wlan_obj_psoc_peerlist_get_peer() - get peer from psoc peer list 1422 * @psoc: PSOC object 1423 * @macaddr: MAC address 1424 * 1425 * API to finds peer object pointer by MAC addr from hash list 1426 * 1427 * Return: peer pointer 1428 * NULL on FAILURE 1429 */ 1430 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1431 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_debug( 1432 qdf_list_t *obj_list, uint8_t *macaddr, 1433 wlan_objmgr_ref_dbgid dbg_id, 1434 const char *func, int line) 1435 { 1436 struct wlan_objmgr_peer *peer; 1437 struct wlan_objmgr_peer *peer_temp; 1438 1439 /* Iterate through hash list to get the peer */ 1440 peer = wlan_psoc_peer_list_peek_head(obj_list); 1441 while (peer) { 1442 /* For peer, macaddr is key */ 1443 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1444 == QDF_STATUS_SUCCESS) { 1445 if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id, 1446 func, line) == 1447 QDF_STATUS_SUCCESS) { 1448 return peer; 1449 } 1450 } 1451 /* Move to next peer */ 1452 peer_temp = peer; 1453 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1454 } 1455 1456 /* Not found, return NULL */ 1457 return NULL; 1458 } 1459 #else 1460 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer( 1461 qdf_list_t *obj_list, uint8_t *macaddr, 1462 wlan_objmgr_ref_dbgid dbg_id) 1463 { 1464 struct wlan_objmgr_peer *peer; 1465 struct wlan_objmgr_peer *peer_temp; 1466 1467 /* Iterate through hash list to get the peer */ 1468 peer = wlan_psoc_peer_list_peek_head(obj_list); 1469 while (peer) { 1470 /* For peer, macaddr is key */ 1471 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1472 == QDF_STATUS_SUCCESS) { 1473 if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == 1474 QDF_STATUS_SUCCESS) { 1475 return peer; 1476 } 1477 } 1478 /* Move to next peer */ 1479 peer_temp = peer; 1480 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1481 } 1482 1483 /* Not found, return NULL */ 1484 return NULL; 1485 } 1486 #endif 1487 1488 /** 1489 * wlan_obj_psoc_peerlist_get_peer_logically_deleted() - get peer 1490 * from psoc peer list 1491 * @psoc: PSOC object 1492 * @macaddr: MAC address 1493 * 1494 * API to finds peer object pointer of logically deleted peer 1495 * 1496 * Return: peer pointer 1497 * NULL on FAILURE 1498 */ 1499 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1500 static struct wlan_objmgr_peer * 1501 wlan_obj_psoc_peerlist_get_peer_logically_deleted_debug( 1502 qdf_list_t *obj_list, uint8_t *macaddr, 1503 wlan_objmgr_ref_dbgid dbg_id, 1504 const char *func, int line) 1505 { 1506 struct wlan_objmgr_peer *peer; 1507 struct wlan_objmgr_peer *peer_temp; 1508 1509 /* Iterate through hash list to get the peer */ 1510 peer = wlan_psoc_peer_list_peek_head(obj_list); 1511 while (peer) { 1512 /* For peer, macaddr is key */ 1513 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1514 == QDF_STATUS_SUCCESS) { 1515 /* Return peer in logically deleted state */ 1516 if (peer->obj_state == 1517 WLAN_OBJ_STATE_LOGICALLY_DELETED) { 1518 wlan_objmgr_peer_get_ref_debug(peer, dbg_id, 1519 func, line); 1520 1521 return peer; 1522 } 1523 1524 } 1525 /* Move to next peer */ 1526 peer_temp = peer; 1527 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1528 } 1529 1530 /* Not found, return NULL */ 1531 return NULL; 1532 } 1533 #else 1534 static struct wlan_objmgr_peer * 1535 wlan_obj_psoc_peerlist_get_peer_logically_deleted( 1536 qdf_list_t *obj_list, uint8_t *macaddr, 1537 wlan_objmgr_ref_dbgid dbg_id) 1538 { 1539 struct wlan_objmgr_peer *peer; 1540 struct wlan_objmgr_peer *peer_temp; 1541 1542 /* Iterate through hash list to get the peer */ 1543 peer = wlan_psoc_peer_list_peek_head(obj_list); 1544 while (peer) { 1545 /* For peer, macaddr is key */ 1546 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1547 == QDF_STATUS_SUCCESS) { 1548 /* Return peer in logically deleted state */ 1549 if (peer->obj_state == 1550 WLAN_OBJ_STATE_LOGICALLY_DELETED) { 1551 wlan_objmgr_peer_get_ref(peer, dbg_id); 1552 1553 return peer; 1554 } 1555 } 1556 /* Move to next peer */ 1557 peer_temp = peer; 1558 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1559 } 1560 1561 /* Not found, return NULL */ 1562 return NULL; 1563 } 1564 #endif 1565 1566 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1567 static struct wlan_objmgr_peer 1568 *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state_debug( 1569 qdf_list_t *obj_list, uint8_t *macaddr, 1570 uint8_t *bssid, 1571 uint8_t pdev_id, 1572 wlan_objmgr_ref_dbgid dbg_id, 1573 const char *func, int line) 1574 { 1575 struct wlan_objmgr_peer *peer; 1576 struct wlan_objmgr_peer *peer_temp; 1577 1578 /* Iterate through hash list to get the peer */ 1579 peer = wlan_psoc_peer_list_peek_head(obj_list); 1580 while (peer) { 1581 /* For peer, macaddr is key */ 1582 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1583 == QDF_STATUS_SUCCESS) { 1584 /* 1585 * BSSID match is requested by caller, check BSSID 1586 * (vdev mac == bssid) -- return peer 1587 * (vdev mac != bssid) -- perform next iteration 1588 */ 1589 if ((wlan_peer_bssid_match(peer, bssid) == 1590 QDF_STATUS_SUCCESS) && 1591 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1592 wlan_objmgr_peer_get_ref_debug(peer, dbg_id, 1593 func, line); 1594 1595 return peer; 1596 } 1597 } 1598 /* Move to next peer */ 1599 peer_temp = peer; 1600 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1601 } 1602 1603 /* Not found, return NULL */ 1604 return NULL; 1605 } 1606 #else 1607 static struct wlan_objmgr_peer 1608 *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state( 1609 qdf_list_t *obj_list, uint8_t *macaddr, 1610 uint8_t *bssid, 1611 uint8_t pdev_id, 1612 wlan_objmgr_ref_dbgid dbg_id) 1613 { 1614 struct wlan_objmgr_peer *peer; 1615 struct wlan_objmgr_peer *peer_temp; 1616 1617 /* Iterate through hash list to get the peer */ 1618 peer = wlan_psoc_peer_list_peek_head(obj_list); 1619 while (peer) { 1620 /* For peer, macaddr is key */ 1621 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1622 == QDF_STATUS_SUCCESS) { 1623 /* 1624 * BSSID match is requested by caller, check BSSID 1625 * (vdev mac == bssid) -- return peer 1626 * (vdev mac != bssid) -- perform next iteration 1627 */ 1628 if ((wlan_peer_bssid_match(peer, bssid) == 1629 QDF_STATUS_SUCCESS) && 1630 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1631 wlan_objmgr_peer_get_ref(peer, dbg_id); 1632 1633 return peer; 1634 } 1635 } 1636 /* Move to next peer */ 1637 peer_temp = peer; 1638 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1639 } 1640 1641 /* Not found, return NULL */ 1642 return NULL; 1643 } 1644 #endif 1645 1646 /** 1647 * wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid() - get peer 1648 * from psoc peer 1649 * list using mac and vdev 1650 * self mac 1651 * @psoc: PSOC object 1652 * @macaddr: MAC address 1653 * @bssid: BSSID address 1654 * 1655 * API to finds peer object pointer by MAC addr and BSSID from 1656 * peer hash list, bssid check is done on matching peer 1657 * 1658 * Return: peer pointer 1659 * NULL on FAILURE 1660 */ 1661 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1662 static struct wlan_objmgr_peer 1663 *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_debug( 1664 qdf_list_t *obj_list, uint8_t *macaddr, 1665 uint8_t *bssid, uint8_t pdev_id, 1666 wlan_objmgr_ref_dbgid dbg_id, 1667 const char *func, int line) 1668 { 1669 struct wlan_objmgr_peer *peer; 1670 struct wlan_objmgr_peer *peer_temp; 1671 1672 /* Iterate through hash list to get the peer */ 1673 peer = wlan_psoc_peer_list_peek_head(obj_list); 1674 while (peer) { 1675 /* For peer, macaddr is key */ 1676 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1677 == QDF_STATUS_SUCCESS) { 1678 /* 1679 * BSSID match is requested by caller, check BSSID 1680 * (vdev mac == bssid) -- return peer 1681 * (vdev mac != bssid) -- perform next iteration 1682 */ 1683 if ((wlan_peer_bssid_match(peer, bssid) == 1684 QDF_STATUS_SUCCESS) && 1685 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1686 if (wlan_objmgr_peer_try_get_ref_debug(peer, 1687 dbg_id, 1688 func, 1689 line) 1690 == QDF_STATUS_SUCCESS) { 1691 return peer; 1692 } 1693 } 1694 } 1695 /* Move to next peer */ 1696 peer_temp = peer; 1697 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1698 } 1699 /* Not found, return NULL */ 1700 return NULL; 1701 } 1702 #else 1703 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid( 1704 qdf_list_t *obj_list, uint8_t *macaddr, 1705 uint8_t *bssid, uint8_t pdev_id, 1706 wlan_objmgr_ref_dbgid dbg_id) 1707 { 1708 struct wlan_objmgr_peer *peer; 1709 struct wlan_objmgr_peer *peer_temp; 1710 1711 /* Iterate through hash list to get the peer */ 1712 peer = wlan_psoc_peer_list_peek_head(obj_list); 1713 while (peer) { 1714 /* For peer, macaddr is key */ 1715 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1716 == QDF_STATUS_SUCCESS) { 1717 /* 1718 * BSSID match is requested by caller, check BSSID 1719 * (vdev mac == bssid) -- return peer 1720 * (vdev mac != bssid) -- perform next iteration 1721 */ 1722 if ((wlan_peer_bssid_match(peer, bssid) == 1723 QDF_STATUS_SUCCESS) && 1724 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1725 if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) 1726 == QDF_STATUS_SUCCESS) { 1727 return peer; 1728 } 1729 } 1730 } 1731 /* Move to next peer */ 1732 peer_temp = peer; 1733 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1734 } 1735 /* Not found, return NULL */ 1736 return NULL; 1737 } 1738 #endif 1739 1740 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1741 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_no_state_debug( 1742 qdf_list_t *obj_list, uint8_t *macaddr, 1743 uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id, 1744 const char *func, int line) 1745 { 1746 struct wlan_objmgr_peer *peer; 1747 struct wlan_objmgr_peer *peer_temp; 1748 1749 /* Iterate through hash list to get the peer */ 1750 peer = wlan_psoc_peer_list_peek_head(obj_list); 1751 while (peer) { 1752 /* For peer, macaddr and pdev_id is key */ 1753 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1754 == QDF_STATUS_SUCCESS) && 1755 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1756 wlan_objmgr_peer_get_ref_debug(peer, dbg_id, func, 1757 line); 1758 1759 return peer; 1760 } 1761 /* Move to next peer */ 1762 peer_temp = peer; 1763 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1764 } 1765 1766 /* Not found, return NULL */ 1767 return NULL; 1768 } 1769 #else 1770 static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_no_state( 1771 qdf_list_t *obj_list, uint8_t *macaddr, 1772 uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id) 1773 { 1774 struct wlan_objmgr_peer *peer; 1775 struct wlan_objmgr_peer *peer_temp; 1776 1777 /* Iterate through hash list to get the peer */ 1778 peer = wlan_psoc_peer_list_peek_head(obj_list); 1779 while (peer) { 1780 /* For peer, macaddr and pdev_id is key */ 1781 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1782 == QDF_STATUS_SUCCESS) && 1783 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1784 wlan_objmgr_peer_get_ref(peer, dbg_id); 1785 1786 return peer; 1787 } 1788 /* Move to next peer */ 1789 peer_temp = peer; 1790 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1791 } 1792 1793 /* Not found, return NULL */ 1794 return NULL; 1795 } 1796 #endif 1797 1798 /** 1799 * wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid() - 1800 * get peer 1801 * from psoc peer list using 1802 * mac and vdev self mac 1803 * @obj_list: peer object list 1804 * @macaddr: MAC address 1805 * @bssid: BSSID address 1806 * @dbg_id: id of the caller 1807 * @func: function name 1808 * @line: line number 1809 * 1810 * API to finds peer object pointer by MAC addr and BSSID from 1811 * peer hash list for a node which is in logically deleted state, 1812 * bssid check is done on matching peer 1813 * 1814 * Caller to free the list allocated in this function 1815 * 1816 * Return: list of peer pointers 1817 * NULL on FAILURE 1818 */ 1819 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1820 static qdf_list_t 1821 *wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid_debug( 1822 qdf_list_t *obj_list, uint8_t *macaddr, 1823 uint8_t *bssid, uint8_t pdev_id, 1824 wlan_objmgr_ref_dbgid dbg_id, 1825 const char *func, int line) 1826 { 1827 struct wlan_objmgr_peer *peer; 1828 struct wlan_objmgr_peer *peer_temp; 1829 struct wlan_logically_del_peer *peer_list = NULL; 1830 qdf_list_t *logical_del_peer_list = NULL; 1831 bool lock_released = false; 1832 1833 logical_del_peer_list = qdf_mem_malloc(sizeof(*logical_del_peer_list)); 1834 if (!logical_del_peer_list) 1835 return NULL; 1836 1837 qdf_list_create(logical_del_peer_list, WLAN_UMAC_PSOC_MAX_PEERS); 1838 1839 /* Iterate through hash list to get the peer */ 1840 peer = wlan_psoc_peer_list_peek_head(obj_list); 1841 while (peer) { 1842 wlan_peer_obj_lock(peer); 1843 /* For peer, macaddr and pdev id are keys */ 1844 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1845 == QDF_STATUS_SUCCESS) && 1846 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1847 /* 1848 * if BSSID not NULL, 1849 * then match is requested by caller, check BSSID 1850 * (vdev mac == bssid) -- return peer 1851 * (vdev mac != bssid) -- perform next iteration 1852 */ 1853 if ((!bssid) || 1854 (wlan_peer_bssid_match(peer, bssid) == 1855 QDF_STATUS_SUCCESS)) { 1856 /* Return peer in logically deleted state */ 1857 if ((peer->obj_state == 1858 WLAN_OBJ_STATE_LOGICALLY_DELETED) && 1859 qdf_atomic_read( 1860 &peer->peer_objmgr.ref_cnt)) { 1861 wlan_objmgr_peer_get_ref_debug(peer, 1862 dbg_id, 1863 func, 1864 line); 1865 wlan_peer_obj_unlock(peer); 1866 lock_released = true; 1867 1868 peer_list = 1869 qdf_mem_malloc( 1870 sizeof(struct wlan_logically_del_peer)); 1871 if (!peer_list) { 1872 wlan_objmgr_peer_release_ref(peer, dbg_id); 1873 /* Lock is already released */ 1874 WLAN_OBJMGR_BUG(0); 1875 break; 1876 } 1877 1878 peer_list->peer = peer; 1879 1880 qdf_list_insert_front( 1881 logical_del_peer_list, 1882 &peer_list->list); 1883 } 1884 } 1885 } 1886 1887 if (!lock_released) 1888 wlan_peer_obj_unlock(peer); 1889 1890 /* Move to next peer */ 1891 peer_temp = peer; 1892 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1893 lock_released = false; 1894 } 1895 1896 /* Not found, return NULL */ 1897 if (qdf_list_empty(logical_del_peer_list)) { 1898 qdf_mem_free(logical_del_peer_list); 1899 return NULL; 1900 } else { 1901 return logical_del_peer_list; 1902 } 1903 } 1904 #else 1905 static qdf_list_t 1906 *wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid( 1907 qdf_list_t *obj_list, uint8_t *macaddr, 1908 uint8_t *bssid, uint8_t pdev_id, 1909 wlan_objmgr_ref_dbgid dbg_id) 1910 { 1911 struct wlan_objmgr_peer *peer; 1912 struct wlan_objmgr_peer *peer_temp; 1913 struct wlan_logically_del_peer *peer_list = NULL; 1914 qdf_list_t *logical_del_peer_list = NULL; 1915 bool lock_released = false; 1916 1917 logical_del_peer_list = qdf_mem_malloc(sizeof(*logical_del_peer_list)); 1918 if (!logical_del_peer_list) 1919 return NULL; 1920 1921 qdf_list_create(logical_del_peer_list, WLAN_UMAC_PSOC_MAX_PEERS); 1922 1923 /* Iterate through hash list to get the peer */ 1924 peer = wlan_psoc_peer_list_peek_head(obj_list); 1925 while (peer) { 1926 wlan_peer_obj_lock(peer); 1927 /* For peer, macaddr and pdev id are keys */ 1928 if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) 1929 == QDF_STATUS_SUCCESS) && 1930 (wlan_peer_get_pdev_id(peer) == pdev_id)) { 1931 /* 1932 * if BSSID not NULL, 1933 * then match is requested by caller, check BSSID 1934 * (vdev mac == bssid) -- return peer 1935 * (vdev mac != bssid) -- perform next iteration 1936 */ 1937 if ((!bssid) || 1938 (wlan_peer_bssid_match(peer, bssid) == 1939 QDF_STATUS_SUCCESS)) { 1940 /* Return peer in logically deleted state */ 1941 if ((peer->obj_state == 1942 WLAN_OBJ_STATE_LOGICALLY_DELETED) && 1943 qdf_atomic_read( 1944 &peer->peer_objmgr.ref_cnt)) { 1945 wlan_objmgr_peer_get_ref(peer, dbg_id); 1946 wlan_peer_obj_unlock(peer); 1947 lock_released = true; 1948 1949 peer_list = 1950 qdf_mem_malloc( 1951 sizeof(struct wlan_logically_del_peer)); 1952 if (!peer_list) { 1953 wlan_objmgr_peer_release_ref(peer, dbg_id); 1954 /* Lock is already released */ 1955 WLAN_OBJMGR_BUG(0); 1956 break; 1957 } 1958 1959 peer_list->peer = peer; 1960 1961 qdf_list_insert_front( 1962 logical_del_peer_list, 1963 &peer_list->list); 1964 } 1965 } 1966 } 1967 1968 if (!lock_released) 1969 wlan_peer_obj_unlock(peer); 1970 1971 /* Move to next peer */ 1972 peer_temp = peer; 1973 peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); 1974 lock_released = false; 1975 } 1976 1977 /* Not found, return NULL */ 1978 if (qdf_list_empty(logical_del_peer_list)) { 1979 qdf_mem_free(logical_del_peer_list); 1980 return NULL; 1981 } else { 1982 return logical_del_peer_list; 1983 } 1984 } 1985 #endif 1986 1987 QDF_STATUS wlan_objmgr_psoc_peer_attach(struct wlan_objmgr_psoc *psoc, 1988 struct wlan_objmgr_peer *peer) 1989 { 1990 struct wlan_objmgr_psoc_objmgr *objmgr; 1991 uint8_t hash_index; 1992 struct wlan_peer_list *peer_list; 1993 1994 wlan_psoc_obj_lock(psoc); 1995 objmgr = &psoc->soc_objmgr; 1996 /* Max temporary peer limit is reached, return failure */ 1997 if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) { 1998 if (objmgr->temp_peer_count >= WLAN_MAX_PSOC_TEMP_PEERS) { 1999 wlan_psoc_obj_unlock(psoc); 2000 return QDF_STATUS_E_FAILURE; 2001 } 2002 } else { 2003 /* Max peer limit is reached, return failure */ 2004 if (objmgr->wlan_peer_count 2005 >= wlan_psoc_get_max_peer_count(psoc)) { 2006 wlan_psoc_obj_unlock(psoc); 2007 return QDF_STATUS_E_FAILURE; 2008 } 2009 } 2010 2011 /* Derive hash index from mac address */ 2012 hash_index = WLAN_PEER_HASH(peer->macaddr); 2013 peer_list = &objmgr->peer_list; 2014 /* psoc lock should be taken before list lock */ 2015 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2016 /* add peer to hash peer list */ 2017 wlan_obj_psoc_peerlist_add_tail( 2018 &peer_list->peer_hash[hash_index], 2019 peer); 2020 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2021 /* Increment peer count */ 2022 if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) 2023 objmgr->temp_peer_count++; 2024 else 2025 objmgr->wlan_peer_count++; 2026 2027 wlan_psoc_obj_unlock(psoc); 2028 2029 return QDF_STATUS_SUCCESS; 2030 } 2031 2032 QDF_STATUS wlan_objmgr_psoc_peer_detach(struct wlan_objmgr_psoc *psoc, 2033 struct wlan_objmgr_peer *peer) 2034 { 2035 struct wlan_objmgr_psoc_objmgr *objmgr; 2036 uint8_t hash_index; 2037 struct wlan_peer_list *peer_list; 2038 2039 wlan_psoc_obj_lock(psoc); 2040 objmgr = &psoc->soc_objmgr; 2041 /* if list is empty, return */ 2042 if (objmgr->wlan_peer_count == 0) { 2043 wlan_psoc_obj_unlock(psoc); 2044 return QDF_STATUS_E_FAILURE; 2045 } 2046 /* Get hash index, to locate the actual peer list */ 2047 hash_index = WLAN_PEER_HASH(peer->macaddr); 2048 peer_list = &objmgr->peer_list; 2049 /* psoc lock should be taken before list lock */ 2050 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2051 /* removes the peer from peer_list */ 2052 if (wlan_obj_psoc_peerlist_remove_peer( 2053 &peer_list->peer_hash[hash_index], 2054 peer) == 2055 QDF_STATUS_E_FAILURE) { 2056 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2057 wlan_psoc_obj_unlock(psoc); 2058 obj_mgr_err("Failed to detach peer"); 2059 return QDF_STATUS_E_FAILURE; 2060 } 2061 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2062 /* Decrement peer count */ 2063 if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) 2064 objmgr->temp_peer_count--; 2065 else 2066 objmgr->wlan_peer_count--; 2067 wlan_psoc_obj_unlock(psoc); 2068 2069 return QDF_STATUS_SUCCESS; 2070 } 2071 2072 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2073 struct wlan_objmgr_peer *wlan_objmgr_get_peer_debug( 2074 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2075 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id, 2076 const char *func, int line) 2077 { 2078 struct wlan_objmgr_psoc_objmgr *objmgr; 2079 uint8_t hash_index; 2080 struct wlan_objmgr_peer *peer = NULL; 2081 struct wlan_peer_list *peer_list; 2082 2083 if (pdev_id >= WLAN_UMAC_MAX_PDEVS) 2084 QDF_ASSERT(0); 2085 2086 if (!macaddr) 2087 return NULL; 2088 2089 /* psoc lock should be taken before peer list lock */ 2090 wlan_psoc_obj_lock(psoc); 2091 objmgr = &psoc->soc_objmgr; 2092 /* List is empty, return NULL */ 2093 if (objmgr->wlan_peer_count == 0) { 2094 wlan_psoc_obj_unlock(psoc); 2095 return NULL; 2096 } 2097 /* reduce the search window, with hash key */ 2098 hash_index = WLAN_PEER_HASH(macaddr); 2099 peer_list = &objmgr->peer_list; 2100 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2101 /* Iterate through peer list, get peer */ 2102 peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id_debug( 2103 &peer_list->peer_hash[hash_index], macaddr, 2104 pdev_id, dbg_id, func, line); 2105 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2106 wlan_psoc_obj_unlock(psoc); 2107 2108 return peer; 2109 } 2110 2111 qdf_export_symbol(wlan_objmgr_get_peer_debug); 2112 #else 2113 struct wlan_objmgr_peer *wlan_objmgr_get_peer( 2114 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2115 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) 2116 { 2117 struct wlan_objmgr_psoc_objmgr *objmgr; 2118 uint8_t hash_index; 2119 struct wlan_objmgr_peer *peer = NULL; 2120 struct wlan_peer_list *peer_list; 2121 2122 if (pdev_id >= WLAN_UMAC_MAX_PDEVS) 2123 QDF_ASSERT(0); 2124 2125 if (!macaddr) 2126 return NULL; 2127 2128 /* psoc lock should be taken before peer list lock */ 2129 wlan_psoc_obj_lock(psoc); 2130 objmgr = &psoc->soc_objmgr; 2131 /* List is empty, return NULL */ 2132 if (objmgr->wlan_peer_count == 0) { 2133 wlan_psoc_obj_unlock(psoc); 2134 return NULL; 2135 } 2136 /* reduce the search window, with hash key */ 2137 hash_index = WLAN_PEER_HASH(macaddr); 2138 peer_list = &objmgr->peer_list; 2139 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2140 /* Iterate through peer list, get peer */ 2141 peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id( 2142 &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); 2143 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2144 wlan_psoc_obj_unlock(psoc); 2145 2146 return peer; 2147 } 2148 2149 qdf_export_symbol(wlan_objmgr_get_peer); 2150 #endif 2151 2152 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2153 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_debug( 2154 struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, 2155 wlan_objmgr_ref_dbgid dbg_id, 2156 const char *func, int line) 2157 { 2158 struct wlan_objmgr_psoc_objmgr *objmgr; 2159 uint8_t hash_index; 2160 struct wlan_objmgr_peer *peer = NULL; 2161 struct wlan_peer_list *peer_list; 2162 2163 if (!macaddr) 2164 return NULL; 2165 2166 /* psoc lock should be taken before peer list lock */ 2167 wlan_psoc_obj_lock(psoc); 2168 objmgr = &psoc->soc_objmgr; 2169 /* List is empty, return NULL */ 2170 if (objmgr->wlan_peer_count == 0) { 2171 wlan_psoc_obj_unlock(psoc); 2172 return NULL; 2173 } 2174 /* reduce the search window, with hash key */ 2175 hash_index = WLAN_PEER_HASH(macaddr); 2176 peer_list = &objmgr->peer_list; 2177 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2178 /* Iterate through peer list, get peer */ 2179 peer = wlan_obj_psoc_peerlist_get_peer_debug( 2180 &peer_list->peer_hash[hash_index], 2181 macaddr, dbg_id, func, line); 2182 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2183 wlan_psoc_obj_unlock(psoc); 2184 2185 return peer; 2186 } 2187 2188 qdf_export_symbol(wlan_objmgr_get_peer_by_mac_debug); 2189 #else 2190 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac( 2191 struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, 2192 wlan_objmgr_ref_dbgid dbg_id) 2193 { 2194 struct wlan_objmgr_psoc_objmgr *objmgr; 2195 uint8_t hash_index; 2196 struct wlan_objmgr_peer *peer = NULL; 2197 struct wlan_peer_list *peer_list; 2198 2199 if (!macaddr) 2200 return NULL; 2201 2202 /* psoc lock should be taken before peer list lock */ 2203 wlan_psoc_obj_lock(psoc); 2204 objmgr = &psoc->soc_objmgr; 2205 /* List is empty, return NULL */ 2206 if (objmgr->wlan_peer_count == 0) { 2207 wlan_psoc_obj_unlock(psoc); 2208 return NULL; 2209 } 2210 /* reduce the search window, with hash key */ 2211 hash_index = WLAN_PEER_HASH(macaddr); 2212 peer_list = &objmgr->peer_list; 2213 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2214 /* Iterate through peer list, get peer */ 2215 peer = wlan_obj_psoc_peerlist_get_peer( 2216 &peer_list->peer_hash[hash_index], macaddr, dbg_id); 2217 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2218 wlan_psoc_obj_unlock(psoc); 2219 2220 return peer; 2221 } 2222 2223 qdf_export_symbol(wlan_objmgr_get_peer_by_mac); 2224 #endif 2225 2226 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2227 struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted_debug( 2228 struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, 2229 wlan_objmgr_ref_dbgid dbg_id, 2230 const char *func, int line) 2231 { 2232 struct wlan_objmgr_psoc_objmgr *objmgr; 2233 uint8_t hash_index; 2234 struct wlan_objmgr_peer *peer = NULL; 2235 struct wlan_peer_list *peer_list; 2236 2237 /* psoc lock should be taken before peer list lock */ 2238 wlan_psoc_obj_lock(psoc); 2239 objmgr = &psoc->soc_objmgr; 2240 /* List is empty, return NULL */ 2241 if (objmgr->wlan_peer_count == 0) { 2242 wlan_psoc_obj_unlock(psoc); 2243 return NULL; 2244 } 2245 /* reduce the search window, with hash key */ 2246 hash_index = WLAN_PEER_HASH(macaddr); 2247 peer_list = &objmgr->peer_list; 2248 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2249 /* Iterate through peer list, get peer */ 2250 peer = wlan_obj_psoc_peerlist_get_peer_logically_deleted_debug( 2251 &peer_list->peer_hash[hash_index], macaddr, dbg_id, 2252 func, line); 2253 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2254 wlan_psoc_obj_unlock(psoc); 2255 2256 return peer; 2257 } 2258 #else 2259 struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted( 2260 struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, 2261 wlan_objmgr_ref_dbgid dbg_id) 2262 { 2263 struct wlan_objmgr_psoc_objmgr *objmgr; 2264 uint8_t hash_index; 2265 struct wlan_objmgr_peer *peer = NULL; 2266 struct wlan_peer_list *peer_list; 2267 2268 /* psoc lock should be taken before peer list lock */ 2269 wlan_psoc_obj_lock(psoc); 2270 objmgr = &psoc->soc_objmgr; 2271 /* List is empty, return NULL */ 2272 if (objmgr->wlan_peer_count == 0) { 2273 wlan_psoc_obj_unlock(psoc); 2274 return NULL; 2275 } 2276 /* reduce the search window, with hash key */ 2277 hash_index = WLAN_PEER_HASH(macaddr); 2278 peer_list = &objmgr->peer_list; 2279 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2280 /* Iterate through peer list, get peer */ 2281 peer = wlan_obj_psoc_peerlist_get_peer_logically_deleted( 2282 &peer_list->peer_hash[hash_index], macaddr, dbg_id); 2283 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2284 wlan_psoc_obj_unlock(psoc); 2285 2286 return peer; 2287 } 2288 #endif 2289 2290 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2291 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_no_state_debug( 2292 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2293 uint8_t *bssid, uint8_t *macaddr, 2294 wlan_objmgr_ref_dbgid dbg_id, 2295 const char *func, int line) 2296 { 2297 struct wlan_objmgr_psoc_objmgr *objmgr; 2298 uint8_t hash_index; 2299 struct wlan_objmgr_peer *peer = NULL; 2300 struct wlan_peer_list *peer_list; 2301 2302 /* psoc lock should be taken before peer list lock */ 2303 wlan_psoc_obj_lock(psoc); 2304 objmgr = &psoc->soc_objmgr; 2305 /* List is empty, return NULL */ 2306 if (objmgr->wlan_peer_count == 0) { 2307 wlan_psoc_obj_unlock(psoc); 2308 return NULL; 2309 } 2310 /* reduce the search window, with hash key */ 2311 hash_index = WLAN_PEER_HASH(macaddr); 2312 peer_list = &objmgr->peer_list; 2313 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2314 /* Iterate through peer list, get peer */ 2315 peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state_debug( 2316 &peer_list->peer_hash[hash_index], macaddr, bssid, 2317 pdev_id, dbg_id, func, line); 2318 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2319 wlan_psoc_obj_unlock(psoc); 2320 2321 return peer; 2322 } 2323 2324 qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev_no_state_debug); 2325 #else 2326 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_no_state( 2327 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2328 uint8_t *bssid, uint8_t *macaddr, 2329 wlan_objmgr_ref_dbgid dbg_id) 2330 { 2331 struct wlan_objmgr_psoc_objmgr *objmgr; 2332 uint8_t hash_index; 2333 struct wlan_objmgr_peer *peer = NULL; 2334 struct wlan_peer_list *peer_list; 2335 2336 /* psoc lock should be taken before peer list lock */ 2337 wlan_psoc_obj_lock(psoc); 2338 objmgr = &psoc->soc_objmgr; 2339 /* List is empty, return NULL */ 2340 if (objmgr->wlan_peer_count == 0) { 2341 wlan_psoc_obj_unlock(psoc); 2342 return NULL; 2343 } 2344 /* reduce the search window, with hash key */ 2345 hash_index = WLAN_PEER_HASH(macaddr); 2346 peer_list = &objmgr->peer_list; 2347 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2348 /* Iterate through peer list, get peer */ 2349 peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state( 2350 &peer_list->peer_hash[hash_index], macaddr, bssid, 2351 pdev_id, dbg_id); 2352 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2353 wlan_psoc_obj_unlock(psoc); 2354 2355 return peer; 2356 } 2357 2358 qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev_no_state); 2359 #endif 2360 2361 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2362 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_debug( 2363 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2364 uint8_t *bssid, uint8_t *macaddr, 2365 wlan_objmgr_ref_dbgid dbg_id, 2366 const char *func, int line) 2367 { 2368 struct wlan_objmgr_psoc_objmgr *objmgr; 2369 uint8_t hash_index; 2370 struct wlan_objmgr_peer *peer = NULL; 2371 struct wlan_peer_list *peer_list; 2372 2373 /* psoc lock should be taken before peer list lock */ 2374 wlan_psoc_obj_lock(psoc); 2375 objmgr = &psoc->soc_objmgr; 2376 /* List is empty, return NULL */ 2377 if (objmgr->wlan_peer_count == 0) { 2378 wlan_psoc_obj_unlock(psoc); 2379 return NULL; 2380 } 2381 /* reduce the search window, with hash key */ 2382 hash_index = WLAN_PEER_HASH(macaddr); 2383 peer_list = &objmgr->peer_list; 2384 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2385 /* Iterate through peer list, get peer */ 2386 peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_debug( 2387 &peer_list->peer_hash[hash_index], macaddr, bssid, 2388 pdev_id, dbg_id, func, line); 2389 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2390 wlan_psoc_obj_unlock(psoc); 2391 2392 return peer; 2393 } 2394 2395 qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev_debug); 2396 #else 2397 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev( 2398 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2399 uint8_t *bssid, uint8_t *macaddr, 2400 wlan_objmgr_ref_dbgid dbg_id) 2401 { 2402 struct wlan_objmgr_psoc_objmgr *objmgr; 2403 uint8_t hash_index; 2404 struct wlan_objmgr_peer *peer = NULL; 2405 struct wlan_peer_list *peer_list; 2406 2407 /* psoc lock should be taken before peer list lock */ 2408 wlan_psoc_obj_lock(psoc); 2409 objmgr = &psoc->soc_objmgr; 2410 /* List is empty, return NULL */ 2411 if (objmgr->wlan_peer_count == 0) { 2412 wlan_psoc_obj_unlock(psoc); 2413 return NULL; 2414 } 2415 /* reduce the search window, with hash key */ 2416 hash_index = WLAN_PEER_HASH(macaddr); 2417 peer_list = &objmgr->peer_list; 2418 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2419 /* Iterate through peer list, get peer */ 2420 peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid( 2421 &peer_list->peer_hash[hash_index], macaddr, bssid, 2422 pdev_id, dbg_id); 2423 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2424 wlan_psoc_obj_unlock(psoc); 2425 2426 return peer; 2427 } 2428 2429 qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev); 2430 #endif 2431 2432 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2433 struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock_debug( 2434 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2435 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id, 2436 const char *func, int line) 2437 { 2438 struct wlan_objmgr_psoc_objmgr *objmgr; 2439 uint8_t hash_index; 2440 struct wlan_objmgr_peer *peer = NULL; 2441 struct wlan_peer_list *peer_list; 2442 2443 /* psoc lock should be taken before peer list lock */ 2444 objmgr = &psoc->soc_objmgr; 2445 /* List is empty, return NULL */ 2446 if (objmgr->wlan_peer_count == 0) 2447 return NULL; 2448 2449 /* reduce the search window, with hash key */ 2450 hash_index = WLAN_PEER_HASH(macaddr); 2451 peer_list = &objmgr->peer_list; 2452 /* Iterate through peer list, get peer */ 2453 peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id_debug( 2454 &peer_list->peer_hash[hash_index], macaddr, 2455 pdev_id, dbg_id, func, line); 2456 2457 return peer; 2458 } 2459 2460 qdf_export_symbol(wlan_objmgr_get_peer_nolock_debug); 2461 #else 2462 struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock( 2463 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2464 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) 2465 { 2466 struct wlan_objmgr_psoc_objmgr *objmgr; 2467 uint8_t hash_index; 2468 struct wlan_objmgr_peer *peer = NULL; 2469 struct wlan_peer_list *peer_list; 2470 2471 /* psoc lock should be taken before peer list lock */ 2472 objmgr = &psoc->soc_objmgr; 2473 /* List is empty, return NULL */ 2474 if (objmgr->wlan_peer_count == 0) 2475 return NULL; 2476 2477 /* reduce the search window, with hash key */ 2478 hash_index = WLAN_PEER_HASH(macaddr); 2479 peer_list = &objmgr->peer_list; 2480 /* Iterate through peer list, get peer */ 2481 peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id( 2482 &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); 2483 2484 return peer; 2485 } 2486 2487 qdf_export_symbol(wlan_objmgr_get_peer_nolock); 2488 #endif 2489 2490 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2491 struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state_debug( 2492 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2493 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id, 2494 const char *func, int line) 2495 { 2496 struct wlan_objmgr_psoc_objmgr *objmgr; 2497 uint8_t hash_index; 2498 struct wlan_objmgr_peer *peer = NULL; 2499 struct wlan_peer_list *peer_list; 2500 2501 /* psoc lock should be taken before peer list lock */ 2502 wlan_psoc_obj_lock(psoc); 2503 objmgr = &psoc->soc_objmgr; 2504 /* List is empty, return NULL */ 2505 if (objmgr->wlan_peer_count == 0) { 2506 wlan_psoc_obj_unlock(psoc); 2507 return NULL; 2508 } 2509 /* reduce the search window, with hash key */ 2510 hash_index = WLAN_PEER_HASH(macaddr); 2511 peer_list = &objmgr->peer_list; 2512 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2513 /* Iterate through peer list, get peer */ 2514 peer = wlan_obj_psoc_peerlist_get_peer_no_state_debug( 2515 &peer_list->peer_hash[hash_index], macaddr, 2516 pdev_id, dbg_id, func, line); 2517 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2518 wlan_psoc_obj_unlock(psoc); 2519 2520 return peer; 2521 } 2522 2523 qdf_export_symbol(wlan_objmgr_get_peer_no_state_debug); 2524 #else 2525 struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state( 2526 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2527 uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) 2528 { 2529 struct wlan_objmgr_psoc_objmgr *objmgr; 2530 uint8_t hash_index; 2531 struct wlan_objmgr_peer *peer = NULL; 2532 struct wlan_peer_list *peer_list; 2533 2534 /* psoc lock should be taken before peer list lock */ 2535 wlan_psoc_obj_lock(psoc); 2536 objmgr = &psoc->soc_objmgr; 2537 /* List is empty, return NULL */ 2538 if (objmgr->wlan_peer_count == 0) { 2539 wlan_psoc_obj_unlock(psoc); 2540 return NULL; 2541 } 2542 /* reduce the search window, with hash key */ 2543 hash_index = WLAN_PEER_HASH(macaddr); 2544 peer_list = &objmgr->peer_list; 2545 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2546 /* Iterate through peer list, get peer */ 2547 peer = wlan_obj_psoc_peerlist_get_peer_no_state( 2548 &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); 2549 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2550 wlan_psoc_obj_unlock(psoc); 2551 2552 return peer; 2553 } 2554 2555 qdf_export_symbol(wlan_objmgr_get_peer_no_state); 2556 #endif 2557 2558 /** 2559 * wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev() - 2560 * get peer from psoc 2561 * peer list using 2562 * mac and vdev 2563 * self mac 2564 * @psoc: PSOC object 2565 * @pdev_id: Pdev id 2566 * @macaddr: MAC address 2567 * @bssid: BSSID address. NULL mac means search all. 2568 * @dbg_id: id of the caller 2569 * @func: function name 2570 * @line: line number 2571 * 2572 * API to finds peer object pointer by MAC addr and BSSID from 2573 * peer hash list, bssid check is done on matching peer 2574 * 2575 * Return: list of peer pointer pointers 2576 * NULL on FAILURE 2577 */ 2578 2579 #ifdef WLAN_OBJMGR_REF_ID_TRACE 2580 qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev_debug( 2581 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2582 uint8_t *bssid, uint8_t *macaddr, 2583 wlan_objmgr_ref_dbgid dbg_id, 2584 const char *func, int line) 2585 { 2586 struct wlan_objmgr_psoc_objmgr *objmgr; 2587 uint8_t hash_index; 2588 struct wlan_peer_list *peer_list = NULL; 2589 qdf_list_t *logical_del_peer_list = NULL; 2590 2591 /* psoc lock should be taken before peer list lock */ 2592 wlan_psoc_obj_lock(psoc); 2593 objmgr = &psoc->soc_objmgr; 2594 /* List is empty, return NULL */ 2595 if (objmgr->wlan_peer_count == 0) { 2596 wlan_psoc_obj_unlock(psoc); 2597 return NULL; 2598 } 2599 /* reduce the search window, with hash key */ 2600 hash_index = WLAN_PEER_HASH(macaddr); 2601 peer_list = &objmgr->peer_list; 2602 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2603 2604 /* Iterate through peer list, get peer */ 2605 logical_del_peer_list = 2606 wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid_debug( 2607 &peer_list->peer_hash[hash_index], macaddr, 2608 bssid, pdev_id, dbg_id, func, line); 2609 2610 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2611 wlan_psoc_obj_unlock(psoc); 2612 2613 return logical_del_peer_list; 2614 } 2615 2616 qdf_export_symbol(wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev_debug); 2617 #else 2618 qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev( 2619 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 2620 uint8_t *bssid, uint8_t *macaddr, 2621 wlan_objmgr_ref_dbgid dbg_id) 2622 { 2623 struct wlan_objmgr_psoc_objmgr *objmgr; 2624 uint8_t hash_index; 2625 struct wlan_peer_list *peer_list = NULL; 2626 qdf_list_t *logical_del_peer_list = NULL; 2627 2628 /* psoc lock should be taken before peer list lock */ 2629 wlan_psoc_obj_lock(psoc); 2630 objmgr = &psoc->soc_objmgr; 2631 /* List is empty, return NULL */ 2632 if (objmgr->wlan_peer_count == 0) { 2633 wlan_psoc_obj_unlock(psoc); 2634 return NULL; 2635 } 2636 /* reduce the search window, with hash key */ 2637 hash_index = WLAN_PEER_HASH(macaddr); 2638 peer_list = &objmgr->peer_list; 2639 qdf_spin_lock_bh(&peer_list->peer_list_lock); 2640 2641 /* Iterate through peer list, get peer */ 2642 logical_del_peer_list = 2643 wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid( 2644 &peer_list->peer_hash[hash_index], macaddr, 2645 bssid, pdev_id, dbg_id); 2646 2647 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 2648 wlan_psoc_obj_unlock(psoc); 2649 2650 return logical_del_peer_list; 2651 } 2652 2653 qdf_export_symbol(wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev); 2654 #endif 2655 2656 void *wlan_objmgr_psoc_get_comp_private_obj(struct wlan_objmgr_psoc *psoc, 2657 enum wlan_umac_comp_id id) 2658 { 2659 void *comp_private_obj; 2660 2661 /* component id is invalid */ 2662 if (id >= WLAN_UMAC_MAX_COMPONENTS) { 2663 QDF_BUG(0); 2664 return NULL; 2665 } 2666 2667 if (!psoc) { 2668 QDF_BUG(0); 2669 return NULL; 2670 } 2671 2672 comp_private_obj = psoc->soc_comp_priv_obj[id]; 2673 2674 return comp_private_obj; 2675 } 2676 qdf_export_symbol(wlan_objmgr_psoc_get_comp_private_obj); 2677 2678 void wlan_objmgr_psoc_get_ref(struct wlan_objmgr_psoc *psoc, 2679 wlan_objmgr_ref_dbgid id) 2680 { 2681 if (!psoc) { 2682 obj_mgr_err("psoc obj is NULL for id:%d", id); 2683 QDF_ASSERT(0); 2684 return; 2685 } 2686 /* Increment ref count */ 2687 qdf_atomic_inc(&psoc->soc_objmgr.ref_cnt); 2688 qdf_atomic_inc(&psoc->soc_objmgr.ref_id_dbg[id]); 2689 return; 2690 } 2691 qdf_export_symbol(wlan_objmgr_psoc_get_ref); 2692 2693 QDF_STATUS wlan_objmgr_psoc_try_get_ref(struct wlan_objmgr_psoc *psoc, 2694 wlan_objmgr_ref_dbgid id) 2695 { 2696 if (!psoc) { 2697 obj_mgr_err("psoc obj is NULL for id:%d", id); 2698 QDF_ASSERT(0); 2699 return QDF_STATUS_E_FAILURE; 2700 } 2701 2702 wlan_psoc_obj_lock(psoc); 2703 if (psoc->obj_state != WLAN_OBJ_STATE_CREATED) { 2704 wlan_psoc_obj_unlock(psoc); 2705 if (psoc->soc_objmgr.print_cnt++ <= 2706 WLAN_OBJMGR_RATELIMIT_THRESH) 2707 obj_mgr_err( 2708 "[Ref id: %d] psoc is not in Created state(%d)", 2709 id, psoc->obj_state); 2710 2711 return QDF_STATUS_E_RESOURCES; 2712 } 2713 2714 /* Increment ref count */ 2715 wlan_objmgr_psoc_get_ref(psoc, id); 2716 wlan_psoc_obj_unlock(psoc); 2717 2718 return QDF_STATUS_SUCCESS; 2719 } 2720 qdf_export_symbol(wlan_objmgr_psoc_try_get_ref); 2721 2722 void wlan_objmgr_psoc_release_ref(struct wlan_objmgr_psoc *psoc, 2723 wlan_objmgr_ref_dbgid id) 2724 { 2725 if (!psoc) { 2726 obj_mgr_err("psoc obj is NULL for id:%d", id); 2727 QDF_ASSERT(0); 2728 return; 2729 } 2730 2731 if (!qdf_atomic_read(&psoc->soc_objmgr.ref_id_dbg[id])) { 2732 obj_mgr_err("psoc ref cnt was not taken by %d", id); 2733 wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, 2734 QDF_TRACE_LEVEL_FATAL); 2735 WLAN_OBJMGR_BUG(0); 2736 } 2737 2738 if (!qdf_atomic_read(&psoc->soc_objmgr.ref_cnt)) { 2739 obj_mgr_err("psoc ref cnt is 0"); 2740 WLAN_OBJMGR_BUG(0); 2741 return; 2742 } 2743 2744 qdf_atomic_dec(&psoc->soc_objmgr.ref_id_dbg[id]); 2745 /* Decrement ref count, free psoc, if ref count == 0 */ 2746 if (qdf_atomic_dec_and_test(&psoc->soc_objmgr.ref_cnt)) 2747 wlan_objmgr_psoc_obj_destroy(psoc); 2748 2749 return; 2750 } 2751 qdf_export_symbol(wlan_objmgr_psoc_release_ref); 2752 2753 static void wlan_objmgr_psoc_peer_ref_print(struct wlan_objmgr_psoc *psoc, 2754 void *obj, void *args) 2755 { 2756 struct wlan_objmgr_peer *peer = (struct wlan_objmgr_peer *)obj; 2757 WLAN_OBJ_STATE obj_state; 2758 uint8_t vdev_id; 2759 uint8_t *macaddr; 2760 2761 wlan_peer_obj_lock(peer); 2762 macaddr = wlan_peer_get_macaddr(peer); 2763 obj_state = peer->obj_state; 2764 vdev_id = wlan_vdev_get_id(wlan_peer_get_vdev(peer)); 2765 wlan_peer_obj_unlock(peer); 2766 2767 obj_mgr_alert("Peer MAC:%02x:%02x:%02x:%02x:%02x:%02x state:%d vdev_id:%d", 2768 macaddr[0], macaddr[1], macaddr[2], macaddr[3], 2769 macaddr[4], macaddr[5], obj_state, vdev_id); 2770 wlan_objmgr_print_peer_ref_ids(peer, QDF_TRACE_LEVEL_FATAL); 2771 } 2772 2773 static void wlan_objmgr_psoc_vdev_ref_print(struct wlan_objmgr_psoc *psoc, 2774 void *obj, void *args) 2775 { 2776 struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; 2777 WLAN_OBJ_STATE obj_state; 2778 uint8_t id; 2779 2780 wlan_vdev_obj_lock(vdev); 2781 id = wlan_vdev_get_id(vdev); 2782 obj_state = vdev->obj_state; 2783 wlan_vdev_obj_unlock(vdev); 2784 obj_mgr_alert("Vdev ID is %d, state %d", id, obj_state); 2785 2786 wlan_objmgr_print_ref_ids(vdev->vdev_objmgr.ref_id_dbg, 2787 QDF_TRACE_LEVEL_FATAL); 2788 } 2789 2790 static void wlan_objmgr_psoc_pdev_ref_print(struct wlan_objmgr_psoc *psoc, 2791 void *obj, void *args) 2792 { 2793 struct wlan_objmgr_pdev *pdev = (struct wlan_objmgr_pdev *)obj; 2794 uint8_t id; 2795 2796 wlan_pdev_obj_lock(pdev); 2797 id = wlan_objmgr_pdev_get_pdev_id(pdev); 2798 wlan_pdev_obj_unlock(pdev); 2799 obj_mgr_alert("pdev ID is %d", id); 2800 2801 wlan_objmgr_print_ref_ids(pdev->pdev_objmgr.ref_id_dbg, 2802 QDF_TRACE_LEVEL_FATAL); 2803 } 2804 2805 QDF_STATUS wlan_objmgr_print_ref_all_objects_per_psoc( 2806 struct wlan_objmgr_psoc *psoc) 2807 { 2808 obj_mgr_alert("Ref counts of PEER"); 2809 wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_PEER_OP, 2810 wlan_objmgr_psoc_peer_ref_print, NULL); 2811 obj_mgr_alert("Ref counts of VDEV"); 2812 wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_VDEV_OP, 2813 wlan_objmgr_psoc_vdev_ref_print, NULL); 2814 obj_mgr_alert("Ref counts of PDEV"); 2815 wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_PDEV_OP, 2816 wlan_objmgr_psoc_pdev_ref_print, NULL); 2817 2818 obj_mgr_alert(" Ref counts of PSOC"); 2819 wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, 2820 QDF_TRACE_LEVEL_FATAL); 2821 2822 return QDF_STATUS_SUCCESS; 2823 } 2824 qdf_export_symbol(wlan_objmgr_print_ref_all_objects_per_psoc); 2825 2826 QDF_STATUS wlan_objmgr_psoc_set_user_config(struct wlan_objmgr_psoc *psoc, 2827 struct wlan_objmgr_psoc_user_config *user_config_data) 2828 { 2829 if (!user_config_data) { 2830 obj_mgr_err("user_config_data is NULL"); 2831 QDF_BUG(0); 2832 return QDF_STATUS_E_FAILURE; 2833 } 2834 wlan_psoc_obj_lock(psoc); 2835 qdf_mem_copy(&psoc->soc_nif.user_config, user_config_data, 2836 sizeof(psoc->soc_nif.user_config)); 2837 wlan_psoc_obj_unlock(psoc); 2838 2839 return QDF_STATUS_SUCCESS; 2840 } 2841 2842 uint32_t wlan_objmgr_psoc_check_for_pdev_leaks(struct wlan_objmgr_psoc *psoc) 2843 { 2844 struct wlan_objmgr_psoc_objmgr *_psoc; 2845 struct wlan_objmgr_pdev *pdev; 2846 int pdev_id; 2847 uint32_t leaks = 0; 2848 2849 QDF_BUG(psoc); 2850 if (!psoc) 2851 return leaks; 2852 2853 wlan_psoc_obj_lock(psoc); 2854 _psoc = &psoc->soc_objmgr; 2855 if (!_psoc->wlan_pdev_count) { 2856 wlan_psoc_obj_unlock(psoc); 2857 return leaks; 2858 } 2859 2860 obj_mgr_alert("objmgr pdev leaks detected for psoc %u!", 2861 _psoc->psoc_id); 2862 obj_mgr_alert("----------------------------------------------------"); 2863 obj_mgr_alert("Pdev Id Refs Module"); 2864 obj_mgr_alert("----------------------------------------------------"); 2865 2866 wlan_objmgr_for_each_psoc_pdev(psoc, pdev_id, pdev) { 2867 qdf_atomic_t *ref_id_dbg; 2868 int ref_id; 2869 int32_t refs; 2870 2871 wlan_pdev_obj_lock(pdev); 2872 ref_id_dbg = pdev->pdev_objmgr.ref_id_dbg; 2873 wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { 2874 leaks++; 2875 obj_mgr_alert("%7u %4u %s", 2876 pdev_id, refs, 2877 string_from_dbgid(ref_id)); 2878 } 2879 wlan_pdev_obj_unlock(pdev); 2880 } 2881 2882 wlan_psoc_obj_unlock(psoc); 2883 return leaks; 2884 } 2885 qdf_export_symbol(wlan_objmgr_psoc_check_for_pdev_leaks); 2886 2887 uint32_t wlan_objmgr_psoc_check_for_vdev_leaks(struct wlan_objmgr_psoc *psoc) 2888 { 2889 struct wlan_objmgr_psoc_objmgr *_psoc; 2890 struct wlan_objmgr_vdev *vdev; 2891 int vdev_id; 2892 uint32_t leaks = 0; 2893 2894 QDF_BUG(psoc); 2895 if (!psoc) 2896 return leaks; 2897 2898 wlan_psoc_obj_lock(psoc); 2899 _psoc = &psoc->soc_objmgr; 2900 if (!_psoc->wlan_vdev_count) { 2901 wlan_psoc_obj_unlock(psoc); 2902 return leaks; 2903 } 2904 2905 obj_mgr_alert("objmgr vdev leaks detected for psoc %u!", 2906 _psoc->psoc_id); 2907 obj_mgr_alert("----------------------------------------------------"); 2908 obj_mgr_alert("Vdev Id Refs Module"); 2909 obj_mgr_alert("----------------------------------------------------"); 2910 2911 wlan_objmgr_for_each_psoc_vdev(psoc, vdev_id, vdev) { 2912 qdf_atomic_t *ref_id_dbg; 2913 int ref_id; 2914 int32_t refs; 2915 2916 wlan_vdev_obj_lock(vdev); 2917 ref_id_dbg = vdev->vdev_objmgr.ref_id_dbg; 2918 wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { 2919 leaks++; 2920 obj_mgr_alert("%7u %4u %s", 2921 vdev_id, refs, string_from_dbgid(ref_id)); 2922 } 2923 wlan_vdev_obj_unlock(vdev); 2924 } 2925 2926 wlan_psoc_obj_unlock(psoc); 2927 return leaks; 2928 } 2929 qdf_export_symbol(wlan_objmgr_psoc_check_for_vdev_leaks); 2930 2931 #ifdef WLAN_OBJMGR_REF_ID_DEBUG 2932 static void 2933 wlan_objmgr_print_peer_ref_leaks(struct wlan_objmgr_peer *peer, int vdev_id) 2934 { 2935 qdf_atomic_t *ref_id_dbg; 2936 int32_t refs; 2937 int ref_id; 2938 2939 ref_id_dbg = peer->peer_objmgr.ref_id_dbg; 2940 wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { 2941 obj_mgr_alert(QDF_MAC_ADDR_FMT " %7u %4u %s", 2942 QDF_MAC_ADDR_REF(peer->macaddr), 2943 vdev_id, 2944 refs, 2945 string_from_dbgid(ref_id)); 2946 } 2947 } 2948 #else 2949 static inline void 2950 wlan_objmgr_print_peer_ref_leaks(struct wlan_objmgr_peer *peer, int vdev_id) 2951 { 2952 obj_mgr_alert(QDF_MAC_ADDR_FMT " %7u %4u %s", 2953 QDF_MAC_ADDR_REF(peer->macaddr), 2954 vdev_id, 2955 qdf_atomic_read(&peer->peer_objmgr.ref_cnt), 2956 "TOTAL_REF_COUNT"); 2957 } 2958 #endif 2959 2960 uint32_t wlan_objmgr_psoc_check_for_peer_leaks(struct wlan_objmgr_psoc *psoc) 2961 { 2962 struct wlan_objmgr_psoc_objmgr *_psoc; 2963 struct wlan_objmgr_vdev *vdev; 2964 int vdev_id; 2965 uint32_t leaks = 0; 2966 2967 QDF_BUG(psoc); 2968 if (!psoc) 2969 return leaks; 2970 2971 wlan_psoc_obj_lock(psoc); 2972 _psoc = &psoc->soc_objmgr; 2973 if (!_psoc->temp_peer_count && !_psoc->wlan_peer_count) { 2974 wlan_psoc_obj_unlock(psoc); 2975 return leaks; 2976 } 2977 2978 obj_mgr_alert("objmgr peer leaks detected for psoc %u!", 2979 _psoc->psoc_id); 2980 obj_mgr_alert("----------------------------------------------------"); 2981 obj_mgr_alert("Peer MAC Vdev Id Refs Module"); 2982 obj_mgr_alert("----------------------------------------------------"); 2983 2984 wlan_objmgr_for_each_psoc_vdev(psoc, vdev_id, vdev) { 2985 struct wlan_objmgr_peer *peer; 2986 2987 wlan_vdev_obj_lock(vdev); 2988 wlan_objmgr_for_each_vdev_peer(vdev, peer) { 2989 wlan_peer_obj_lock(peer); 2990 leaks += qdf_atomic_read(&peer->peer_objmgr.ref_cnt); 2991 wlan_objmgr_print_peer_ref_leaks(peer, vdev_id); 2992 wlan_peer_obj_unlock(peer); 2993 } 2994 wlan_vdev_obj_unlock(vdev); 2995 } 2996 2997 wlan_psoc_obj_unlock(psoc); 2998 return leaks; 2999 } 3000 qdf_export_symbol(wlan_objmgr_psoc_check_for_peer_leaks); 3001 3002 void wlan_objmgr_psoc_check_for_leaks(struct wlan_objmgr_psoc *psoc) 3003 { 3004 struct wlan_objmgr_psoc_objmgr *_psoc; 3005 uint32_t peer_leaks = 0; 3006 uint32_t vdev_leaks = 0; 3007 uint32_t pdev_leaks = 0; 3008 3009 _psoc = &psoc->soc_objmgr; 3010 3011 peer_leaks = wlan_objmgr_psoc_check_for_peer_leaks(psoc); 3012 vdev_leaks = wlan_objmgr_psoc_check_for_vdev_leaks(psoc); 3013 pdev_leaks = wlan_objmgr_psoc_check_for_pdev_leaks(psoc); 3014 3015 if (peer_leaks || vdev_leaks || pdev_leaks) { 3016 QDF_DEBUG_PANIC("%u objmgr peer leaks %u objmgr vdev leaks" 3017 "%u objmgr pdev leaks detected for psoc %u!", 3018 peer_leaks, vdev_leaks, pdev_leaks, 3019 _psoc->psoc_id); 3020 } 3021 } 3022 3023 qdf_export_symbol(wlan_objmgr_psoc_check_for_leaks); 3024 3025 #ifdef WLAN_OBJMGR_DEBUG 3026 void wlan_print_psoc_info(struct wlan_objmgr_psoc *psoc) 3027 { 3028 struct wlan_objmgr_psoc_objmgr *psoc_objmgr; 3029 struct wlan_objmgr_pdev *pdev; 3030 struct wlan_objmgr_vdev *vdev; 3031 uint16_t index = 0; 3032 3033 psoc_objmgr = &psoc->soc_objmgr; 3034 3035 obj_mgr_debug("psoc: %pK", psoc); 3036 obj_mgr_debug("psoc_id: %d", psoc_objmgr->psoc_id); 3037 obj_mgr_debug("wlan_pdev_count: %d", psoc_objmgr->wlan_pdev_count); 3038 obj_mgr_debug("wlan_pdev_id_map: 0x%x", psoc_objmgr->wlan_pdev_id_map); 3039 obj_mgr_debug("wlan_vdev_count: %d", psoc_objmgr->wlan_vdev_count); 3040 obj_mgr_debug("max_vdev_count: %d", psoc_objmgr->max_vdev_count); 3041 obj_mgr_debug("wlan_peer_count: %d", psoc_objmgr->wlan_peer_count); 3042 obj_mgr_debug("max_peer_count: %d", psoc_objmgr->max_peer_count); 3043 obj_mgr_debug("temp_peer_count: %d", psoc_objmgr->temp_peer_count); 3044 obj_mgr_debug("ref_cnt: %d", qdf_atomic_read(&psoc_objmgr->ref_cnt)); 3045 obj_mgr_debug("qdf_dev: %pK", psoc_objmgr->qdf_dev); 3046 3047 obj_mgr_debug("wlan_vdev_id_map:"); 3048 obj_mgr_debug_hex(psoc_objmgr->wlan_vdev_id_map, 3049 sizeof(psoc_objmgr->wlan_vdev_id_map)); 3050 3051 wlan_objmgr_for_each_psoc_pdev(psoc, index, pdev) { 3052 obj_mgr_debug("wlan_pdev_list[%d]: %pK", index, pdev); 3053 wlan_print_pdev_info(pdev); 3054 } 3055 3056 wlan_objmgr_for_each_psoc_vdev(psoc, index, vdev) { 3057 obj_mgr_debug("wlan_vdev_list[%d]: %pK", index, vdev); 3058 wlan_print_vdev_info(vdev); 3059 } 3060 } 3061 3062 qdf_export_symbol(wlan_print_psoc_info); 3063 #endif 3064