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