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