1 /* 2 * Copyright (c) 2016-2020 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 /** 19 * DOC: Public APIs to perform operations on Global objects 20 */ 21 #include <wlan_objmgr_cmn.h> 22 #include <wlan_objmgr_global_obj.h> 23 #include <wlan_objmgr_psoc_obj.h> 24 #include <wlan_objmgr_pdev_obj.h> 25 #include <wlan_objmgr_vdev_obj.h> 26 #include <wlan_objmgr_peer_obj.h> 27 #include <wlan_objmgr_debug.h> 28 #include <qdf_mem.h> 29 #include <qdf_module.h> 30 #include "wlan_objmgr_global_obj_i.h" 31 #include "wlan_objmgr_psoc_obj_i.h" 32 #include "wlan_objmgr_pdev_obj_i.h" 33 #include <wlan_utility.h> 34 35 /** 36 ** APIs to Create/Delete Global object APIs 37 */ 38 static QDF_STATUS wlan_objmgr_pdev_object_status( 39 struct wlan_objmgr_pdev *pdev) 40 { 41 uint8_t id; 42 QDF_STATUS status = QDF_STATUS_SUCCESS; 43 44 wlan_pdev_obj_lock(pdev); 45 /* Iterate through all components to derive the object status */ 46 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 47 /* If component disabled, Ignore */ 48 if (pdev->obj_status[id] == QDF_STATUS_COMP_DISABLED) { 49 continue; 50 /* If component operates in Async, status is Partially created, 51 break */ 52 } else if (pdev->obj_status[id] == QDF_STATUS_COMP_ASYNC) { 53 if (!pdev->pdev_comp_priv_obj[id]) { 54 status = QDF_STATUS_COMP_ASYNC; 55 break; 56 } 57 /* If component failed to allocate its object, treat it as 58 failure, complete object need to be cleaned up */ 59 } else if ((pdev->obj_status[id] == QDF_STATUS_E_NOMEM) || 60 (pdev->obj_status[id] == QDF_STATUS_E_FAILURE)) { 61 status = QDF_STATUS_E_FAILURE; 62 break; 63 } 64 } 65 wlan_pdev_obj_unlock(pdev); 66 return status; 67 } 68 69 static QDF_STATUS wlan_objmgr_pdev_obj_free(struct wlan_objmgr_pdev *pdev) 70 { 71 72 uint8_t pdev_id; 73 74 if (!pdev) { 75 obj_mgr_err("pdev obj is NULL"); 76 QDF_ASSERT(0); 77 return QDF_STATUS_E_FAILURE; 78 } 79 80 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 81 82 /* Detach PDEV from PSOC PDEV's list */ 83 if (wlan_objmgr_psoc_pdev_detach(pdev->pdev_objmgr.wlan_psoc, pdev) == 84 QDF_STATUS_E_FAILURE) { 85 obj_mgr_err("PSOC PDEV detach failed: pdev-id: %d", pdev_id); 86 return QDF_STATUS_E_FAILURE; 87 } 88 qdf_spinlock_destroy(&pdev->pdev_lock); 89 qdf_mem_free(pdev); 90 91 return QDF_STATUS_SUCCESS; 92 } 93 94 struct wlan_objmgr_pdev *wlan_objmgr_pdev_obj_create( 95 struct wlan_objmgr_psoc *psoc, 96 struct pdev_osif_priv *osdev_priv) 97 { 98 struct wlan_objmgr_pdev *pdev; 99 uint8_t id; 100 wlan_objmgr_pdev_create_handler handler; 101 wlan_objmgr_pdev_status_handler s_handler; 102 void *arg; 103 QDF_STATUS obj_status; 104 105 if (!psoc) { 106 obj_mgr_err("psoc is NULL"); 107 return NULL; 108 } 109 /* Allocate PDEV object's memory */ 110 pdev = qdf_mem_malloc(sizeof(*pdev)); 111 if (!pdev) 112 return NULL; 113 114 pdev->obj_state = WLAN_OBJ_STATE_ALLOCATED; 115 /* Initialize PDEV spinlock */ 116 qdf_spinlock_create(&pdev->pdev_lock); 117 /* Attach PDEV with PSOC */ 118 if (wlan_objmgr_psoc_pdev_attach(psoc, pdev) 119 != QDF_STATUS_SUCCESS) { 120 obj_mgr_err("pdev psoc attach failed"); 121 qdf_spinlock_destroy(&pdev->pdev_lock); 122 qdf_mem_free(pdev); 123 return NULL; 124 } 125 wlan_minidump_log(pdev, sizeof(*pdev), psoc, 126 WLAN_MD_OBJMGR_PDEV, "wlan_objmgr_pdev"); 127 /* Save PSOC object pointer in PDEV */ 128 wlan_pdev_set_psoc(pdev, psoc); 129 /* Initialize PDEV's VDEV list, assign default values */ 130 qdf_list_create(&pdev->pdev_objmgr.wlan_vdev_list, 131 WLAN_UMAC_PDEV_MAX_VDEVS); 132 pdev->pdev_objmgr.wlan_vdev_count = 0; 133 pdev->pdev_objmgr.max_vdev_count = WLAN_UMAC_PDEV_MAX_VDEVS; 134 pdev->pdev_objmgr.wlan_peer_count = 0; 135 pdev->pdev_objmgr.temp_peer_count = 0; 136 pdev->pdev_objmgr.max_peer_count = wlan_psoc_get_max_peer_count(psoc); 137 /* Save HDD/OSIF pointer */ 138 pdev->pdev_nif.pdev_ospriv = osdev_priv; 139 qdf_atomic_init(&pdev->pdev_objmgr.ref_cnt); 140 pdev->pdev_objmgr.print_cnt = 0; 141 wlan_objmgr_pdev_get_ref(pdev, WLAN_OBJMGR_ID); 142 /* Invoke registered create handlers */ 143 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 144 handler = g_umac_glb_obj->pdev_create_handler[id]; 145 arg = g_umac_glb_obj->pdev_create_handler_arg[id]; 146 if (handler) 147 pdev->obj_status[id] = handler(pdev, arg); 148 else 149 pdev->obj_status[id] = QDF_STATUS_COMP_DISABLED; 150 } 151 /* Derive object status */ 152 obj_status = wlan_objmgr_pdev_object_status(pdev); 153 154 if (obj_status == QDF_STATUS_SUCCESS) { 155 /* Object status is SUCCESS, Object is created */ 156 pdev->obj_state = WLAN_OBJ_STATE_CREATED; 157 /* Invoke component registered status handlers */ 158 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 159 s_handler = g_umac_glb_obj->pdev_status_handler[id]; 160 arg = g_umac_glb_obj->pdev_status_handler_arg[id]; 161 if (s_handler) { 162 s_handler(pdev, arg, 163 QDF_STATUS_SUCCESS); 164 } 165 } 166 /* Few components operates in Asynchrous communction, Object state 167 partially created */ 168 } else if (obj_status == QDF_STATUS_COMP_ASYNC) { 169 pdev->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 170 /* Component object failed to be created, clean up the object */ 171 } else if (obj_status == QDF_STATUS_E_FAILURE) { 172 /* Clean up the psoc */ 173 obj_mgr_err("PDEV component objects allocation failed"); 174 wlan_objmgr_pdev_obj_delete(pdev); 175 return NULL; 176 } 177 178 obj_mgr_debug("Created pdev %d", pdev->pdev_objmgr.wlan_pdev_id); 179 180 return pdev; 181 } 182 qdf_export_symbol(wlan_objmgr_pdev_obj_create); 183 184 static QDF_STATUS wlan_objmgr_pdev_obj_destroy(struct wlan_objmgr_pdev *pdev) 185 { 186 uint8_t id; 187 wlan_objmgr_pdev_destroy_handler handler; 188 QDF_STATUS obj_status; 189 void *arg; 190 uint8_t pdev_id; 191 192 if (!pdev) { 193 obj_mgr_err("pdev is NULL"); 194 return QDF_STATUS_E_FAILURE; 195 } 196 wlan_objmgr_notify_destroy(pdev, WLAN_PDEV_OP); 197 198 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 199 200 wlan_print_pdev_info(pdev); 201 obj_mgr_debug("Physically deleting pdev %d", pdev_id); 202 203 if (pdev->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) { 204 obj_mgr_err("PDEV object delete is not invoked pdevid:%d objstate:%d", 205 pdev_id, pdev->obj_state); 206 WLAN_OBJMGR_BUG(0); 207 } 208 209 /* Invoke registered destroy handlers */ 210 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 211 handler = g_umac_glb_obj->pdev_destroy_handler[id]; 212 arg = g_umac_glb_obj->pdev_destroy_handler_arg[id]; 213 if (handler && 214 (pdev->obj_status[id] == QDF_STATUS_SUCCESS || 215 pdev->obj_status[id] == QDF_STATUS_COMP_ASYNC)) 216 pdev->obj_status[id] = handler(pdev, arg); 217 else 218 pdev->obj_status[id] = QDF_STATUS_COMP_DISABLED; 219 } 220 /* Derive object status */ 221 obj_status = wlan_objmgr_pdev_object_status(pdev); 222 223 if (obj_status == QDF_STATUS_E_FAILURE) { 224 obj_mgr_err("PDEV component objects destroy failed: pdev-id:%d", 225 pdev_id); 226 /* Ideally should not happen */ 227 /* This leads to memleak ??? how to handle */ 228 QDF_BUG(0); 229 return QDF_STATUS_E_FAILURE; 230 } 231 /* Deletion is in progress */ 232 if (obj_status == QDF_STATUS_COMP_ASYNC) { 233 pdev->obj_state = WLAN_OBJ_STATE_PARTIALLY_DELETED; 234 return QDF_STATUS_COMP_ASYNC; 235 } 236 237 wlan_minidump_remove(pdev); 238 /* Free PDEV object */ 239 return wlan_objmgr_pdev_obj_free(pdev); 240 } 241 242 QDF_STATUS wlan_objmgr_pdev_obj_delete(struct wlan_objmgr_pdev *pdev) 243 { 244 uint8_t print_idx; 245 246 if (!pdev) { 247 obj_mgr_err("pdev is NULL"); 248 return QDF_STATUS_E_FAILURE; 249 } 250 251 obj_mgr_debug("Logically deleting pdev %d", 252 pdev->pdev_objmgr.wlan_pdev_id); 253 254 print_idx = qdf_get_pidx(); 255 wlan_objmgr_print_ref_ids(pdev->pdev_objmgr.ref_id_dbg, 256 QDF_TRACE_LEVEL_DEBUG); 257 /* 258 * Update PDEV object state to LOGICALLY DELETED 259 * It prevents further access of this object 260 */ 261 wlan_pdev_obj_lock(pdev); 262 pdev->obj_state = WLAN_OBJ_STATE_LOGICALLY_DELETED; 263 wlan_pdev_obj_unlock(pdev); 264 wlan_objmgr_notify_log_delete(pdev, WLAN_PDEV_OP); 265 wlan_objmgr_pdev_release_ref(pdev, WLAN_OBJMGR_ID); 266 267 return QDF_STATUS_SUCCESS; 268 } 269 qdf_export_symbol(wlan_objmgr_pdev_obj_delete); 270 271 /** 272 ** APIs to attach/detach component objects 273 */ 274 QDF_STATUS wlan_objmgr_pdev_component_obj_attach( 275 struct wlan_objmgr_pdev *pdev, 276 enum wlan_umac_comp_id id, 277 void *comp_priv_obj, 278 QDF_STATUS status) 279 { 280 uint8_t i; 281 wlan_objmgr_pdev_status_handler s_hlr; 282 void *a; 283 QDF_STATUS obj_status; 284 285 /* component id is invalid */ 286 if (id >= WLAN_UMAC_MAX_COMPONENTS) { 287 obj_mgr_err("component-id %d is not supported", id); 288 return QDF_STATUS_MAXCOMP_FAIL; 289 } 290 wlan_pdev_obj_lock(pdev); 291 /* If there is a valid entry, return failure */ 292 if (pdev->pdev_comp_priv_obj[id]) { 293 obj_mgr_err("component-%d already have valid pointer", id); 294 wlan_pdev_obj_unlock(pdev); 295 return QDF_STATUS_E_FAILURE; 296 } 297 /* Save component's pointer and status */ 298 pdev->pdev_comp_priv_obj[id] = comp_priv_obj; 299 pdev->obj_status[id] = status; 300 301 wlan_pdev_obj_unlock(pdev); 302 303 if (pdev->obj_state != WLAN_OBJ_STATE_PARTIALLY_CREATED) 304 return QDF_STATUS_SUCCESS; 305 /** 306 * If PDEV object status is partially created means, this API is 307 * invoked with differnt context, this block should be executed for 308 * async components only 309 */ 310 /* Derive status */ 311 obj_status = wlan_objmgr_pdev_object_status(pdev); 312 /* STATUS_SUCCESS means, object is CREATED */ 313 if (obj_status == QDF_STATUS_SUCCESS) 314 pdev->obj_state = WLAN_OBJ_STATE_CREATED; 315 /* update state as CREATION failed, caller has to delete the 316 PDEV object */ 317 else if (obj_status == QDF_STATUS_E_FAILURE) 318 pdev->obj_state = WLAN_OBJ_STATE_CREATION_FAILED; 319 /* Notify components about the CREATION success/failure */ 320 if ((obj_status == QDF_STATUS_SUCCESS) || 321 (obj_status == QDF_STATUS_E_FAILURE)) { 322 /* nofity object status */ 323 for (i = 0; i < WLAN_UMAC_MAX_COMPONENTS; i++) { 324 s_hlr = g_umac_glb_obj->pdev_status_handler[i]; 325 a = g_umac_glb_obj->pdev_status_handler_arg[i]; 326 if (s_hlr) 327 s_hlr(pdev, a, obj_status); 328 } 329 } 330 return QDF_STATUS_SUCCESS; 331 } 332 qdf_export_symbol(wlan_objmgr_pdev_component_obj_attach); 333 334 QDF_STATUS wlan_objmgr_pdev_component_obj_detach( 335 struct wlan_objmgr_pdev *pdev, 336 enum wlan_umac_comp_id id, 337 void *comp_priv_obj) 338 { 339 QDF_STATUS obj_status; 340 341 /* component id is invalid */ 342 if (id >= WLAN_UMAC_MAX_COMPONENTS) 343 return QDF_STATUS_MAXCOMP_FAIL; 344 345 wlan_pdev_obj_lock(pdev); 346 /* If there is a invalid entry, return failure */ 347 if (pdev->pdev_comp_priv_obj[id] != comp_priv_obj) { 348 pdev->obj_status[id] = QDF_STATUS_E_FAILURE; 349 wlan_pdev_obj_unlock(pdev); 350 return QDF_STATUS_E_FAILURE; 351 } 352 /* Reset pointers to NULL, update the status*/ 353 pdev->pdev_comp_priv_obj[id] = NULL; 354 pdev->obj_status[id] = QDF_STATUS_SUCCESS; 355 wlan_pdev_obj_unlock(pdev); 356 357 /* If PDEV object status is partially destroyed means, this API is 358 invoked with differnt context, this block should be executed for async 359 components only */ 360 if ((pdev->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) || 361 (pdev->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS)) { 362 /* Derive object status */ 363 obj_status = wlan_objmgr_pdev_object_status(pdev); 364 if (obj_status == QDF_STATUS_SUCCESS) { 365 /*Update the status as Deleted, if full object 366 deletion is in progress */ 367 if (pdev->obj_state == 368 WLAN_OBJ_STATE_PARTIALLY_DELETED) 369 pdev->obj_state = WLAN_OBJ_STATE_DELETED; 370 /* Move to creation state, since this component 371 deletion alone requested */ 372 if (pdev->obj_state == 373 WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 374 pdev->obj_state = WLAN_OBJ_STATE_CREATED; 375 /* Object status is failure */ 376 } else if (obj_status == QDF_STATUS_E_FAILURE) { 377 /*Update the status as Deletion failed, if full object 378 deletion is in progress */ 379 if (pdev->obj_state == 380 WLAN_OBJ_STATE_PARTIALLY_DELETED) 381 pdev->obj_state = 382 WLAN_OBJ_STATE_DELETION_FAILED; 383 /* Move to creation state, since this component 384 deletion alone requested (do not block other 385 components)*/ 386 if (pdev->obj_state == 387 WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 388 pdev->obj_state = WLAN_OBJ_STATE_CREATED; 389 } 390 391 /* Delete pdev object */ 392 if ((obj_status == QDF_STATUS_SUCCESS) && 393 (pdev->obj_state == WLAN_OBJ_STATE_DELETED)) { 394 /* Free PDEV object */ 395 return wlan_objmgr_pdev_obj_free(pdev); 396 } 397 } 398 return QDF_STATUS_SUCCESS; 399 } 400 qdf_export_symbol(wlan_objmgr_pdev_component_obj_detach); 401 402 /** 403 ** APIs to operations on pdev objects 404 */ 405 static void wlan_objmgr_pdev_vdev_iterate_peers(struct wlan_objmgr_pdev *pdev, 406 struct wlan_objmgr_vdev *vdev, 407 wlan_objmgr_pdev_op_handler handler, 408 void *arg, uint8_t lock_free_op, 409 wlan_objmgr_ref_dbgid dbg_id) 410 { 411 qdf_list_t *peer_list = NULL; 412 struct wlan_objmgr_peer *peer = NULL; 413 struct wlan_objmgr_peer *peer_next = NULL; 414 415 /* Iterating through vdev's peer list, so lock is 416 needed */ 417 /* Get peer list of the vdev */ 418 peer_list = &vdev->vdev_objmgr.wlan_peer_list; 419 if (peer_list) { 420 peer = wlan_vdev_peer_list_peek_active_head(vdev, peer_list, 421 dbg_id); 422 while (peer) { 423 /* Invoke the handler */ 424 handler(pdev, (void *)peer, arg); 425 /* Get next peer pointer, increments the ref count */ 426 peer_next = wlan_peer_get_next_active_peer_of_vdev(vdev, 427 peer_list, peer, dbg_id); 428 wlan_objmgr_peer_release_ref(peer, dbg_id); 429 peer = peer_next; 430 } 431 } 432 } 433 434 QDF_STATUS wlan_objmgr_pdev_iterate_obj_list( 435 struct wlan_objmgr_pdev *pdev, 436 enum wlan_objmgr_obj_type obj_type, 437 wlan_objmgr_pdev_op_handler handler, 438 void *arg, uint8_t lock_free_op, 439 wlan_objmgr_ref_dbgid dbg_id) 440 { 441 struct wlan_objmgr_pdev_objmgr *objmgr = &pdev->pdev_objmgr; 442 qdf_list_t *vdev_list = NULL; 443 struct wlan_objmgr_vdev *vdev = NULL; 444 struct wlan_objmgr_vdev *vdev_next = NULL; 445 446 /* VDEV list */ 447 vdev_list = &objmgr->wlan_vdev_list; 448 449 switch (obj_type) { 450 case WLAN_VDEV_OP: 451 /* Iterate through all VDEV object, and invoke handler for each 452 VDEV object */ 453 vdev = wlan_pdev_vdev_list_peek_active_head(pdev, vdev_list, 454 dbg_id); 455 while (vdev) { 456 handler(pdev, (void *)vdev, arg); 457 /* Get next vdev, it increments ref of next vdev */ 458 vdev_next = wlan_vdev_get_next_active_vdev_of_pdev( 459 pdev, vdev_list, vdev, dbg_id); 460 wlan_objmgr_vdev_release_ref(vdev, dbg_id); 461 vdev = vdev_next; 462 } 463 break; 464 case WLAN_PEER_OP: 465 vdev = wlan_pdev_vdev_list_peek_active_head(pdev, vdev_list, 466 dbg_id); 467 while (vdev) { 468 wlan_objmgr_pdev_vdev_iterate_peers(pdev, vdev, handler, 469 arg, lock_free_op, dbg_id); 470 /* Get next vdev, it increments ref of next vdev */ 471 vdev_next = wlan_vdev_get_next_active_vdev_of_pdev( 472 pdev, vdev_list, vdev, dbg_id); 473 wlan_objmgr_vdev_release_ref(vdev, dbg_id); 474 vdev = vdev_next; 475 } 476 break; 477 default: 478 break; 479 } 480 481 return QDF_STATUS_SUCCESS; 482 } 483 qdf_export_symbol(wlan_objmgr_pdev_iterate_obj_list); 484 485 QDF_STATUS wlan_objmgr_trigger_pdev_comp_priv_object_creation( 486 struct wlan_objmgr_pdev *pdev, 487 enum wlan_umac_comp_id id) 488 { 489 wlan_objmgr_pdev_create_handler handler; 490 void *arg; 491 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 492 493 /* Component id is invalid */ 494 if (id >= WLAN_UMAC_MAX_COMPONENTS) 495 return QDF_STATUS_MAXCOMP_FAIL; 496 497 wlan_pdev_obj_lock(pdev); 498 /* If component object is already created, delete old 499 component object, then invoke creation */ 500 if (pdev->pdev_comp_priv_obj[id]) { 501 wlan_pdev_obj_unlock(pdev); 502 return QDF_STATUS_E_FAILURE; 503 } 504 wlan_pdev_obj_unlock(pdev); 505 506 /* Invoke registered create handlers */ 507 handler = g_umac_glb_obj->pdev_create_handler[id]; 508 arg = g_umac_glb_obj->pdev_create_handler_arg[id]; 509 if (handler) 510 pdev->obj_status[id] = handler(pdev, arg); 511 else 512 return QDF_STATUS_E_FAILURE; 513 /* If object status is created, then only handle this object status */ 514 if (pdev->obj_state == WLAN_OBJ_STATE_CREATED) { 515 /* Derive object status */ 516 obj_status = wlan_objmgr_pdev_object_status(pdev); 517 /* Move PDEV object state to Partially created state */ 518 if (obj_status == QDF_STATUS_COMP_ASYNC) { 519 /*TODO atomic */ 520 pdev->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 521 } 522 } 523 return obj_status; 524 } 525 526 QDF_STATUS wlan_objmgr_trigger_pdev_comp_priv_object_deletion( 527 struct wlan_objmgr_pdev *pdev, 528 enum wlan_umac_comp_id id) 529 { 530 wlan_objmgr_pdev_destroy_handler handler; 531 void *arg; 532 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 533 534 /* component id is invalid */ 535 if (id >= WLAN_UMAC_MAX_COMPONENTS) 536 return QDF_STATUS_MAXCOMP_FAIL; 537 538 wlan_pdev_obj_lock(pdev); 539 /* Component object was never created, invalid operation */ 540 if (!pdev->pdev_comp_priv_obj[id]) { 541 wlan_pdev_obj_unlock(pdev); 542 return QDF_STATUS_E_FAILURE; 543 } 544 wlan_pdev_obj_unlock(pdev); 545 546 /* Invoke registered create handlers */ 547 handler = g_umac_glb_obj->pdev_destroy_handler[id]; 548 arg = g_umac_glb_obj->pdev_destroy_handler_arg[id]; 549 if (handler) 550 pdev->obj_status[id] = handler(pdev, arg); 551 else 552 return QDF_STATUS_E_FAILURE; 553 554 /* If object status is created, then only handle this object status */ 555 if (pdev->obj_state == WLAN_OBJ_STATE_CREATED) { 556 obj_status = wlan_objmgr_pdev_object_status(pdev); 557 /* move object state to DEL progress */ 558 if (obj_status == QDF_STATUS_COMP_ASYNC) 559 pdev->obj_state = WLAN_OBJ_STATE_COMP_DEL_PROGRESS; 560 } 561 return obj_status; 562 } 563 564 static void wlan_obj_pdev_vdevlist_add_tail(qdf_list_t *obj_list, 565 struct wlan_objmgr_vdev *obj) 566 { 567 qdf_list_insert_back(obj_list, &obj->vdev_node); 568 } 569 570 static QDF_STATUS wlan_obj_pdev_vdevlist_remove_vdev( 571 qdf_list_t *obj_list, 572 struct wlan_objmgr_vdev *vdev) 573 { 574 qdf_list_node_t *vdev_node = NULL; 575 576 if (!vdev) 577 return QDF_STATUS_E_FAILURE; 578 /* get vdev list node element */ 579 vdev_node = &vdev->vdev_node; 580 /* list is empty, return failure */ 581 if (qdf_list_remove_node(obj_list, vdev_node) != QDF_STATUS_SUCCESS) 582 return QDF_STATUS_E_FAILURE; 583 584 return QDF_STATUS_SUCCESS; 585 } 586 587 QDF_STATUS wlan_objmgr_pdev_vdev_attach(struct wlan_objmgr_pdev *pdev, 588 struct wlan_objmgr_vdev *vdev) 589 { 590 struct wlan_objmgr_pdev_objmgr *objmgr = &pdev->pdev_objmgr; 591 592 wlan_pdev_obj_lock(pdev); 593 /* If Max vdev count exceeds, return failure */ 594 if (objmgr->wlan_vdev_count >= objmgr->max_vdev_count) { 595 wlan_pdev_obj_unlock(pdev); 596 return QDF_STATUS_E_FAILURE; 597 } 598 /* Add vdev to pdev's vdev list */ 599 wlan_obj_pdev_vdevlist_add_tail(&objmgr->wlan_vdev_list, vdev); 600 /* Increment pdev ref count to make sure it won't be destroyed before */ 601 wlan_objmgr_pdev_get_ref(pdev, WLAN_OBJMGR_ID); 602 /* Increment vdev count of pdev */ 603 objmgr->wlan_vdev_count++; 604 wlan_pdev_obj_unlock(pdev); 605 606 return QDF_STATUS_SUCCESS; 607 } 608 609 QDF_STATUS wlan_objmgr_pdev_vdev_detach(struct wlan_objmgr_pdev *pdev, 610 struct wlan_objmgr_vdev *vdev) 611 { 612 struct wlan_objmgr_pdev_objmgr *objmgr = &pdev->pdev_objmgr; 613 614 wlan_pdev_obj_lock(pdev); 615 /* if vdev count is 0, return failure */ 616 if (objmgr->wlan_vdev_count == 0) { 617 wlan_pdev_obj_unlock(pdev); 618 return QDF_STATUS_E_FAILURE; 619 } 620 /* remove vdev from pdev's vdev list */ 621 wlan_obj_pdev_vdevlist_remove_vdev(&objmgr->wlan_vdev_list, vdev); 622 /* decrement vdev count */ 623 objmgr->wlan_vdev_count--; 624 wlan_pdev_obj_unlock(pdev); 625 /* Decrement pdev ref count since vdev is releasing reference */ 626 wlan_objmgr_pdev_release_ref(pdev, WLAN_OBJMGR_ID); 627 return QDF_STATUS_SUCCESS; 628 } 629 630 void *wlan_objmgr_pdev_get_comp_private_obj( 631 struct wlan_objmgr_pdev *pdev, 632 enum wlan_umac_comp_id id) 633 { 634 void *comp_priv_obj; 635 636 /* component id is invalid */ 637 if (id >= WLAN_UMAC_MAX_COMPONENTS) { 638 QDF_BUG(0); 639 return NULL; 640 } 641 642 if (!pdev) { 643 QDF_BUG(0); 644 return NULL; 645 } 646 647 comp_priv_obj = pdev->pdev_comp_priv_obj[id]; 648 649 return comp_priv_obj; 650 } 651 652 qdf_export_symbol(wlan_objmgr_pdev_get_comp_private_obj); 653 654 void wlan_objmgr_pdev_get_ref(struct wlan_objmgr_pdev *pdev, 655 wlan_objmgr_ref_dbgid id) 656 { 657 if (!pdev) { 658 obj_mgr_err("pdev obj is NULL"); 659 QDF_ASSERT(0); 660 return; 661 } 662 qdf_atomic_inc(&pdev->pdev_objmgr.ref_cnt); 663 qdf_atomic_inc(&pdev->pdev_objmgr.ref_id_dbg[id]); 664 } 665 666 qdf_export_symbol(wlan_objmgr_pdev_get_ref); 667 668 QDF_STATUS wlan_objmgr_pdev_try_get_ref(struct wlan_objmgr_pdev *pdev, 669 wlan_objmgr_ref_dbgid id) 670 { 671 uint8_t pdev_id; 672 673 if (!pdev) { 674 obj_mgr_err("pdev obj is NULL"); 675 QDF_ASSERT(0); 676 return QDF_STATUS_E_FAILURE; 677 } 678 679 wlan_pdev_obj_lock(pdev); 680 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 681 if (pdev->obj_state != WLAN_OBJ_STATE_CREATED) { 682 wlan_pdev_obj_unlock(pdev); 683 if (pdev->pdev_objmgr.print_cnt++ <= 684 WLAN_OBJMGR_RATELIMIT_THRESH) 685 obj_mgr_err( 686 "[Ref id: %d] pdev [%d] is not in Created(st:%d)", 687 id, pdev_id, pdev->obj_state); 688 return QDF_STATUS_E_RESOURCES; 689 } 690 691 wlan_objmgr_pdev_get_ref(pdev, id); 692 wlan_pdev_obj_unlock(pdev); 693 694 return QDF_STATUS_SUCCESS; 695 } 696 697 qdf_export_symbol(wlan_objmgr_pdev_try_get_ref); 698 699 void wlan_objmgr_pdev_release_ref(struct wlan_objmgr_pdev *pdev, 700 wlan_objmgr_ref_dbgid id) 701 { 702 uint8_t pdev_id; 703 704 if (!pdev) { 705 obj_mgr_err("pdev obj is NULL"); 706 QDF_ASSERT(0); 707 return; 708 } 709 710 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 711 712 if (!qdf_atomic_read(&pdev->pdev_objmgr.ref_id_dbg[id])) { 713 obj_mgr_err("pdev (id:%d)ref cnt was not taken by %d", 714 pdev_id, id); 715 wlan_objmgr_print_ref_ids(pdev->pdev_objmgr.ref_id_dbg, 716 QDF_TRACE_LEVEL_FATAL); 717 WLAN_OBJMGR_BUG(0); 718 return; 719 } 720 721 if (!qdf_atomic_read(&pdev->pdev_objmgr.ref_cnt)) { 722 obj_mgr_err("pdev ref cnt is 0: pdev-id:%d", pdev_id); 723 WLAN_OBJMGR_BUG(0); 724 return; 725 } 726 727 qdf_atomic_dec(&pdev->pdev_objmgr.ref_id_dbg[id]); 728 /* Decrement ref count, free pdev, if ref count == 0 */ 729 if (qdf_atomic_dec_and_test(&pdev->pdev_objmgr.ref_cnt)) 730 wlan_objmgr_pdev_obj_destroy(pdev); 731 } 732 733 qdf_export_symbol(wlan_objmgr_pdev_release_ref); 734 735 #ifdef WLAN_OBJMGR_REF_ID_TRACE 736 struct wlan_objmgr_vdev *wlan_objmgr_pdev_get_first_vdev_debug( 737 struct wlan_objmgr_pdev *pdev, 738 wlan_objmgr_ref_dbgid dbg_id, 739 const char *func, int line) 740 { 741 struct wlan_objmgr_pdev_objmgr *objmgr = &pdev->pdev_objmgr; 742 qdf_list_t *vdev_list = NULL; 743 struct wlan_objmgr_vdev *vdev; 744 qdf_list_node_t *node = NULL; 745 qdf_list_node_t *prev_node = NULL; 746 747 wlan_pdev_obj_lock(pdev); 748 749 /* VDEV list */ 750 vdev_list = &objmgr->wlan_vdev_list; 751 if (qdf_list_peek_front(vdev_list, &node) != QDF_STATUS_SUCCESS) { 752 wlan_pdev_obj_unlock(pdev); 753 return NULL; 754 } 755 756 do { 757 vdev = qdf_container_of(node, struct wlan_objmgr_vdev, 758 vdev_node); 759 if (wlan_objmgr_vdev_try_get_ref_debug(vdev, 760 dbg_id, func, line) == 761 QDF_STATUS_SUCCESS) { 762 wlan_pdev_obj_unlock(pdev); 763 return vdev; 764 } 765 766 prev_node = node; 767 } while (qdf_list_peek_next(vdev_list, prev_node, &node) == 768 QDF_STATUS_SUCCESS); 769 770 wlan_pdev_obj_unlock(pdev); 771 772 return NULL; 773 } 774 775 qdf_export_symbol(wlan_objmgr_pdev_get_first_vdev_debug); 776 #else 777 struct wlan_objmgr_vdev *wlan_objmgr_pdev_get_first_vdev( 778 struct wlan_objmgr_pdev *pdev, 779 wlan_objmgr_ref_dbgid dbg_id) 780 { 781 struct wlan_objmgr_pdev_objmgr *objmgr = &pdev->pdev_objmgr; 782 qdf_list_t *vdev_list = NULL; 783 struct wlan_objmgr_vdev *vdev; 784 qdf_list_node_t *node = NULL; 785 qdf_list_node_t *prev_node = NULL; 786 787 wlan_pdev_obj_lock(pdev); 788 789 /* VDEV list */ 790 vdev_list = &objmgr->wlan_vdev_list; 791 if (qdf_list_peek_front(vdev_list, &node) != QDF_STATUS_SUCCESS) { 792 wlan_pdev_obj_unlock(pdev); 793 return NULL; 794 } 795 796 do { 797 vdev = qdf_container_of(node, struct wlan_objmgr_vdev, 798 vdev_node); 799 if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) == 800 QDF_STATUS_SUCCESS) { 801 wlan_pdev_obj_unlock(pdev); 802 return vdev; 803 } 804 805 prev_node = node; 806 } while (qdf_list_peek_next(vdev_list, prev_node, &node) == 807 QDF_STATUS_SUCCESS); 808 809 wlan_pdev_obj_unlock(pdev); 810 811 return NULL; 812 } 813 814 qdf_export_symbol(wlan_objmgr_pdev_get_first_vdev); 815 #endif 816 817 #ifdef WLAN_OBJMGR_REF_ID_TRACE 818 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_pdev_debug( 819 struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 820 wlan_objmgr_ref_dbgid dbg_id, 821 const char *func, int line) 822 { 823 struct wlan_objmgr_vdev *vdev; 824 struct wlan_objmgr_vdev *vdev_next; 825 struct wlan_objmgr_pdev_objmgr *objmgr; 826 qdf_list_t *vdev_list; 827 828 wlan_pdev_obj_lock(pdev); 829 830 objmgr = &pdev->pdev_objmgr; 831 vdev_list = &objmgr->wlan_vdev_list; 832 /* Get first vdev */ 833 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 834 /** 835 * Iterate through pdev's vdev list, till vdev id matches with 836 * entry of vdev list 837 */ 838 while (vdev) { 839 if (wlan_vdev_get_id(vdev) == vdev_id) { 840 if (wlan_objmgr_vdev_try_get_ref_debug(vdev, dbg_id, 841 func, line) != 842 QDF_STATUS_SUCCESS) 843 vdev = NULL; 844 845 wlan_pdev_obj_unlock(pdev); 846 return vdev; 847 } 848 /* get next vdev */ 849 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 850 vdev = vdev_next; 851 } 852 wlan_pdev_obj_unlock(pdev); 853 return NULL; 854 } 855 856 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_pdev_debug); 857 #else 858 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_pdev( 859 struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 860 wlan_objmgr_ref_dbgid dbg_id) 861 { 862 struct wlan_objmgr_vdev *vdev; 863 struct wlan_objmgr_vdev *vdev_next; 864 struct wlan_objmgr_pdev_objmgr *objmgr; 865 qdf_list_t *vdev_list; 866 867 wlan_pdev_obj_lock(pdev); 868 869 objmgr = &pdev->pdev_objmgr; 870 vdev_list = &objmgr->wlan_vdev_list; 871 /* Get first vdev */ 872 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 873 /** 874 * Iterate through pdev's vdev list, till vdev id matches with 875 * entry of vdev list 876 */ 877 while (vdev) { 878 if (wlan_vdev_get_id(vdev) == vdev_id) { 879 if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) != 880 QDF_STATUS_SUCCESS) 881 vdev = NULL; 882 883 wlan_pdev_obj_unlock(pdev); 884 return vdev; 885 } 886 /* get next vdev */ 887 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 888 vdev = vdev_next; 889 } 890 wlan_pdev_obj_unlock(pdev); 891 return NULL; 892 } 893 894 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_pdev); 895 #endif 896 897 #ifdef WLAN_OBJMGR_REF_ID_TRACE 898 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_pdev_no_state_debug( 899 struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 900 wlan_objmgr_ref_dbgid dbg_id, 901 const char *func, int line) 902 { 903 struct wlan_objmgr_vdev *vdev; 904 struct wlan_objmgr_vdev *vdev_next; 905 struct wlan_objmgr_pdev_objmgr *objmgr; 906 qdf_list_t *vdev_list; 907 908 wlan_pdev_obj_lock(pdev); 909 910 objmgr = &pdev->pdev_objmgr; 911 vdev_list = &objmgr->wlan_vdev_list; 912 /* Get first vdev */ 913 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 914 /** 915 * Iterate through pdev's vdev list, till vdev id matches with 916 * entry of vdev list 917 */ 918 while (vdev) { 919 if (wlan_vdev_get_id(vdev) == vdev_id) { 920 wlan_objmgr_vdev_get_ref_debug(vdev, dbg_id, 921 func, line); 922 wlan_pdev_obj_unlock(pdev); 923 924 return vdev; 925 } 926 /* get next vdev */ 927 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 928 vdev = vdev_next; 929 } 930 wlan_pdev_obj_unlock(pdev); 931 932 return NULL; 933 } 934 935 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_pdev_no_state_debug); 936 #else 937 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_pdev_no_state( 938 struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 939 wlan_objmgr_ref_dbgid dbg_id) 940 { 941 struct wlan_objmgr_vdev *vdev; 942 struct wlan_objmgr_vdev *vdev_next; 943 struct wlan_objmgr_pdev_objmgr *objmgr; 944 qdf_list_t *vdev_list; 945 946 wlan_pdev_obj_lock(pdev); 947 948 objmgr = &pdev->pdev_objmgr; 949 vdev_list = &objmgr->wlan_vdev_list; 950 /* Get first vdev */ 951 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 952 /** 953 * Iterate through pdev's vdev list, till vdev id matches with 954 * entry of vdev list 955 */ 956 while (vdev) { 957 if (wlan_vdev_get_id(vdev) == vdev_id) { 958 wlan_objmgr_vdev_get_ref(vdev, dbg_id); 959 wlan_pdev_obj_unlock(pdev); 960 961 return vdev; 962 } 963 /* get next vdev */ 964 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 965 vdev = vdev_next; 966 } 967 wlan_pdev_obj_unlock(pdev); 968 969 return NULL; 970 } 971 972 qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_pdev_no_state); 973 #endif 974 975 #ifdef WLAN_OBJMGR_REF_ID_TRACE 976 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_pdev_debug( 977 struct wlan_objmgr_pdev *pdev, uint8_t *macaddr, 978 wlan_objmgr_ref_dbgid dbg_id, 979 const char *fnc, int ln) 980 { 981 struct wlan_objmgr_vdev *vdev; 982 struct wlan_objmgr_vdev *vdev_next; 983 struct wlan_objmgr_pdev_objmgr *objmgr; 984 qdf_list_t *vdev_list; 985 986 wlan_pdev_obj_lock(pdev); 987 objmgr = &pdev->pdev_objmgr; 988 vdev_list = &objmgr->wlan_vdev_list; 989 /* Get first vdev */ 990 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 991 /** 992 * Iterate through pdev's vdev list, till vdev macaddr matches with 993 * entry of vdev list 994 */ 995 while (vdev) { 996 if (QDF_IS_STATUS_SUCCESS( 997 WLAN_ADDR_EQ(wlan_vdev_mlme_get_macaddr(vdev), macaddr))) { 998 if (QDF_IS_STATUS_SUCCESS( 999 wlan_objmgr_vdev_try_get_ref_debug(vdev, dbg_id, 1000 fnc, ln))) { 1001 wlan_pdev_obj_unlock(pdev); 1002 return vdev; 1003 } 1004 } 1005 /* get next vdev */ 1006 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 1007 vdev = vdev_next; 1008 } 1009 wlan_pdev_obj_unlock(pdev); 1010 1011 return NULL; 1012 } 1013 #else 1014 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_pdev( 1015 struct wlan_objmgr_pdev *pdev, uint8_t *macaddr, 1016 wlan_objmgr_ref_dbgid dbg_id) 1017 { 1018 struct wlan_objmgr_vdev *vdev; 1019 struct wlan_objmgr_vdev *vdev_next; 1020 struct wlan_objmgr_pdev_objmgr *objmgr; 1021 qdf_list_t *vdev_list; 1022 1023 wlan_pdev_obj_lock(pdev); 1024 objmgr = &pdev->pdev_objmgr; 1025 vdev_list = &objmgr->wlan_vdev_list; 1026 /* Get first vdev */ 1027 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 1028 /** 1029 * Iterate through pdev's vdev list, till vdev macaddr matches with 1030 * entry of vdev list 1031 */ 1032 while (vdev) { 1033 if (QDF_IS_STATUS_SUCCESS( 1034 WLAN_ADDR_EQ(wlan_vdev_mlme_get_macaddr(vdev), macaddr))) { 1035 if (QDF_IS_STATUS_SUCCESS( 1036 wlan_objmgr_vdev_try_get_ref(vdev, dbg_id))) { 1037 wlan_pdev_obj_unlock(pdev); 1038 return vdev; 1039 } 1040 } 1041 /* get next vdev */ 1042 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 1043 vdev = vdev_next; 1044 } 1045 wlan_pdev_obj_unlock(pdev); 1046 1047 return NULL; 1048 } 1049 #endif 1050 1051 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1052 struct wlan_objmgr_vdev 1053 *wlan_objmgr_get_vdev_by_macaddr_from_pdev_no_state_debug( 1054 struct wlan_objmgr_pdev *pdev, uint8_t *macaddr, 1055 wlan_objmgr_ref_dbgid dbg_id, 1056 const char *func, int line) 1057 { 1058 struct wlan_objmgr_vdev *vdev; 1059 struct wlan_objmgr_vdev *vdev_next; 1060 struct wlan_objmgr_pdev_objmgr *objmgr; 1061 qdf_list_t *vdev_list; 1062 1063 wlan_pdev_obj_lock(pdev); 1064 objmgr = &pdev->pdev_objmgr; 1065 vdev_list = &objmgr->wlan_vdev_list; 1066 /* Get first vdev */ 1067 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 1068 /** 1069 * Iterate through pdev's vdev list, till vdev macaddr matches with 1070 * entry of vdev list 1071 */ 1072 while (vdev) { 1073 if (WLAN_ADDR_EQ(wlan_vdev_mlme_get_macaddr(vdev), macaddr) 1074 == QDF_STATUS_SUCCESS) { 1075 wlan_objmgr_vdev_get_ref_debug(vdev, dbg_id, 1076 func, line); 1077 wlan_pdev_obj_unlock(pdev); 1078 1079 return vdev; 1080 } 1081 /* get next vdev */ 1082 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 1083 vdev = vdev_next; 1084 } 1085 wlan_pdev_obj_unlock(pdev); 1086 1087 return NULL; 1088 } 1089 #else 1090 struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_pdev_no_state( 1091 struct wlan_objmgr_pdev *pdev, uint8_t *macaddr, 1092 wlan_objmgr_ref_dbgid dbg_id) 1093 { 1094 struct wlan_objmgr_vdev *vdev; 1095 struct wlan_objmgr_vdev *vdev_next; 1096 struct wlan_objmgr_pdev_objmgr *objmgr; 1097 qdf_list_t *vdev_list; 1098 1099 wlan_pdev_obj_lock(pdev); 1100 objmgr = &pdev->pdev_objmgr; 1101 vdev_list = &objmgr->wlan_vdev_list; 1102 /* Get first vdev */ 1103 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 1104 /** 1105 * Iterate through pdev's vdev list, till vdev macaddr matches with 1106 * entry of vdev list 1107 */ 1108 while (vdev) { 1109 if (WLAN_ADDR_EQ(wlan_vdev_mlme_get_macaddr(vdev), macaddr) 1110 == QDF_STATUS_SUCCESS) { 1111 wlan_objmgr_vdev_get_ref(vdev, dbg_id); 1112 wlan_pdev_obj_unlock(pdev); 1113 1114 return vdev; 1115 } 1116 /* get next vdev */ 1117 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 1118 vdev = vdev_next; 1119 } 1120 wlan_pdev_obj_unlock(pdev); 1121 1122 return NULL; 1123 } 1124 #endif 1125 1126 #ifdef WLAN_OBJMGR_DEBUG 1127 void wlan_print_pdev_info(struct wlan_objmgr_pdev *pdev) 1128 { 1129 struct wlan_objmgr_pdev_objmgr *pdev_objmgr; 1130 struct wlan_objmgr_vdev *vdev; 1131 struct wlan_objmgr_vdev *vdev_next; 1132 qdf_list_t *vdev_list; 1133 uint16_t index = 0; 1134 1135 pdev_objmgr = &pdev->pdev_objmgr; 1136 1137 obj_mgr_debug("pdev: %pK", pdev); 1138 obj_mgr_debug("wlan_pdev_id: %d", pdev_objmgr->wlan_pdev_id); 1139 obj_mgr_debug("wlan_vdev_count: %d", pdev_objmgr->wlan_vdev_count); 1140 obj_mgr_debug("max_vdev_count: %d", pdev_objmgr->max_vdev_count); 1141 obj_mgr_debug("wlan_peer_count: %d", pdev_objmgr->wlan_peer_count); 1142 obj_mgr_debug("max_peer_count: %d", pdev_objmgr->max_peer_count); 1143 obj_mgr_debug("temp_peer_count: %d", pdev_objmgr->temp_peer_count); 1144 obj_mgr_debug("wlan_psoc: %pK", pdev_objmgr->wlan_psoc); 1145 obj_mgr_debug("ref_cnt: %d", qdf_atomic_read(&pdev_objmgr->ref_cnt)); 1146 1147 wlan_pdev_obj_lock(pdev); 1148 vdev_list = &pdev_objmgr->wlan_vdev_list; 1149 /* Get first vdev */ 1150 vdev = wlan_pdev_vdev_list_peek_head(vdev_list); 1151 1152 while (vdev) { 1153 obj_mgr_debug("wlan_vdev_list[%d]: %pK", index, vdev); 1154 wlan_print_vdev_info(vdev); 1155 index++; 1156 /* get next vdev */ 1157 vdev_next = wlan_vdev_get_next_vdev_of_pdev(vdev_list, vdev); 1158 vdev = vdev_next; 1159 } 1160 wlan_pdev_obj_unlock(pdev); 1161 } 1162 1163 qdf_export_symbol(wlan_print_pdev_info); 1164 #endif 1165