Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1 | /* |
Madhvapathi Sriram | b73fc28 | 2019-01-07 09:12:25 +0530 | [diff] [blame] | 2 | * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved. |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 3 | * |
| 4 | * Permission to use, copy, modify, and/or distribute this software for |
| 5 | * any purpose with or without fee is hereby granted, provided that the |
| 6 | * above copyright notice and this permission notice appear in all |
| 7 | * copies. |
| 8 | * |
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| 10 | * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| 11 | * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| 12 | * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| 13 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| 14 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 15 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 16 | * PERFORMANCE OF THIS SOFTWARE. |
| 17 | */ |
| 18 | /** |
| 19 | * DOC: Public APIs to perform operations on Global objects |
| 20 | */ |
| 21 | |
| 22 | #include <wlan_objmgr_cmn.h> |
| 23 | #include <wlan_objmgr_global_obj.h> |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 24 | #include <wlan_objmgr_psoc_obj.h> |
| 25 | #include <wlan_objmgr_pdev_obj.h> |
| 26 | #include <wlan_objmgr_vdev_obj.h> |
| 27 | #include <wlan_objmgr_peer_obj.h> |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 28 | #include <qdf_mem.h> |
Amir Patel | c8d752f | 2018-02-20 11:48:32 +0530 | [diff] [blame] | 29 | #include <qdf_types.h> |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 30 | #include <qdf_module.h> |
Srinivas Pitla | 7c2f975 | 2017-01-05 13:11:40 +0530 | [diff] [blame] | 31 | #include "wlan_objmgr_global_obj_i.h" |
| 32 | #include "wlan_objmgr_psoc_obj_i.h" |
| 33 | #include "wlan_objmgr_pdev_obj_i.h" |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 34 | #include "wlan_objmgr_vdev_obj_i.h" |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 35 | |
| 36 | /** |
| 37 | ** APIs to Create/Delete Global object APIs |
| 38 | */ |
| 39 | static QDF_STATUS wlan_objmgr_psoc_object_status( |
| 40 | struct wlan_objmgr_psoc *psoc) |
| 41 | { |
| 42 | uint8_t id; |
| 43 | QDF_STATUS status = QDF_STATUS_SUCCESS; |
| 44 | |
| 45 | wlan_psoc_obj_lock(psoc); |
| 46 | /* Iterate through all components to derive the object status */ |
| 47 | for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { |
| 48 | /* If component disabled, Ignore */ |
| 49 | if (psoc->obj_status[id] == QDF_STATUS_COMP_DISABLED) |
| 50 | continue; |
| 51 | /* If component operates in Async, status is Partially created, |
Rajeev Kumar | 1ef07b9 | 2017-02-22 14:12:16 -0800 | [diff] [blame] | 52 | * break |
| 53 | */ |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 54 | else if (psoc->obj_status[id] == QDF_STATUS_COMP_ASYNC) { |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 55 | if (!psoc->soc_comp_priv_obj[id]) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 56 | status = QDF_STATUS_COMP_ASYNC; |
| 57 | break; |
| 58 | } |
| 59 | /* |
| 60 | * If component failed to allocate its object, treat it as |
| 61 | * failure, complete object need to be cleaned up |
| 62 | */ |
| 63 | } else if ((psoc->obj_status[id] == QDF_STATUS_E_NOMEM) || |
| 64 | (psoc->obj_status[id] == QDF_STATUS_E_FAILURE)) { |
| 65 | status = QDF_STATUS_E_FAILURE; |
| 66 | break; |
| 67 | } |
| 68 | } |
| 69 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 70 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 71 | return status; |
| 72 | } |
| 73 | |
| 74 | static void wlan_objmgr_psoc_peer_list_init(struct wlan_peer_list *peer_list) |
| 75 | { |
| 76 | uint8_t i; |
| 77 | |
| 78 | qdf_spinlock_create(&peer_list->peer_list_lock); |
| 79 | for (i = 0; i < WLAN_PEER_HASHSIZE; i++) |
| 80 | qdf_list_create(&peer_list->peer_hash[i], |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 81 | WLAN_UMAC_PSOC_MAX_PEERS + |
| 82 | WLAN_MAX_PSOC_TEMP_PEERS); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | static void wlan_objmgr_psoc_peer_list_deinit(struct wlan_peer_list *peer_list) |
| 86 | { |
| 87 | uint8_t i; |
| 88 | |
| 89 | /* deinit the lock */ |
| 90 | qdf_spinlock_destroy(&peer_list->peer_list_lock); |
| 91 | for (i = 0; i < WLAN_PEER_HASHSIZE; i++) |
| 92 | qdf_list_destroy(&peer_list->peer_hash[i]); |
| 93 | } |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 94 | |
| 95 | static QDF_STATUS wlan_objmgr_psoc_obj_free(struct wlan_objmgr_psoc *psoc) |
| 96 | { |
| 97 | /* Detach PSOC from global object's psoc list */ |
| 98 | if (wlan_objmgr_psoc_object_detach(psoc) == QDF_STATUS_E_FAILURE) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 99 | obj_mgr_err("PSOC object detach failed"); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 100 | return QDF_STATUS_E_FAILURE; |
| 101 | } |
| 102 | wlan_objmgr_psoc_peer_list_deinit(&psoc->soc_objmgr.peer_list); |
Vikram Kandukuri | d4aa277 | 2017-03-07 18:40:13 +0530 | [diff] [blame] | 103 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 104 | qdf_spinlock_destroy(&psoc->psoc_lock); |
| 105 | qdf_mem_free(psoc); |
| 106 | |
| 107 | return QDF_STATUS_SUCCESS; |
| 108 | } |
Rajeev Kumar | 1ef07b9 | 2017-02-22 14:12:16 -0800 | [diff] [blame] | 109 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 110 | struct wlan_objmgr_psoc *wlan_objmgr_psoc_obj_create(uint32_t phy_version, |
| 111 | WLAN_DEV_TYPE dev_type) |
| 112 | { |
| 113 | uint8_t id; |
| 114 | struct wlan_objmgr_psoc *psoc = NULL; |
| 115 | wlan_objmgr_psoc_create_handler handler; |
| 116 | wlan_objmgr_psoc_status_handler stat_handler; |
| 117 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 118 | QDF_STATUS obj_status; |
| 119 | void *arg; |
| 120 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 121 | psoc = qdf_mem_malloc(sizeof(*psoc)); |
Madhvapathi Sriram | b73fc28 | 2019-01-07 09:12:25 +0530 | [diff] [blame] | 122 | if (!psoc) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 123 | return NULL; |
Madhvapathi Sriram | b73fc28 | 2019-01-07 09:12:25 +0530 | [diff] [blame] | 124 | |
Srinivas Pitla | 86db6ab | 2018-01-16 10:20:38 +0530 | [diff] [blame] | 125 | psoc->obj_state = WLAN_OBJ_STATE_ALLOCATED; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 126 | qdf_spinlock_create(&psoc->psoc_lock); |
| 127 | /* Initialize with default values */ |
| 128 | objmgr = &psoc->soc_objmgr; |
| 129 | objmgr->wlan_pdev_count = 0; |
| 130 | objmgr->wlan_vdev_count = 0; |
| 131 | objmgr->max_vdev_count = WLAN_UMAC_PSOC_MAX_VDEVS; |
| 132 | objmgr->wlan_peer_count = 0; |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 133 | objmgr->temp_peer_count = 0; |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 134 | objmgr->max_peer_count = WLAN_UMAC_PSOC_MAX_PEERS; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 135 | qdf_atomic_init(&objmgr->ref_cnt); |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 136 | objmgr->print_cnt = 0; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 137 | /* set phy version, dev_type in psoc */ |
| 138 | wlan_psoc_set_nif_phy_version(psoc, phy_version); |
| 139 | wlan_psoc_set_dev_type(psoc, dev_type); |
| 140 | /* Initialize peer list */ |
| 141 | wlan_objmgr_psoc_peer_list_init(&objmgr->peer_list); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 142 | wlan_objmgr_psoc_get_ref(psoc, WLAN_OBJMGR_ID); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 143 | /* Invoke registered create handlers */ |
| 144 | for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { |
| 145 | handler = g_umac_glb_obj->psoc_create_handler[id]; |
| 146 | arg = g_umac_glb_obj->psoc_create_handler_arg[id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 147 | if (handler) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 148 | psoc->obj_status[id] = handler(psoc, arg); |
| 149 | else |
| 150 | psoc->obj_status[id] = QDF_STATUS_COMP_DISABLED; |
| 151 | } |
| 152 | /* Derive object status */ |
| 153 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 154 | |
| 155 | if (obj_status == QDF_STATUS_SUCCESS) { |
| 156 | /* Object status is SUCCESS, Object is created */ |
| 157 | psoc->obj_state = WLAN_OBJ_STATE_CREATED; |
| 158 | for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { |
| 159 | stat_handler = g_umac_glb_obj->psoc_status_handler[id]; |
| 160 | arg = g_umac_glb_obj->psoc_status_handler_arg[id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 161 | if (stat_handler) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 162 | stat_handler(psoc, arg, |
| 163 | QDF_STATUS_SUCCESS); |
| 164 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 165 | } else if (obj_status == QDF_STATUS_COMP_ASYNC) { |
Rajeev Kumar | 1ef07b9 | 2017-02-22 14:12:16 -0800 | [diff] [blame] | 166 | /* |
| 167 | * Few components operates in Asynchrous communction |
| 168 | * Object state partially created |
| 169 | */ |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 170 | psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 171 | } else if (obj_status == QDF_STATUS_E_FAILURE) { |
Rajeev Kumar | 1ef07b9 | 2017-02-22 14:12:16 -0800 | [diff] [blame] | 172 | /* Component object failed to be created, clean up the object */ |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 173 | obj_mgr_err("PSOC component objects allocation failed"); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 174 | /* Clean up the psoc */ |
| 175 | wlan_objmgr_psoc_obj_delete(psoc); |
| 176 | return NULL; |
| 177 | } |
| 178 | |
| 179 | if (wlan_objmgr_psoc_object_attach(psoc) != |
| 180 | QDF_STATUS_SUCCESS) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 181 | obj_mgr_err("PSOC object attach failed"); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 182 | wlan_objmgr_psoc_obj_delete(psoc); |
| 183 | return NULL; |
| 184 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 185 | |
Dustin Brown | 7229739 | 2018-01-26 15:29:04 -0800 | [diff] [blame] | 186 | obj_mgr_info("Created psoc %d", psoc->soc_objmgr.psoc_id); |
| 187 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 188 | return psoc; |
| 189 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 190 | qdf_export_symbol(wlan_objmgr_psoc_obj_create); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 191 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 192 | static QDF_STATUS wlan_objmgr_psoc_obj_destroy(struct wlan_objmgr_psoc *psoc) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 193 | { |
| 194 | uint8_t id; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 195 | wlan_objmgr_psoc_destroy_handler handler; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 196 | QDF_STATUS obj_status; |
| 197 | void *arg; |
| 198 | |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 199 | if (!psoc) { |
Vivek | 2c86b21 | 2017-06-05 00:02:11 +0530 | [diff] [blame] | 200 | obj_mgr_err("psoc is NULL"); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 201 | return QDF_STATUS_E_FAILURE; |
| 202 | } |
Amir Patel | c8d752f | 2018-02-20 11:48:32 +0530 | [diff] [blame] | 203 | wlan_objmgr_notify_destroy(psoc, WLAN_PSOC_OP); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 204 | |
Vivek | 4ad877f | 2019-09-18 16:49:10 +0530 | [diff] [blame^] | 205 | wlan_print_psoc_info(psoc); |
Dustin Brown | 7229739 | 2018-01-26 15:29:04 -0800 | [diff] [blame] | 206 | obj_mgr_info("Physically deleting psoc %d", psoc->soc_objmgr.psoc_id); |
| 207 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 208 | if (psoc->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) { |
Santosh Anbu | 4d62c9d | 2018-04-27 11:37:09 +0530 | [diff] [blame] | 209 | obj_mgr_err("PSOC object delete is not invoked obj_state:%d", |
| 210 | psoc->obj_state); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 211 | WLAN_OBJMGR_BUG(0); |
| 212 | } |
| 213 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 214 | /* Invoke registered create handlers */ |
| 215 | for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 216 | handler = g_umac_glb_obj->psoc_destroy_handler[id]; |
| 217 | arg = g_umac_glb_obj->psoc_destroy_handler_arg[id]; |
Paul Zhang | da522d8 | 2018-08-28 21:19:41 +0800 | [diff] [blame] | 218 | if (handler && |
| 219 | (psoc->obj_status[id] == QDF_STATUS_SUCCESS || |
| 220 | psoc->obj_status[id] == QDF_STATUS_COMP_ASYNC)) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 221 | psoc->obj_status[id] = handler(psoc, arg); |
| 222 | else |
| 223 | psoc->obj_status[id] = QDF_STATUS_COMP_DISABLED; |
| 224 | } |
| 225 | /* Derive object status */ |
| 226 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 227 | |
| 228 | if (obj_status == QDF_STATUS_E_FAILURE) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 229 | obj_mgr_err("PSOC component object free failed"); |
Rajeev Kumar | 1ef07b9 | 2017-02-22 14:12:16 -0800 | [diff] [blame] | 230 | /* Ideally should not happen |
| 231 | * This leads to memleak, BUG_ON to find which component |
| 232 | * delete notification failed and fix it. |
| 233 | */ |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 234 | QDF_BUG(0); |
| 235 | return QDF_STATUS_E_FAILURE; |
| 236 | } |
| 237 | /* Deletion is in progress */ |
| 238 | if (obj_status == QDF_STATUS_COMP_ASYNC) { |
| 239 | psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_DELETED; |
| 240 | return QDF_STATUS_COMP_ASYNC; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 241 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 242 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 243 | /* Free psoc object */ |
| 244 | return wlan_objmgr_psoc_obj_free(psoc); |
| 245 | } |
| 246 | |
| 247 | |
| 248 | QDF_STATUS wlan_objmgr_psoc_obj_delete(struct wlan_objmgr_psoc *psoc) |
| 249 | { |
Vivek | 1312d70 | 2017-06-12 18:57:51 +0530 | [diff] [blame] | 250 | uint8_t print_idx; |
| 251 | |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 252 | if (!psoc) { |
Vivek | 2c86b21 | 2017-06-05 00:02:11 +0530 | [diff] [blame] | 253 | obj_mgr_err("psoc is NULL"); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 254 | return QDF_STATUS_E_FAILURE; |
| 255 | } |
Vivek | 1312d70 | 2017-06-12 18:57:51 +0530 | [diff] [blame] | 256 | |
Dustin Brown | 7229739 | 2018-01-26 15:29:04 -0800 | [diff] [blame] | 257 | obj_mgr_info("Logically deleting psoc %d", psoc->soc_objmgr.psoc_id); |
Vivek | 1312d70 | 2017-06-12 18:57:51 +0530 | [diff] [blame] | 258 | |
Dustin Brown | 7229739 | 2018-01-26 15:29:04 -0800 | [diff] [blame] | 259 | print_idx = qdf_get_pidx(); |
Abhinav Kumar | 9791957 | 2018-06-15 16:46:30 +0530 | [diff] [blame] | 260 | wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, |
| 261 | QDF_TRACE_LEVEL_DEBUG); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 262 | /* |
| 263 | * Update PSOC object state to LOGICALLY DELETED |
| 264 | * It prevents further access of this object |
| 265 | */ |
| 266 | wlan_psoc_obj_lock(psoc); |
| 267 | psoc->obj_state = WLAN_OBJ_STATE_LOGICALLY_DELETED; |
| 268 | wlan_psoc_obj_unlock(psoc); |
Amir Patel | c8d752f | 2018-02-20 11:48:32 +0530 | [diff] [blame] | 269 | wlan_objmgr_notify_log_delete(psoc, WLAN_PSOC_OP); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 270 | wlan_objmgr_psoc_release_ref(psoc, WLAN_OBJMGR_ID); |
| 271 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 272 | return QDF_STATUS_SUCCESS; |
| 273 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 274 | qdf_export_symbol(wlan_objmgr_psoc_obj_delete); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 275 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 276 | QDF_STATUS wlan_objmgr_psoc_component_obj_attach( |
| 277 | struct wlan_objmgr_psoc *psoc, |
| 278 | enum wlan_umac_comp_id id, |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 279 | void *comp_priv_obj, |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 280 | QDF_STATUS status) |
| 281 | { |
| 282 | wlan_objmgr_psoc_status_handler stat_handler; |
| 283 | void *arg = NULL; |
| 284 | QDF_STATUS obj_status; |
| 285 | uint8_t i; |
| 286 | |
| 287 | /* component id is invalid */ |
| 288 | if (id >= WLAN_UMAC_MAX_COMPONENTS) |
| 289 | return QDF_STATUS_MAXCOMP_FAIL; |
| 290 | |
| 291 | wlan_psoc_obj_lock(psoc); |
| 292 | /* If there is a valid entry, return failure */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 293 | if (psoc->soc_comp_priv_obj[id]) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 294 | wlan_psoc_obj_unlock(psoc); |
| 295 | return QDF_STATUS_E_FAILURE; |
| 296 | } |
| 297 | /* Save component's pointer and status */ |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 298 | psoc->soc_comp_priv_obj[id] = comp_priv_obj; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 299 | psoc->obj_status[id] = status; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 300 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 301 | wlan_psoc_obj_unlock(psoc); |
| 302 | |
| 303 | if (psoc->obj_state != WLAN_OBJ_STATE_PARTIALLY_CREATED) |
| 304 | return QDF_STATUS_SUCCESS; |
| 305 | /* If PSOC object status is partially created means, this API is |
| 306 | * invoked with differnt context, this block should be executed for |
| 307 | * async components only |
| 308 | */ |
| 309 | /* Derive status */ |
| 310 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 311 | /* STATUS_SUCCESS means, object is CREATED */ |
| 312 | if (obj_status == QDF_STATUS_SUCCESS) |
| 313 | psoc->obj_state = WLAN_OBJ_STATE_CREATED; |
| 314 | /* update state as CREATION failed, caller has to delete the |
| 315 | * PSOC object |
| 316 | */ |
| 317 | else if (obj_status == QDF_STATUS_E_FAILURE) |
| 318 | psoc->obj_state = WLAN_OBJ_STATE_CREATION_FAILED; |
| 319 | |
| 320 | /* Notify components about the CREATION success/failure */ |
| 321 | if ((obj_status == QDF_STATUS_SUCCESS) || |
| 322 | (obj_status == QDF_STATUS_E_FAILURE)) { |
| 323 | /* nofity object status */ |
| 324 | for (i = 0; i < WLAN_UMAC_MAX_COMPONENTS; i++) { |
| 325 | stat_handler = g_umac_glb_obj->psoc_status_handler[i]; |
| 326 | arg = g_umac_glb_obj->psoc_status_handler_arg[i]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 327 | if (stat_handler) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 328 | stat_handler(psoc, arg, obj_status); |
| 329 | } |
| 330 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 331 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 332 | return QDF_STATUS_SUCCESS; |
| 333 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 334 | qdf_export_symbol(wlan_objmgr_psoc_component_obj_attach); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 335 | |
| 336 | QDF_STATUS wlan_objmgr_psoc_component_obj_detach( |
| 337 | struct wlan_objmgr_psoc *psoc, |
| 338 | enum wlan_umac_comp_id id, |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 339 | void *comp_priv_obj) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 340 | { |
| 341 | QDF_STATUS obj_status; |
| 342 | |
| 343 | /* component id is invalid */ |
| 344 | if (id >= WLAN_UMAC_MAX_COMPONENTS) |
| 345 | return QDF_STATUS_MAXCOMP_FAIL; |
| 346 | |
| 347 | wlan_psoc_obj_lock(psoc); |
| 348 | /* If there is a valid entry, return failure */ |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 349 | if (psoc->soc_comp_priv_obj[id] != comp_priv_obj) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 350 | psoc->obj_status[id] = QDF_STATUS_E_FAILURE; |
| 351 | wlan_psoc_obj_unlock(psoc); |
| 352 | return QDF_STATUS_E_FAILURE; |
| 353 | } |
| 354 | /* Reset pointers to NULL, update the status*/ |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 355 | psoc->soc_comp_priv_obj[id] = NULL; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 356 | psoc->obj_status[id] = QDF_STATUS_SUCCESS; |
| 357 | wlan_psoc_obj_unlock(psoc); |
| 358 | |
| 359 | /* If PSOC object status is partially created means, this API is |
| 360 | * invoked with differnt context, this block should be executed for |
| 361 | * async components only |
| 362 | */ |
| 363 | if ((psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) || |
| 364 | (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS)) { |
| 365 | /* Derive object status */ |
| 366 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 367 | if (obj_status == QDF_STATUS_SUCCESS) { |
| 368 | /* Update the status as Deleted, if full object |
| 369 | * deletion is in progress |
| 370 | */ |
| 371 | if (psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) |
| 372 | psoc->obj_state = WLAN_OBJ_STATE_DELETED; |
| 373 | |
| 374 | /* Move to creation state, since this component |
| 375 | * deletion alone requested |
| 376 | */ |
| 377 | if (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) |
| 378 | psoc->obj_state = WLAN_OBJ_STATE_CREATED; |
| 379 | /* Object status is failure */ |
| 380 | } else if (obj_status == QDF_STATUS_E_FAILURE) { |
| 381 | /* Update the status as Deletion failed, if full object |
| 382 | * deletion is in progress |
| 383 | */ |
| 384 | if (psoc->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) |
| 385 | psoc->obj_state = |
| 386 | WLAN_OBJ_STATE_DELETION_FAILED; |
| 387 | |
| 388 | /* Move to creation state, since this component |
| 389 | * deletion alone requested (do not block other |
| 390 | * components) |
| 391 | */ |
| 392 | if (psoc->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) |
| 393 | psoc->obj_state = WLAN_OBJ_STATE_CREATED; |
| 394 | } |
| 395 | |
| 396 | /* Delete psoc object */ |
| 397 | if ((obj_status == QDF_STATUS_SUCCESS) && |
| 398 | (psoc->obj_state == WLAN_OBJ_STATE_DELETED)) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 399 | /* Free psoc object */ |
| 400 | return wlan_objmgr_psoc_obj_free(psoc); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 401 | } |
| 402 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 403 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 404 | return QDF_STATUS_SUCCESS; |
| 405 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 406 | qdf_export_symbol(wlan_objmgr_psoc_component_obj_detach); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 407 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 408 | QDF_STATUS wlan_objmgr_iterate_obj_list( |
| 409 | struct wlan_objmgr_psoc *psoc, |
| 410 | enum wlan_objmgr_obj_type obj_type, |
| 411 | wlan_objmgr_op_handler handler, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 412 | void *arg, uint8_t lock_free_op, |
| 413 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 414 | { |
| 415 | uint16_t obj_id; |
| 416 | uint8_t i; |
| 417 | struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; |
| 418 | struct wlan_peer_list *peer_list; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 419 | struct wlan_objmgr_pdev *pdev; |
| 420 | struct wlan_objmgr_vdev *vdev; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 421 | struct wlan_objmgr_peer *peer; |
| 422 | struct wlan_objmgr_peer *peer_next; |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 423 | uint16_t max_vdev_cnt; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 424 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 425 | switch (obj_type) { |
| 426 | case WLAN_PDEV_OP: |
| 427 | /* Iterate through PDEV list, invoke handler for each pdev */ |
| 428 | for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 429 | pdev = wlan_objmgr_get_pdev_by_id(psoc, obj_id, dbg_id); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 430 | if (pdev) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 431 | handler(psoc, (void *)pdev, arg); |
| 432 | wlan_objmgr_pdev_release_ref(pdev, dbg_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 433 | } |
| 434 | } |
| 435 | break; |
| 436 | case WLAN_VDEV_OP: |
| 437 | /* Iterate through VDEV list, invoke handler for each vdev */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 438 | max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); |
| 439 | for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 440 | vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, |
| 441 | obj_id, dbg_id); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 442 | if (vdev) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 443 | handler(psoc, vdev, arg); |
| 444 | wlan_objmgr_vdev_release_ref(vdev, dbg_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 445 | } |
| 446 | } |
| 447 | break; |
| 448 | case WLAN_PEER_OP: |
| 449 | /* Iterate through PEER list, invoke handler for each peer */ |
| 450 | peer_list = &objmgr->peer_list; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 451 | /* Since peer list has sublist, iterate through sublists */ |
| 452 | for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 453 | peer = wlan_psoc_peer_list_peek_active_head(peer_list, |
| 454 | i, dbg_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 455 | while (peer) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 456 | handler(psoc, (void *)peer, arg); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 457 | /* Get next peer */ |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 458 | peer_next = |
| 459 | wlan_peer_get_next_active_peer_of_psoc( |
| 460 | peer_list, i, peer, dbg_id); |
| 461 | wlan_objmgr_peer_release_ref(peer, dbg_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 462 | peer = peer_next; |
| 463 | } |
| 464 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 465 | break; |
| 466 | default: |
| 467 | break; |
| 468 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 469 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 470 | return QDF_STATUS_SUCCESS; |
| 471 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 472 | qdf_export_symbol(wlan_objmgr_iterate_obj_list); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 473 | |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 474 | QDF_STATUS wlan_objmgr_iterate_obj_list_all( |
| 475 | struct wlan_objmgr_psoc *psoc, |
| 476 | enum wlan_objmgr_obj_type obj_type, |
| 477 | wlan_objmgr_op_handler handler, |
| 478 | void *arg, uint8_t lock_free_op, |
| 479 | wlan_objmgr_ref_dbgid dbg_id) |
| 480 | { |
| 481 | uint16_t obj_id; |
| 482 | uint8_t i; |
| 483 | struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; |
| 484 | struct wlan_peer_list *peer_list; |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 485 | struct wlan_objmgr_pdev *pdev; |
| 486 | struct wlan_objmgr_vdev *vdev; |
| 487 | struct wlan_objmgr_peer *peer; |
| 488 | struct wlan_objmgr_peer *peer_next; |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 489 | uint16_t max_vdev_cnt; |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 490 | |
| 491 | /* If caller requests for lock free opeation, do not acquire, |
| 492 | * handler will handle the synchronization |
| 493 | */ |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 494 | |
| 495 | switch (obj_type) { |
| 496 | case WLAN_PDEV_OP: |
| 497 | /* Iterate through PDEV list, invoke handler for each pdev */ |
| 498 | for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 499 | pdev = wlan_objmgr_get_pdev_by_id_no_state(psoc, |
| 500 | obj_id, dbg_id); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 501 | if (pdev) { |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 502 | handler(psoc, (void *)pdev, arg); |
| 503 | wlan_objmgr_pdev_release_ref(pdev, dbg_id); |
| 504 | } |
| 505 | } |
| 506 | break; |
| 507 | case WLAN_VDEV_OP: |
| 508 | /* Iterate through VDEV list, invoke handler for each vdev */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 509 | max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); |
| 510 | for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 511 | vdev = wlan_objmgr_get_vdev_by_id_from_psoc_no_state( |
| 512 | psoc, obj_id, dbg_id); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 513 | if (vdev) { |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 514 | handler(psoc, vdev, arg); |
| 515 | wlan_objmgr_vdev_release_ref(vdev, dbg_id); |
| 516 | } |
| 517 | } |
| 518 | break; |
| 519 | case WLAN_PEER_OP: |
| 520 | /* Iterate through PEER list, invoke handler for each peer */ |
| 521 | peer_list = &objmgr->peer_list; |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 522 | /* Since peer list has sublist, iterate through sublists */ |
| 523 | for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 524 | peer = wlan_psoc_peer_list_peek_head_ref(peer_list, i, |
| 525 | dbg_id); |
| 526 | |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 527 | while (peer) { |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 528 | handler(psoc, (void *)peer, arg); |
Srinivas Pitla | 77e1791 | 2018-04-11 21:59:08 +0530 | [diff] [blame] | 529 | /* Get next peer */ |
| 530 | peer_next = wlan_peer_get_next_peer_of_psoc_ref( |
| 531 | peer_list, i, |
| 532 | peer, dbg_id); |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 533 | wlan_objmgr_peer_release_ref(peer, dbg_id); |
| 534 | peer = peer_next; |
| 535 | } |
| 536 | } |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 537 | break; |
| 538 | default: |
| 539 | break; |
| 540 | } |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 541 | |
| 542 | return QDF_STATUS_SUCCESS; |
| 543 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 544 | qdf_export_symbol(wlan_objmgr_iterate_obj_list_all); |
Srinivas Pitla | 935cd2d | 2017-04-04 11:09:25 +0530 | [diff] [blame] | 545 | |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 546 | /** |
| 547 | * wlan_objmgr_iterate_obj_list_all_noref() - iterate through all psoc objects |
| 548 | * without taking ref |
| 549 | * @psoc: PSOC object |
| 550 | * @obj_type: PDEV_OP/VDEV_OP/PEER_OP |
| 551 | * @handler: the handler will be called for each object of requested type |
| 552 | * the handler should be implemented to perform required operation |
| 553 | * @arg: agruments passed by caller |
| 554 | * |
| 555 | * API to be used for performing the operations on all PDEV/VDEV/PEER objects |
| 556 | * of psoc with lock protected |
| 557 | * |
| 558 | * Return: SUCCESS/FAILURE |
| 559 | */ |
| 560 | static QDF_STATUS wlan_objmgr_iterate_obj_list_all_noref( |
| 561 | struct wlan_objmgr_psoc *psoc, |
| 562 | enum wlan_objmgr_obj_type obj_type, |
| 563 | wlan_objmgr_op_handler handler, |
| 564 | void *arg) |
| 565 | { |
| 566 | uint16_t obj_id; |
| 567 | uint8_t i; |
| 568 | struct wlan_objmgr_psoc_objmgr *objmgr = &psoc->soc_objmgr; |
| 569 | struct wlan_peer_list *peer_list; |
| 570 | qdf_list_t *obj_list; |
| 571 | struct wlan_objmgr_pdev *pdev; |
| 572 | struct wlan_objmgr_vdev *vdev; |
| 573 | struct wlan_objmgr_peer *peer; |
| 574 | struct wlan_objmgr_peer *peer_next; |
| 575 | uint16_t max_vdev_cnt; |
| 576 | |
| 577 | /* If caller requests for lock free opeation, do not acquire, |
| 578 | * handler will handle the synchronization |
| 579 | */ |
| 580 | wlan_psoc_obj_lock(psoc); |
| 581 | |
| 582 | switch (obj_type) { |
| 583 | case WLAN_PDEV_OP: |
| 584 | /* Iterate through PDEV list, invoke handler for each pdev */ |
| 585 | for (obj_id = 0; obj_id < WLAN_UMAC_MAX_PDEVS; obj_id++) { |
| 586 | pdev = objmgr->wlan_pdev_list[obj_id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 587 | if (pdev) |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 588 | handler(psoc, (void *)pdev, arg); |
| 589 | } |
| 590 | break; |
| 591 | case WLAN_VDEV_OP: |
| 592 | /* Iterate through VDEV list, invoke handler for each vdev */ |
| 593 | max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); |
| 594 | for (obj_id = 0; obj_id < max_vdev_cnt; obj_id++) { |
| 595 | vdev = objmgr->wlan_vdev_list[obj_id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 596 | if (vdev) |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 597 | handler(psoc, vdev, arg); |
| 598 | } |
| 599 | break; |
| 600 | case WLAN_PEER_OP: |
| 601 | /* Iterate through PEER list, invoke handler for each peer */ |
| 602 | peer_list = &objmgr->peer_list; |
| 603 | /* psoc lock should be taken before list lock */ |
| 604 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 605 | /* Since peer list has sublist, iterate through sublists */ |
| 606 | for (i = 0; i < WLAN_PEER_HASHSIZE; i++) { |
| 607 | obj_list = &peer_list->peer_hash[i]; |
| 608 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
| 609 | while (peer) { |
| 610 | /* Get next peer */ |
| 611 | peer_next = wlan_peer_get_next_peer_of_psoc( |
| 612 | obj_list, peer); |
| 613 | handler(psoc, (void *)peer, arg); |
| 614 | peer = peer_next; |
| 615 | } |
| 616 | } |
| 617 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 618 | break; |
| 619 | default: |
| 620 | break; |
| 621 | } |
| 622 | wlan_psoc_obj_unlock(psoc); |
| 623 | |
| 624 | return QDF_STATUS_SUCCESS; |
| 625 | } |
| 626 | |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 627 | static void wlan_objmgr_psoc_peer_delete(struct wlan_objmgr_psoc *psoc, |
| 628 | void *obj, void *args) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 629 | { |
| 630 | struct wlan_objmgr_peer *peer = (struct wlan_objmgr_peer *)obj; |
| 631 | |
| 632 | wlan_objmgr_peer_obj_delete(peer); |
| 633 | } |
| 634 | |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 635 | static void wlan_objmgr_psoc_vdev_delete(struct wlan_objmgr_psoc *psoc, |
| 636 | void *obj, void *args) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 637 | { |
| 638 | struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; |
| 639 | |
| 640 | wlan_objmgr_vdev_obj_delete(vdev); |
| 641 | } |
| 642 | |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 643 | static void wlan_objmgr_psoc_pdev_delete(struct wlan_objmgr_psoc *psoc, |
| 644 | void *obj, void *args) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 645 | { |
| 646 | struct wlan_objmgr_pdev *pdev = (struct wlan_objmgr_pdev *)obj; |
| 647 | |
| 648 | wlan_objmgr_pdev_obj_delete(pdev); |
| 649 | } |
| 650 | |
| 651 | QDF_STATUS wlan_objmgr_free_all_objects_per_psoc( |
| 652 | struct wlan_objmgr_psoc *psoc) |
| 653 | { |
| 654 | /* Free all peers */ |
| 655 | wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 656 | wlan_objmgr_psoc_peer_delete, NULL, 1, |
| 657 | WLAN_OBJMGR_ID); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 658 | /* Free all vdevs */ |
| 659 | wlan_objmgr_iterate_obj_list(psoc, WLAN_VDEV_OP, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 660 | wlan_objmgr_psoc_vdev_delete, NULL, 1, |
| 661 | WLAN_OBJMGR_ID); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 662 | /* Free all PDEVs */ |
| 663 | wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 664 | wlan_objmgr_psoc_pdev_delete, NULL, 1, |
| 665 | WLAN_OBJMGR_ID); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 666 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 667 | return QDF_STATUS_SUCCESS; |
| 668 | } |
| 669 | |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 670 | QDF_STATUS wlan_objmgr_trigger_psoc_comp_priv_object_creation( |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 671 | struct wlan_objmgr_psoc *psoc, |
| 672 | enum wlan_umac_comp_id id) |
| 673 | { |
| 674 | wlan_objmgr_psoc_create_handler handler; |
| 675 | void *arg; |
| 676 | QDF_STATUS obj_status = QDF_STATUS_SUCCESS; |
| 677 | |
| 678 | /* Component id is invalid */ |
| 679 | if (id >= WLAN_UMAC_MAX_COMPONENTS) |
| 680 | return QDF_STATUS_MAXCOMP_FAIL; |
| 681 | |
| 682 | wlan_psoc_obj_lock(psoc); |
| 683 | /* If component object is already created, delete old |
| 684 | * component object, then invoke creation |
| 685 | */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 686 | if (psoc->soc_comp_priv_obj[id]) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 687 | wlan_psoc_obj_unlock(psoc); |
| 688 | return QDF_STATUS_E_FAILURE; |
| 689 | } |
| 690 | wlan_psoc_obj_unlock(psoc); |
| 691 | /* Invoke registered create handlers */ |
| 692 | handler = g_umac_glb_obj->psoc_create_handler[id]; |
| 693 | arg = g_umac_glb_obj->psoc_create_handler_arg[id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 694 | if (handler) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 695 | psoc->obj_status[id] = handler(psoc, arg); |
| 696 | else |
| 697 | return QDF_STATUS_E_FAILURE; |
| 698 | |
| 699 | /* If object status is created, then only handle this object status */ |
| 700 | if (psoc->obj_state == WLAN_OBJ_STATE_CREATED) { |
| 701 | /* Derive object status */ |
| 702 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 703 | /* Move PSOC object state to Partially created state */ |
| 704 | if (obj_status == QDF_STATUS_COMP_ASYNC) { |
| 705 | /*TODO atomic */ |
| 706 | psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; |
| 707 | } |
| 708 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 709 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 710 | return obj_status; |
| 711 | } |
| 712 | |
Soumya Bhat | dd73487 | 2016-12-29 16:21:43 +0530 | [diff] [blame] | 713 | QDF_STATUS wlan_objmgr_trigger_psoc_comp_priv_object_deletion( |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 714 | struct wlan_objmgr_psoc *psoc, |
| 715 | enum wlan_umac_comp_id id) |
| 716 | { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 717 | wlan_objmgr_psoc_destroy_handler handler; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 718 | void *arg; |
| 719 | QDF_STATUS obj_status = QDF_STATUS_SUCCESS; |
| 720 | |
| 721 | /* component id is invalid */ |
| 722 | if (id >= WLAN_UMAC_MAX_COMPONENTS) |
| 723 | return QDF_STATUS_MAXCOMP_FAIL; |
| 724 | |
| 725 | wlan_psoc_obj_lock(psoc); |
| 726 | /* Component object was never created, invalid operation */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 727 | if (!psoc->soc_comp_priv_obj[id]) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 728 | wlan_psoc_obj_unlock(psoc); |
| 729 | return QDF_STATUS_E_FAILURE; |
| 730 | } |
| 731 | wlan_psoc_obj_unlock(psoc); |
| 732 | /* Invoke registered create handlers */ |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 733 | handler = g_umac_glb_obj->psoc_destroy_handler[id]; |
| 734 | arg = g_umac_glb_obj->psoc_destroy_handler_arg[id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 735 | if (handler) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 736 | psoc->obj_status[id] = handler(psoc, arg); |
| 737 | else |
| 738 | return QDF_STATUS_E_FAILURE; |
| 739 | |
| 740 | /* If object status is created, then only handle this object status */ |
| 741 | if (psoc->obj_state == WLAN_OBJ_STATE_CREATED) { |
| 742 | obj_status = wlan_objmgr_psoc_object_status(psoc); |
| 743 | /* move object state to DEL progress */ |
| 744 | if (obj_status == QDF_STATUS_COMP_ASYNC) |
| 745 | psoc->obj_state = WLAN_OBJ_STATE_COMP_DEL_PROGRESS; |
| 746 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 747 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 748 | return obj_status; |
| 749 | } |
| 750 | |
| 751 | /* Util APIs */ |
| 752 | |
| 753 | QDF_STATUS wlan_objmgr_psoc_pdev_attach(struct wlan_objmgr_psoc *psoc, |
| 754 | struct wlan_objmgr_pdev *pdev) |
| 755 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 756 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 757 | uint8_t id = 0; |
| 758 | QDF_STATUS status; |
| 759 | |
| 760 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 761 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 762 | /* |
| 763 | * Derive pdev id from pdev map |
| 764 | * First free pdev id is assigned |
| 765 | */ |
| 766 | while ((id < WLAN_UMAC_MAX_PDEVS) && |
| 767 | (objmgr->wlan_pdev_id_map & (1<<id))) |
| 768 | id++; |
| 769 | |
| 770 | if (id == WLAN_UMAC_MAX_PDEVS) { |
| 771 | status = QDF_STATUS_E_FAILURE; |
| 772 | } else { |
| 773 | /* Update the map for reserving the id */ |
| 774 | objmgr->wlan_pdev_id_map |= (1<<id); |
| 775 | /* store pdev in pdev list */ |
| 776 | objmgr->wlan_pdev_list[id] = pdev; |
| 777 | /* Increment pdev count */ |
| 778 | objmgr->wlan_pdev_count++; |
| 779 | /* save pdev id */ |
| 780 | pdev->pdev_objmgr.wlan_pdev_id = id; |
| 781 | status = QDF_STATUS_SUCCESS; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 782 | /* Inrement psoc ref count to block its free before pdev */ |
| 783 | wlan_objmgr_psoc_get_ref(psoc, WLAN_OBJMGR_ID); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 784 | } |
| 785 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 786 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 787 | return status; |
| 788 | } |
| 789 | |
| 790 | QDF_STATUS wlan_objmgr_psoc_pdev_detach(struct wlan_objmgr_psoc *psoc, |
| 791 | struct wlan_objmgr_pdev *pdev) |
| 792 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 793 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 794 | uint8_t id; |
| 795 | |
| 796 | id = pdev->pdev_objmgr.wlan_pdev_id; |
| 797 | /* If id is invalid, return */ |
| 798 | if (id >= WLAN_UMAC_MAX_PDEVS) |
| 799 | return QDF_STATUS_E_FAILURE; |
| 800 | |
| 801 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 802 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 803 | /* Free pdev id slot */ |
| 804 | objmgr->wlan_pdev_id_map &= ~(1<<id); |
| 805 | objmgr->wlan_pdev_list[id] = NULL; |
| 806 | objmgr->wlan_pdev_count--; |
| 807 | pdev->pdev_objmgr.wlan_pdev_id = 0xff; |
| 808 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 809 | /* Release ref count of psoc */ |
| 810 | wlan_objmgr_psoc_release_ref(psoc, WLAN_OBJMGR_ID); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 811 | |
Srinivas Pitla | 24ca6c9 | 2017-01-05 12:46:27 +0530 | [diff] [blame] | 812 | return QDF_STATUS_SUCCESS; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 813 | } |
| 814 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 815 | struct wlan_objmgr_pdev *wlan_objmgr_get_pdev_by_id( |
| 816 | struct wlan_objmgr_psoc *psoc, uint8_t id, |
| 817 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 818 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 819 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 820 | struct wlan_objmgr_pdev *pdev = NULL; |
| 821 | |
Srinivas Pitla | cb89aac | 2018-03-09 12:30:34 +0530 | [diff] [blame] | 822 | /* If id is invalid, return */ |
| 823 | if (id >= WLAN_UMAC_MAX_PDEVS) |
| 824 | return NULL; |
| 825 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 826 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 827 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 828 | /* get pdev from pdev list */ |
| 829 | pdev = objmgr->wlan_pdev_list[id]; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 830 | /* Do not return object, if it is not CREATED state */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 831 | if (pdev) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 832 | if (wlan_objmgr_pdev_try_get_ref(pdev, dbg_id) != |
| 833 | QDF_STATUS_SUCCESS) |
| 834 | pdev = NULL; |
| 835 | } |
| 836 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 837 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 838 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 839 | return pdev; |
| 840 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 841 | qdf_export_symbol(wlan_objmgr_get_pdev_by_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 842 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 843 | struct wlan_objmgr_pdev *wlan_objmgr_get_pdev_by_id_no_state( |
| 844 | struct wlan_objmgr_psoc *psoc, uint8_t id, |
| 845 | wlan_objmgr_ref_dbgid dbg_id) |
| 846 | { |
| 847 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 848 | struct wlan_objmgr_pdev *pdev = NULL; |
| 849 | |
Srinivas Pitla | cb89aac | 2018-03-09 12:30:34 +0530 | [diff] [blame] | 850 | /* If id is invalid, return */ |
| 851 | if (id >= WLAN_UMAC_MAX_PDEVS) |
| 852 | return NULL; |
| 853 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 854 | wlan_psoc_obj_lock(psoc); |
| 855 | objmgr = &psoc->soc_objmgr; |
| 856 | /* get pdev from pdev list */ |
| 857 | pdev = objmgr->wlan_pdev_list[id]; |
| 858 | /* Do not return object, if it is not CREATED state */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 859 | if (pdev) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 860 | wlan_objmgr_pdev_get_ref(pdev, dbg_id); |
| 861 | |
| 862 | wlan_psoc_obj_unlock(psoc); |
| 863 | |
| 864 | return pdev; |
| 865 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 866 | QDF_STATUS wlan_objmgr_psoc_vdev_attach(struct wlan_objmgr_psoc *psoc, |
| 867 | struct wlan_objmgr_vdev *vdev) |
| 868 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 869 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 870 | uint8_t id = 0; |
| 871 | uint8_t map_index = 0; |
| 872 | uint8_t map_entry_size = 32; |
| 873 | uint8_t adjust_ix = 0; |
| 874 | QDF_STATUS status; |
| 875 | |
| 876 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 877 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 878 | /* Find first free vdev id */ |
| 879 | while ((id < objmgr->max_vdev_count) && |
| 880 | (objmgr->wlan_vdev_id_map[map_index] & (1<<(id - adjust_ix)))) { |
| 881 | id++; |
| 882 | /* |
| 883 | * The map is two DWORDS(32 bits), so, map_index |
| 884 | * adjust_ix derived based on the id value |
| 885 | */ |
Neil Zhao | 502dceb | 2017-08-08 11:30:05 -0700 | [diff] [blame] | 886 | if (id == ((map_index + 1) * map_entry_size)) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 887 | map_index++; |
Neil Zhao | 502dceb | 2017-08-08 11:30:05 -0700 | [diff] [blame] | 888 | adjust_ix = map_index * map_entry_size; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 889 | } |
| 890 | } |
| 891 | /* If no free slot, return failure */ |
| 892 | if (id == objmgr->max_vdev_count) { |
| 893 | status = QDF_STATUS_E_FAILURE; |
| 894 | } else { |
| 895 | /* set free vdev id index */ |
| 896 | objmgr->wlan_vdev_id_map[map_index] |= (1<<(id-adjust_ix)); |
| 897 | /* store vdev pointer in vdev list */ |
| 898 | objmgr->wlan_vdev_list[id] = vdev; |
| 899 | /* increment vdev counter */ |
| 900 | objmgr->wlan_vdev_count++; |
| 901 | /* save vdev id */ |
| 902 | vdev->vdev_objmgr.vdev_id = id; |
| 903 | status = QDF_STATUS_SUCCESS; |
| 904 | } |
| 905 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 906 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 907 | return status; |
| 908 | } |
| 909 | |
| 910 | QDF_STATUS wlan_objmgr_psoc_vdev_detach(struct wlan_objmgr_psoc *psoc, |
| 911 | struct wlan_objmgr_vdev *vdev) |
| 912 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 913 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 914 | uint8_t id = 0; |
| 915 | uint8_t map_index = 0; |
| 916 | uint8_t map_entry_size = 32; |
| 917 | uint8_t adjust_ix = 0; |
| 918 | |
| 919 | id = vdev->vdev_objmgr.vdev_id; |
| 920 | /* Invalid vdev id */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 921 | if (id >= wlan_psoc_get_max_vdev_count(psoc)) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 922 | return QDF_STATUS_E_FAILURE; |
| 923 | /* |
| 924 | * Derive map_index and adjust_ix to find actual DWORD |
| 925 | * the id map is present |
| 926 | */ |
| 927 | while ((id - adjust_ix) >= map_entry_size) { |
| 928 | map_index++; |
| 929 | adjust_ix = map_index * map_entry_size; |
| 930 | } |
| 931 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 932 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 933 | /* unset bit, to free the slot */ |
| 934 | objmgr->wlan_vdev_id_map[map_index] &= ~(1<<(id-adjust_ix)); |
| 935 | /* reset VDEV pointer to NULL in VDEV list array */ |
| 936 | objmgr->wlan_vdev_list[id] = NULL; |
| 937 | /* decrement vdev count */ |
| 938 | objmgr->wlan_vdev_count--; |
| 939 | vdev->vdev_objmgr.vdev_id = 0xff; |
| 940 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 941 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 942 | return QDF_STATUS_SUCCESS; |
| 943 | } |
| 944 | |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 945 | struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_opmode_from_psoc( |
| 946 | struct wlan_objmgr_psoc *psoc, |
Jeff Johnson | a426232 | 2017-11-09 09:54:12 -0800 | [diff] [blame] | 947 | enum QDF_OPMODE opmode, |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 948 | wlan_objmgr_ref_dbgid dbg_id) |
| 949 | { |
Naveen Rawat | bbb6bd6 | 2017-11-08 11:03:28 -0800 | [diff] [blame] | 950 | struct wlan_objmgr_vdev *vdev = NULL; |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 951 | int vdev_cnt = 0; |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 952 | uint16_t max_vdev_cnt; |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 953 | |
| 954 | /* if PSOC is NULL, return */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 955 | if (!psoc) |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 956 | return NULL; |
| 957 | |
| 958 | wlan_psoc_obj_lock(psoc); |
| 959 | |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 960 | max_vdev_cnt = wlan_psoc_get_max_vdev_count(psoc); |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 961 | /* retrieve vdev pointer from vdev list */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 962 | while (vdev_cnt < max_vdev_cnt) { |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 963 | vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_cnt]; |
| 964 | vdev_cnt++; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 965 | if (!vdev) |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 966 | continue; |
| 967 | wlan_vdev_obj_lock(vdev); |
| 968 | if (vdev->vdev_mlme.vdev_opmode == opmode) { |
| 969 | wlan_vdev_obj_unlock(vdev); |
| 970 | if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) != |
Naveen Rawat | bbb6bd6 | 2017-11-08 11:03:28 -0800 | [diff] [blame] | 971 | QDF_STATUS_SUCCESS) { |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 972 | vdev = NULL; |
Naveen Rawat | bbb6bd6 | 2017-11-08 11:03:28 -0800 | [diff] [blame] | 973 | continue; |
| 974 | } |
Kabilan Kannan | 3e47521 | 2017-02-28 20:28:54 -0800 | [diff] [blame] | 975 | break; |
| 976 | } |
| 977 | wlan_vdev_obj_unlock(vdev); |
| 978 | } |
| 979 | wlan_psoc_obj_unlock(psoc); |
| 980 | |
| 981 | return vdev; |
| 982 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 983 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 984 | struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc( |
| 985 | struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, |
| 986 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 987 | { |
| 988 | struct wlan_objmgr_vdev *vdev; |
| 989 | |
| 990 | /* if PSOC is NULL, return */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 991 | if (!psoc) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 992 | return NULL; |
| 993 | /* vdev id is invalid */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 994 | if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 995 | return NULL; |
| 996 | |
| 997 | wlan_psoc_obj_lock(psoc); |
| 998 | /* retrieve vdev pointer from vdev list */ |
| 999 | vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1000 | if (vdev) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1001 | if (wlan_objmgr_vdev_try_get_ref(vdev, dbg_id) != |
| 1002 | QDF_STATUS_SUCCESS) |
| 1003 | vdev = NULL; |
| 1004 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1005 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1006 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1007 | return vdev; |
| 1008 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1009 | qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1010 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1011 | struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_id_from_psoc_no_state( |
| 1012 | struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, |
| 1013 | wlan_objmgr_ref_dbgid dbg_id) |
| 1014 | { |
| 1015 | struct wlan_objmgr_vdev *vdev; |
| 1016 | |
| 1017 | /* if PSOC is NULL, return */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1018 | if (!psoc) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1019 | return NULL; |
| 1020 | /* vdev id is invalid */ |
Srinivas Pitla | c7f4e03 | 2018-01-08 16:59:16 +0530 | [diff] [blame] | 1021 | if (vdev_id >= wlan_psoc_get_max_vdev_count(psoc)) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1022 | return NULL; |
| 1023 | |
| 1024 | wlan_psoc_obj_lock(psoc); |
| 1025 | /* retrieve vdev pointer from vdev list */ |
| 1026 | vdev = psoc->soc_objmgr.wlan_vdev_list[vdev_id]; |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1027 | if (vdev) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1028 | wlan_objmgr_vdev_get_ref(vdev, dbg_id); |
| 1029 | |
| 1030 | wlan_psoc_obj_unlock(psoc); |
| 1031 | |
| 1032 | return vdev; |
| 1033 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1034 | qdf_export_symbol(wlan_objmgr_get_vdev_by_id_from_psoc_no_state); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1035 | |
| 1036 | struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_psoc( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1037 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1038 | uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1039 | { |
| 1040 | struct wlan_objmgr_vdev *vdev; |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1041 | struct wlan_objmgr_pdev *pdev; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1042 | |
| 1043 | /* if PSOC is NULL, return */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1044 | if (!psoc) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1045 | return NULL; |
| 1046 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1047 | if (!macaddr) |
| 1048 | return NULL; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1049 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1050 | pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); |
| 1051 | if (!pdev) { |
| 1052 | obj_mgr_err("pdev is null"); |
| 1053 | return NULL; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1054 | } |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1055 | vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev(pdev, macaddr, dbg_id); |
| 1056 | wlan_objmgr_pdev_release_ref(pdev, dbg_id); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1057 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1058 | return vdev; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1059 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1060 | qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1061 | |
| 1062 | struct wlan_objmgr_vdev *wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1063 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1064 | uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1065 | { |
| 1066 | struct wlan_objmgr_vdev *vdev; |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1067 | struct wlan_objmgr_pdev *pdev; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1068 | |
| 1069 | /* if PSOC is NULL, return */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1070 | if (!psoc) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1071 | return NULL; |
| 1072 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1073 | if (!macaddr) |
| 1074 | return NULL; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1075 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1076 | pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, dbg_id); |
| 1077 | if (!pdev) { |
| 1078 | obj_mgr_err("pdev is null"); |
| 1079 | return NULL; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1080 | } |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1081 | vdev = wlan_objmgr_get_vdev_by_macaddr_from_pdev_no_state(pdev, macaddr, dbg_id); |
| 1082 | wlan_objmgr_pdev_release_ref(pdev, dbg_id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1083 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1084 | return vdev; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1085 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1086 | qdf_export_symbol(wlan_objmgr_get_vdev_by_macaddr_from_psoc_no_state); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1087 | |
| 1088 | static void wlan_obj_psoc_peerlist_add_tail(qdf_list_t *obj_list, |
| 1089 | struct wlan_objmgr_peer *obj) |
| 1090 | { |
| 1091 | qdf_list_insert_back(obj_list, &obj->psoc_peer); |
| 1092 | } |
| 1093 | |
| 1094 | static QDF_STATUS wlan_obj_psoc_peerlist_remove_peer( |
| 1095 | qdf_list_t *obj_list, |
| 1096 | struct wlan_objmgr_peer *peer) |
| 1097 | { |
| 1098 | qdf_list_node_t *psoc_node = NULL; |
| 1099 | |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1100 | if (!peer) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1101 | return QDF_STATUS_E_FAILURE; |
| 1102 | /* get vdev list node element */ |
| 1103 | psoc_node = &peer->psoc_peer; |
| 1104 | /* list is empty, return failure */ |
| 1105 | if (qdf_list_remove_node(obj_list, psoc_node) != QDF_STATUS_SUCCESS) |
| 1106 | return QDF_STATUS_E_FAILURE; |
| 1107 | |
| 1108 | return QDF_STATUS_SUCCESS; |
| 1109 | } |
| 1110 | |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1111 | static QDF_STATUS wlan_peer_bssid_match(struct wlan_objmgr_peer *peer, |
| 1112 | uint8_t *bssid) |
| 1113 | { |
| 1114 | struct wlan_objmgr_vdev *vdev = wlan_peer_get_vdev(peer); |
| 1115 | uint8_t *peer_bssid = wlan_vdev_mlme_get_macaddr(vdev); |
| 1116 | |
| 1117 | if (WLAN_ADDR_EQ(peer_bssid, bssid) == QDF_STATUS_SUCCESS) |
| 1118 | return QDF_STATUS_SUCCESS; |
| 1119 | else |
| 1120 | return QDF_STATUS_E_FAILURE; |
| 1121 | } |
| 1122 | |
| 1123 | /** |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1124 | * wlan_obj_psoc_peerlist_get_peer_logically_deleted() - get peer |
| 1125 | * from psoc peer list |
| 1126 | * @psoc: PSOC object |
| 1127 | * @macaddr: MAC address |
| 1128 | * |
| 1129 | * API to finds peer object pointer of logically deleted peer |
| 1130 | * |
| 1131 | * Return: peer pointer |
| 1132 | * NULL on FAILURE |
| 1133 | */ |
| 1134 | static struct wlan_objmgr_peer * |
| 1135 | wlan_obj_psoc_peerlist_get_peer_logically_deleted( |
| 1136 | qdf_list_t *obj_list, uint8_t *macaddr, |
| 1137 | wlan_objmgr_ref_dbgid dbg_id) |
| 1138 | { |
| 1139 | struct wlan_objmgr_peer *peer; |
| 1140 | struct wlan_objmgr_peer *peer_temp; |
| 1141 | |
| 1142 | /* Iterate through hash list to get the peer */ |
| 1143 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1144 | while (peer) { |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1145 | /* For peer, macaddr is key */ |
| 1146 | if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1147 | == QDF_STATUS_SUCCESS) { |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1148 | /* Return peer in logically deleted state */ |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1149 | if (peer->obj_state == |
| 1150 | WLAN_OBJ_STATE_LOGICALLY_DELETED) { |
| 1151 | wlan_objmgr_peer_get_ref(peer, dbg_id); |
| 1152 | |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1153 | return peer; |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1154 | } |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1155 | |
| 1156 | } |
| 1157 | /* Move to next peer */ |
| 1158 | peer_temp = peer; |
| 1159 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1160 | } |
| 1161 | |
| 1162 | /* Not found, return NULL */ |
| 1163 | return NULL; |
| 1164 | } |
| 1165 | |
| 1166 | /** |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1167 | * wlan_obj_psoc_peerlist_get_peer() - get peer from psoc peer list |
| 1168 | * @psoc: PSOC object |
| 1169 | * @macaddr: MAC address |
| 1170 | * |
| 1171 | * API to finds peer object pointer by MAC addr from hash list |
| 1172 | * |
| 1173 | * Return: peer pointer |
| 1174 | * NULL on FAILURE |
| 1175 | */ |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 1176 | static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1177 | qdf_list_t *obj_list, uint8_t *macaddr, |
| 1178 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1179 | { |
| 1180 | struct wlan_objmgr_peer *peer; |
| 1181 | struct wlan_objmgr_peer *peer_temp; |
| 1182 | |
| 1183 | /* Iterate through hash list to get the peer */ |
| 1184 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1185 | while (peer) { |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1186 | /* For peer, macaddr is key */ |
| 1187 | if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1188 | == QDF_STATUS_SUCCESS) { |
| 1189 | if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == |
| 1190 | QDF_STATUS_SUCCESS) { |
| 1191 | return peer; |
| 1192 | } |
| 1193 | } |
| 1194 | /* Move to next peer */ |
| 1195 | peer_temp = peer; |
| 1196 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
| 1197 | } |
| 1198 | |
| 1199 | /* Not found, return NULL */ |
| 1200 | return NULL; |
| 1201 | } |
| 1202 | |
| 1203 | /** |
| 1204 | * wlan_obj_psoc_peerlist_get_peer_by_pdev_id() - get peer from psoc peer list |
| 1205 | * @psoc: PSOC object |
| 1206 | * @macaddr: MAC address |
| 1207 | * #pdev_id: Pdev id |
| 1208 | * |
| 1209 | * API to finds peer object pointer by MAC addr and pdev id from hash list |
| 1210 | * |
| 1211 | * Return: peer pointer |
| 1212 | * NULL on FAILURE |
| 1213 | */ |
| 1214 | static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_by_pdev_id( |
| 1215 | qdf_list_t *obj_list, uint8_t *macaddr, |
| 1216 | uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id) |
| 1217 | { |
| 1218 | struct wlan_objmgr_peer *peer; |
| 1219 | struct wlan_objmgr_peer *peer_temp; |
| 1220 | |
| 1221 | /* Iterate through hash list to get the peer */ |
| 1222 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1223 | while (peer) { |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1224 | /* For peer, macaddr is key */ |
| 1225 | if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1226 | == QDF_STATUS_SUCCESS) && |
| 1227 | (wlan_peer_get_pdev_id(peer) == pdev_id)) { |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1228 | if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1229 | QDF_STATUS_SUCCESS) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1230 | return peer; |
| 1231 | } |
| 1232 | } |
| 1233 | /* Move to next peer */ |
| 1234 | peer_temp = peer; |
| 1235 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
| 1236 | } |
| 1237 | |
| 1238 | /* Not found, return NULL */ |
| 1239 | return NULL; |
| 1240 | } |
| 1241 | |
| 1242 | static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_no_state( |
| 1243 | qdf_list_t *obj_list, uint8_t *macaddr, |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1244 | uint8_t pdev_id, wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1245 | { |
| 1246 | struct wlan_objmgr_peer *peer; |
| 1247 | struct wlan_objmgr_peer *peer_temp; |
| 1248 | |
| 1249 | /* Iterate through hash list to get the peer */ |
| 1250 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1251 | while (peer) { |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1252 | /* For peer, macaddr and pdev_id is key */ |
| 1253 | if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1254 | == QDF_STATUS_SUCCESS) && |
| 1255 | (wlan_peer_get_pdev_id(peer) == pdev_id)) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1256 | wlan_objmgr_peer_get_ref(peer, dbg_id); |
| 1257 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1258 | return peer; |
| 1259 | } |
| 1260 | /* Move to next peer */ |
| 1261 | peer_temp = peer; |
| 1262 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
| 1263 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1264 | |
| 1265 | /* Not found, return NULL */ |
| 1266 | return NULL; |
| 1267 | } |
| 1268 | |
| 1269 | /** |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1270 | * wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid() - get peer |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1271 | * from psoc peer list using |
| 1272 | * mac and vdev self mac |
| 1273 | * @obj_list: peer object list |
| 1274 | * @macaddr: MAC address |
| 1275 | * @bssid: BSSID address |
| 1276 | * @dbg_id: id of the caller |
| 1277 | * |
| 1278 | * API to finds peer object pointer by MAC addr and BSSID from |
| 1279 | * peer hash list for a node which is in logically deleted state, |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1280 | * bssid check is done on matching peer |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1281 | * |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1282 | * Caller to free the list allocated in this function |
| 1283 | * |
| 1284 | * Return: list of peer pointers |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1285 | * NULL on FAILURE |
| 1286 | */ |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1287 | static qdf_list_t |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1288 | *wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid( |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1289 | qdf_list_t *obj_list, uint8_t *macaddr, |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1290 | uint8_t *bssid, uint8_t pdev_id, |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1291 | wlan_objmgr_ref_dbgid dbg_id) |
| 1292 | { |
| 1293 | struct wlan_objmgr_peer *peer; |
| 1294 | struct wlan_objmgr_peer *peer_temp; |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1295 | struct wlan_logically_del_peer *peer_list = NULL; |
| 1296 | qdf_list_t *logical_del_peer_list = NULL; |
| 1297 | bool lock_released = false; |
| 1298 | |
| 1299 | logical_del_peer_list = qdf_mem_malloc(sizeof(*logical_del_peer_list)); |
Madhvapathi Sriram | b73fc28 | 2019-01-07 09:12:25 +0530 | [diff] [blame] | 1300 | if (!logical_del_peer_list) |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1301 | return NULL; |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1302 | |
| 1303 | qdf_list_create(logical_del_peer_list, WLAN_UMAC_PSOC_MAX_PEERS); |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1304 | |
| 1305 | /* Iterate through hash list to get the peer */ |
| 1306 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1307 | while (peer) { |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1308 | wlan_peer_obj_lock(peer); |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1309 | /* For peer, macaddr and pdev id are keys */ |
| 1310 | if ((WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1311 | == QDF_STATUS_SUCCESS) && |
| 1312 | (wlan_peer_get_pdev_id(peer) == pdev_id)) { |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1313 | /* |
Kiran Venkatappa | 111dcb8 | 2017-12-15 22:42:27 +0530 | [diff] [blame] | 1314 | * if BSSID not NULL, |
| 1315 | * then match is requested by caller, check BSSID |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1316 | * (vdev mac == bssid) -- return peer |
| 1317 | * (vdev mac != bssid) -- perform next iteration |
| 1318 | */ |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1319 | if ((!bssid) || |
Kiran Venkatappa | 111dcb8 | 2017-12-15 22:42:27 +0530 | [diff] [blame] | 1320 | (wlan_peer_bssid_match(peer, bssid) == |
| 1321 | QDF_STATUS_SUCCESS)) { |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1322 | /* Return peer in logically deleted state */ |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1323 | if ((peer->obj_state == |
| 1324 | WLAN_OBJ_STATE_LOGICALLY_DELETED) && |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1325 | qdf_atomic_read( |
| 1326 | &peer->peer_objmgr.ref_cnt)) { |
| 1327 | |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1328 | wlan_objmgr_peer_get_ref(peer, dbg_id); |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1329 | wlan_peer_obj_unlock(peer); |
| 1330 | lock_released = true; |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1331 | |
| 1332 | peer_list = |
| 1333 | qdf_mem_malloc( |
| 1334 | sizeof(struct wlan_logically_del_peer)); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1335 | if (!peer_list) { |
Om Prakash Tripathi | de062d8 | 2018-05-11 16:41:26 +0530 | [diff] [blame] | 1336 | wlan_objmgr_peer_release_ref(peer, dbg_id); |
Varun Reddy Yeturu | d6b2247 | 2017-12-21 15:37:57 -0800 | [diff] [blame] | 1337 | /* Lock is already released */ |
Om Prakash Tripathi | de062d8 | 2018-05-11 16:41:26 +0530 | [diff] [blame] | 1338 | WLAN_OBJMGR_BUG(0); |
Varun Reddy Yeturu | d6b2247 | 2017-12-21 15:37:57 -0800 | [diff] [blame] | 1339 | break; |
| 1340 | } |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1341 | |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1342 | peer_list->peer = peer; |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1343 | |
| 1344 | qdf_list_insert_front( |
| 1345 | logical_del_peer_list, |
| 1346 | &peer_list->list); |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1347 | } |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1348 | } |
| 1349 | } |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1350 | |
| 1351 | if (!lock_released) |
| 1352 | wlan_peer_obj_unlock(peer); |
| 1353 | |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1354 | /* Move to next peer */ |
| 1355 | peer_temp = peer; |
| 1356 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
Srinivas Pitla | d7f0966 | 2017-06-28 21:18:39 +0530 | [diff] [blame] | 1357 | lock_released = false; |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1358 | } |
| 1359 | |
| 1360 | /* Not found, return NULL */ |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1361 | if (qdf_list_empty(logical_del_peer_list)) { |
| 1362 | qdf_mem_free(logical_del_peer_list); |
| 1363 | return NULL; |
| 1364 | } else { |
| 1365 | return logical_del_peer_list; |
| 1366 | } |
| 1367 | |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1368 | } |
| 1369 | |
| 1370 | /** |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1371 | * wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid() - get peer from psoc peer |
| 1372 | * list using mac and vdev |
| 1373 | * self mac |
| 1374 | * @psoc: PSOC object |
| 1375 | * @macaddr: MAC address |
| 1376 | * @bssid: BSSID address |
| 1377 | * |
| 1378 | * API to finds peer object pointer by MAC addr and BSSID from |
| 1379 | * peer hash list, bssid check is done on matching peer |
| 1380 | * |
| 1381 | * Return: peer pointer |
| 1382 | * NULL on FAILURE |
| 1383 | */ |
| 1384 | static struct wlan_objmgr_peer *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid( |
| 1385 | qdf_list_t *obj_list, uint8_t *macaddr, |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1386 | uint8_t *bssid, uint8_t pdev_id, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1387 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1388 | { |
| 1389 | struct wlan_objmgr_peer *peer; |
| 1390 | struct wlan_objmgr_peer *peer_temp; |
| 1391 | |
| 1392 | /* Iterate through hash list to get the peer */ |
| 1393 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1394 | while (peer) { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1395 | /* For peer, macaddr is key */ |
| 1396 | if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1397 | == QDF_STATUS_SUCCESS) { |
| 1398 | /* |
| 1399 | * BSSID match is requested by caller, check BSSID |
| 1400 | * (vdev mac == bssid) -- return peer |
| 1401 | * (vdev mac != bssid) -- perform next iteration |
| 1402 | */ |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1403 | if ((wlan_peer_bssid_match(peer, bssid) == |
| 1404 | QDF_STATUS_SUCCESS) && |
| 1405 | (wlan_peer_get_pdev_id(peer) == pdev_id)) { |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1406 | if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) |
| 1407 | == QDF_STATUS_SUCCESS) { |
| 1408 | return peer; |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1409 | } |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1410 | } |
| 1411 | } |
| 1412 | /* Move to next peer */ |
| 1413 | peer_temp = peer; |
| 1414 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
| 1415 | } |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1416 | /* Not found, return NULL */ |
| 1417 | return NULL; |
| 1418 | } |
| 1419 | |
| 1420 | static struct wlan_objmgr_peer |
| 1421 | *wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state( |
| 1422 | qdf_list_t *obj_list, uint8_t *macaddr, |
| 1423 | uint8_t *bssid, |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1424 | uint8_t pdev_id, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1425 | wlan_objmgr_ref_dbgid dbg_id) |
| 1426 | { |
| 1427 | struct wlan_objmgr_peer *peer; |
| 1428 | struct wlan_objmgr_peer *peer_temp; |
| 1429 | |
| 1430 | /* Iterate through hash list to get the peer */ |
| 1431 | peer = wlan_psoc_peer_list_peek_head(obj_list); |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1432 | while (peer) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1433 | /* For peer, macaddr is key */ |
| 1434 | if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), macaddr) |
| 1435 | == QDF_STATUS_SUCCESS) { |
| 1436 | /* |
| 1437 | * BSSID match is requested by caller, check BSSID |
| 1438 | * (vdev mac == bssid) -- return peer |
| 1439 | * (vdev mac != bssid) -- perform next iteration |
| 1440 | */ |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1441 | if ((wlan_peer_bssid_match(peer, bssid) == |
| 1442 | QDF_STATUS_SUCCESS) && |
| 1443 | (wlan_peer_get_pdev_id(peer) == pdev_id)) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1444 | wlan_objmgr_peer_get_ref(peer, dbg_id); |
| 1445 | |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1446 | return peer; |
| 1447 | } |
| 1448 | } |
| 1449 | /* Move to next peer */ |
| 1450 | peer_temp = peer; |
| 1451 | peer = wlan_peer_get_next_peer_of_psoc(obj_list, peer_temp); |
| 1452 | } |
| 1453 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1454 | /* Not found, return NULL */ |
| 1455 | return NULL; |
| 1456 | } |
| 1457 | |
| 1458 | QDF_STATUS wlan_objmgr_psoc_peer_attach(struct wlan_objmgr_psoc *psoc, |
| 1459 | struct wlan_objmgr_peer *peer) |
| 1460 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1461 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1462 | uint8_t hash_index; |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1463 | struct wlan_peer_list *peer_list; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1464 | |
| 1465 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1466 | objmgr = &psoc->soc_objmgr; |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 1467 | /* Max temporary peer limit is reached, return failure */ |
| 1468 | if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) { |
| 1469 | if (objmgr->temp_peer_count >= WLAN_MAX_PSOC_TEMP_PEERS) { |
| 1470 | wlan_psoc_obj_unlock(psoc); |
| 1471 | return QDF_STATUS_E_FAILURE; |
| 1472 | } |
| 1473 | } else { |
| 1474 | /* Max peer limit is reached, return failure */ |
| 1475 | if (objmgr->wlan_peer_count |
| 1476 | >= wlan_psoc_get_max_peer_count(psoc)) { |
| 1477 | wlan_psoc_obj_unlock(psoc); |
| 1478 | return QDF_STATUS_E_FAILURE; |
| 1479 | } |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1480 | } |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 1481 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1482 | /* Derive hash index from mac address */ |
| 1483 | hash_index = WLAN_PEER_HASH(peer->macaddr); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1484 | peer_list = &objmgr->peer_list; |
| 1485 | /* psoc lock should be taken before list lock */ |
| 1486 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1487 | /* add peer to hash peer list */ |
| 1488 | wlan_obj_psoc_peerlist_add_tail( |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1489 | &peer_list->peer_hash[hash_index], |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1490 | peer); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1491 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1492 | /* Increment peer count */ |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 1493 | if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) |
| 1494 | objmgr->temp_peer_count++; |
| 1495 | else |
| 1496 | objmgr->wlan_peer_count++; |
| 1497 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1498 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1499 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1500 | return QDF_STATUS_SUCCESS; |
| 1501 | } |
| 1502 | |
| 1503 | QDF_STATUS wlan_objmgr_psoc_peer_detach(struct wlan_objmgr_psoc *psoc, |
| 1504 | struct wlan_objmgr_peer *peer) |
| 1505 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1506 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1507 | uint8_t hash_index; |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1508 | struct wlan_peer_list *peer_list; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1509 | |
| 1510 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1511 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1512 | /* if list is empty, return */ |
| 1513 | if (objmgr->wlan_peer_count == 0) { |
| 1514 | wlan_psoc_obj_unlock(psoc); |
| 1515 | return QDF_STATUS_E_FAILURE; |
| 1516 | } |
| 1517 | /* Get hash index, to locate the actual peer list */ |
| 1518 | hash_index = WLAN_PEER_HASH(peer->macaddr); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1519 | peer_list = &objmgr->peer_list; |
| 1520 | /* psoc lock should be taken before list lock */ |
| 1521 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1522 | /* removes the peer from peer_list */ |
| 1523 | if (wlan_obj_psoc_peerlist_remove_peer( |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1524 | &peer_list->peer_hash[hash_index], |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1525 | peer) == |
| 1526 | QDF_STATUS_E_FAILURE) { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1527 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1528 | wlan_psoc_obj_unlock(psoc); |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1529 | obj_mgr_err("Failed to detach peer"); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1530 | return QDF_STATUS_E_FAILURE; |
| 1531 | } |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1532 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1533 | /* Decrement peer count */ |
Vivek | adbfaa7 | 2018-05-11 13:02:00 +0530 | [diff] [blame] | 1534 | if (peer->peer_mlme.peer_type == WLAN_PEER_STA_TEMP) |
| 1535 | objmgr->temp_peer_count--; |
| 1536 | else |
| 1537 | objmgr->wlan_peer_count--; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1538 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1539 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1540 | return QDF_STATUS_SUCCESS; |
| 1541 | } |
| 1542 | |
Soumya Bhat | c430e10 | 2017-02-17 10:33:54 +0530 | [diff] [blame] | 1543 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted( |
| 1544 | struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, |
| 1545 | wlan_objmgr_ref_dbgid dbg_id) |
| 1546 | { |
| 1547 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1548 | uint8_t hash_index; |
| 1549 | struct wlan_objmgr_peer *peer = NULL; |
| 1550 | struct wlan_peer_list *peer_list; |
| 1551 | |
| 1552 | /* psoc lock should be taken before peer list lock */ |
| 1553 | wlan_psoc_obj_lock(psoc); |
| 1554 | objmgr = &psoc->soc_objmgr; |
| 1555 | /* List is empty, return NULL */ |
| 1556 | if (objmgr->wlan_peer_count == 0) { |
| 1557 | wlan_psoc_obj_unlock(psoc); |
| 1558 | return NULL; |
| 1559 | } |
| 1560 | /* reduce the search window, with hash key */ |
| 1561 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1562 | peer_list = &objmgr->peer_list; |
| 1563 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1564 | /* Iterate through peer list, get peer */ |
| 1565 | peer = wlan_obj_psoc_peerlist_get_peer_logically_deleted( |
| 1566 | &peer_list->peer_hash[hash_index], macaddr, dbg_id); |
| 1567 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1568 | wlan_psoc_obj_unlock(psoc); |
| 1569 | |
| 1570 | return peer; |
| 1571 | } |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1572 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1573 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac( |
| 1574 | struct wlan_objmgr_psoc *psoc, uint8_t *macaddr, |
| 1575 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1576 | { |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1577 | struct wlan_objmgr_psoc_objmgr *objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1578 | uint8_t hash_index; |
| 1579 | struct wlan_objmgr_peer *peer = NULL; |
| 1580 | struct wlan_peer_list *peer_list; |
| 1581 | |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1582 | if (!macaddr) |
| 1583 | return NULL; |
| 1584 | |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1585 | /* psoc lock should be taken before peer list lock */ |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1586 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1587 | objmgr = &psoc->soc_objmgr; |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1588 | /* List is empty, return NULL */ |
| 1589 | if (objmgr->wlan_peer_count == 0) { |
| 1590 | wlan_psoc_obj_unlock(psoc); |
| 1591 | return NULL; |
| 1592 | } |
| 1593 | /* reduce the search window, with hash key */ |
| 1594 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1595 | peer_list = &objmgr->peer_list; |
| 1596 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1597 | /* Iterate through peer list, get peer */ |
| 1598 | peer = wlan_obj_psoc_peerlist_get_peer( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1599 | &peer_list->peer_hash[hash_index], macaddr, dbg_id); |
| 1600 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1601 | wlan_psoc_obj_unlock(psoc); |
| 1602 | |
| 1603 | return peer; |
| 1604 | } |
| 1605 | qdf_export_symbol(wlan_objmgr_get_peer_by_mac); |
| 1606 | |
| 1607 | struct wlan_objmgr_peer *wlan_objmgr_get_peer( |
| 1608 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1609 | uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) |
| 1610 | { |
| 1611 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1612 | uint8_t hash_index; |
| 1613 | struct wlan_objmgr_peer *peer = NULL; |
| 1614 | struct wlan_peer_list *peer_list; |
| 1615 | |
| 1616 | if (pdev_id >= WLAN_UMAC_MAX_PDEVS) |
| 1617 | QDF_ASSERT(0); |
| 1618 | |
| 1619 | if (!macaddr) |
| 1620 | return NULL; |
| 1621 | |
| 1622 | /* psoc lock should be taken before peer list lock */ |
| 1623 | wlan_psoc_obj_lock(psoc); |
| 1624 | objmgr = &psoc->soc_objmgr; |
| 1625 | /* List is empty, return NULL */ |
| 1626 | if (objmgr->wlan_peer_count == 0) { |
| 1627 | wlan_psoc_obj_unlock(psoc); |
| 1628 | return NULL; |
| 1629 | } |
| 1630 | /* reduce the search window, with hash key */ |
| 1631 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1632 | peer_list = &objmgr->peer_list; |
| 1633 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1634 | /* Iterate through peer list, get peer */ |
| 1635 | peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id( |
| 1636 | &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1637 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1638 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1639 | |
| 1640 | return peer; |
| 1641 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1642 | qdf_export_symbol(wlan_objmgr_get_peer); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1643 | |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1644 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1645 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1646 | uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1647 | { |
| 1648 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1649 | uint8_t hash_index; |
| 1650 | struct wlan_objmgr_peer *peer = NULL; |
| 1651 | struct wlan_peer_list *peer_list; |
| 1652 | |
| 1653 | /* psoc lock should be taken before peer list lock */ |
| 1654 | objmgr = &psoc->soc_objmgr; |
| 1655 | /* List is empty, return NULL */ |
| 1656 | if (objmgr->wlan_peer_count == 0) |
| 1657 | return NULL; |
| 1658 | |
| 1659 | /* reduce the search window, with hash key */ |
| 1660 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1661 | peer_list = &objmgr->peer_list; |
| 1662 | /* Iterate through peer list, get peer */ |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1663 | peer = wlan_obj_psoc_peerlist_get_peer_by_pdev_id( |
| 1664 | &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1665 | |
| 1666 | return peer; |
| 1667 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1668 | qdf_export_symbol(wlan_objmgr_get_peer_nolock); |
Srinivas Pitla | 9365b08 | 2017-03-27 16:01:59 +0530 | [diff] [blame] | 1669 | |
| 1670 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1671 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1672 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1673 | uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1674 | { |
| 1675 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1676 | uint8_t hash_index; |
| 1677 | struct wlan_objmgr_peer *peer = NULL; |
| 1678 | struct wlan_peer_list *peer_list; |
| 1679 | |
| 1680 | /* psoc lock should be taken before peer list lock */ |
| 1681 | wlan_psoc_obj_lock(psoc); |
| 1682 | objmgr = &psoc->soc_objmgr; |
| 1683 | /* List is empty, return NULL */ |
| 1684 | if (objmgr->wlan_peer_count == 0) { |
| 1685 | wlan_psoc_obj_unlock(psoc); |
| 1686 | return NULL; |
| 1687 | } |
| 1688 | /* reduce the search window, with hash key */ |
| 1689 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1690 | peer_list = &objmgr->peer_list; |
| 1691 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1692 | /* Iterate through peer list, get peer */ |
| 1693 | peer = wlan_obj_psoc_peerlist_get_peer_no_state( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1694 | &peer_list->peer_hash[hash_index], macaddr, pdev_id, dbg_id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1695 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1696 | wlan_psoc_obj_unlock(psoc); |
| 1697 | |
| 1698 | return peer; |
| 1699 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1700 | qdf_export_symbol(wlan_objmgr_get_peer_no_state); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1701 | |
| 1702 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1703 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1704 | uint8_t *bssid, uint8_t *macaddr, |
| 1705 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1706 | { |
| 1707 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1708 | uint8_t hash_index; |
| 1709 | struct wlan_objmgr_peer *peer = NULL; |
| 1710 | struct wlan_peer_list *peer_list; |
| 1711 | |
| 1712 | /* psoc lock should be taken before peer list lock */ |
| 1713 | wlan_psoc_obj_lock(psoc); |
| 1714 | objmgr = &psoc->soc_objmgr; |
| 1715 | /* List is empty, return NULL */ |
| 1716 | if (objmgr->wlan_peer_count == 0) { |
| 1717 | wlan_psoc_obj_unlock(psoc); |
| 1718 | return NULL; |
| 1719 | } |
| 1720 | /* reduce the search window, with hash key */ |
| 1721 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1722 | peer_list = &objmgr->peer_list; |
| 1723 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1724 | /* Iterate through peer list, get peer */ |
| 1725 | peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1726 | &peer_list->peer_hash[hash_index], macaddr, bssid, |
| 1727 | pdev_id, dbg_id); |
Srinivas Pitla | eb76bcd | 2017-01-05 12:57:32 +0530 | [diff] [blame] | 1728 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1729 | wlan_psoc_obj_unlock(psoc); |
| 1730 | |
Srinivas Pitla | fa5290f | 2016-10-17 16:40:37 +0530 | [diff] [blame] | 1731 | return peer; |
| 1732 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1733 | qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1734 | |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1735 | |
| 1736 | /** |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1737 | * wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev() - get peer from psoc |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1738 | * peer list using |
| 1739 | * mac and vdev |
| 1740 | * self mac |
| 1741 | * @psoc: PSOC object |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1742 | * @pdev_id: Pdev id |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1743 | * @macaddr: MAC address |
Kiran Venkatappa | 111dcb8 | 2017-12-15 22:42:27 +0530 | [diff] [blame] | 1744 | * @bssid: BSSID address. NULL mac means search all. |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1745 | * @dbg_id: id of the caller |
| 1746 | * |
| 1747 | * API to finds peer object pointer by MAC addr and BSSID from |
| 1748 | * peer hash list, bssid check is done on matching peer |
| 1749 | * |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1750 | * Return: list of peer pointer pointers |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1751 | * NULL on FAILURE |
| 1752 | */ |
| 1753 | |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1754 | qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1755 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1756 | uint8_t *bssid, uint8_t *macaddr, |
| 1757 | wlan_objmgr_ref_dbgid dbg_id) |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1758 | { |
| 1759 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1760 | uint8_t hash_index; |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1761 | struct wlan_peer_list *peer_list = NULL; |
| 1762 | qdf_list_t *logical_del_peer_list = NULL; |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1763 | |
| 1764 | /* psoc lock should be taken before peer list lock */ |
| 1765 | wlan_psoc_obj_lock(psoc); |
| 1766 | objmgr = &psoc->soc_objmgr; |
| 1767 | /* List is empty, return NULL */ |
| 1768 | if (objmgr->wlan_peer_count == 0) { |
| 1769 | wlan_psoc_obj_unlock(psoc); |
| 1770 | return NULL; |
| 1771 | } |
| 1772 | /* reduce the search window, with hash key */ |
| 1773 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1774 | peer_list = &objmgr->peer_list; |
| 1775 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1776 | |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1777 | /* Iterate through peer list, get peer */ |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1778 | logical_del_peer_list = |
| 1779 | wlan_obj_psoc_populate_logically_del_peerlist_by_mac_n_bssid( |
| 1780 | &peer_list->peer_hash[hash_index], macaddr, |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1781 | bssid, pdev_id, dbg_id); |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1782 | |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1783 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1784 | wlan_psoc_obj_unlock(psoc); |
| 1785 | |
Soumya Bhat | 5d0786b | 2017-06-08 11:52:17 +0530 | [diff] [blame] | 1786 | return logical_del_peer_list; |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1787 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1788 | qdf_export_symbol(wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev); |
Nandha Kishore Easwaran | 9b820f5 | 2017-03-16 20:18:25 +0530 | [diff] [blame] | 1789 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1790 | struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_no_state( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1791 | struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, |
| 1792 | uint8_t *bssid, uint8_t *macaddr, |
| 1793 | wlan_objmgr_ref_dbgid dbg_id) |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1794 | { |
| 1795 | struct wlan_objmgr_psoc_objmgr *objmgr; |
| 1796 | uint8_t hash_index; |
| 1797 | struct wlan_objmgr_peer *peer = NULL; |
| 1798 | struct wlan_peer_list *peer_list; |
| 1799 | |
| 1800 | /* psoc lock should be taken before peer list lock */ |
| 1801 | wlan_psoc_obj_lock(psoc); |
| 1802 | objmgr = &psoc->soc_objmgr; |
| 1803 | /* List is empty, return NULL */ |
| 1804 | if (objmgr->wlan_peer_count == 0) { |
| 1805 | wlan_psoc_obj_unlock(psoc); |
| 1806 | return NULL; |
| 1807 | } |
| 1808 | /* reduce the search window, with hash key */ |
| 1809 | hash_index = WLAN_PEER_HASH(macaddr); |
| 1810 | peer_list = &objmgr->peer_list; |
| 1811 | qdf_spin_lock_bh(&peer_list->peer_list_lock); |
| 1812 | /* Iterate through peer list, get peer */ |
| 1813 | peer = wlan_obj_psoc_peerlist_get_peer_by_mac_n_bssid_no_state( |
Amir Patel | d338594 | 2018-05-03 23:01:08 +0530 | [diff] [blame] | 1814 | &peer_list->peer_hash[hash_index], macaddr, bssid, |
| 1815 | pdev_id, dbg_id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1816 | qdf_spin_unlock_bh(&peer_list->peer_list_lock); |
| 1817 | wlan_psoc_obj_unlock(psoc); |
| 1818 | |
| 1819 | return peer; |
| 1820 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1821 | qdf_export_symbol(wlan_objmgr_get_peer_by_mac_n_vdev_no_state); |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 1822 | |
| 1823 | void *wlan_objmgr_psoc_get_comp_private_obj(struct wlan_objmgr_psoc *psoc, |
| 1824 | enum wlan_umac_comp_id id) |
| 1825 | { |
| 1826 | void *comp_private_obj; |
| 1827 | |
Srinivas Pitla | 1a2ef8c | 2017-01-04 16:48:00 +0530 | [diff] [blame] | 1828 | /* component id is invalid */ |
| 1829 | if (id >= WLAN_UMAC_MAX_COMPONENTS) { |
| 1830 | QDF_BUG(0); |
| 1831 | return NULL; |
| 1832 | } |
| 1833 | |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1834 | if (!psoc) { |
Srinivas Pitla | 1a2ef8c | 2017-01-04 16:48:00 +0530 | [diff] [blame] | 1835 | QDF_BUG(0); |
| 1836 | return NULL; |
| 1837 | } |
| 1838 | |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 1839 | comp_private_obj = psoc->soc_comp_priv_obj[id]; |
Selvaraj, Sridhar | afd3a5b | 2017-01-04 11:00:10 +0530 | [diff] [blame] | 1840 | |
| 1841 | return comp_private_obj; |
| 1842 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1843 | qdf_export_symbol(wlan_objmgr_psoc_get_comp_private_obj); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1844 | |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1845 | void wlan_objmgr_psoc_get_ref(struct wlan_objmgr_psoc *psoc, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1846 | wlan_objmgr_ref_dbgid id) |
| 1847 | { |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1848 | if (!psoc) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1849 | obj_mgr_err("psoc obj is NULL for id:%d", id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1850 | QDF_ASSERT(0); |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1851 | return; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1852 | } |
| 1853 | /* Increment ref count */ |
| 1854 | qdf_atomic_inc(&psoc->soc_objmgr.ref_cnt); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1855 | qdf_atomic_inc(&psoc->soc_objmgr.ref_id_dbg[id]); |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1856 | return; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1857 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1858 | qdf_export_symbol(wlan_objmgr_psoc_get_ref); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1859 | |
| 1860 | QDF_STATUS wlan_objmgr_psoc_try_get_ref(struct wlan_objmgr_psoc *psoc, |
| 1861 | wlan_objmgr_ref_dbgid id) |
| 1862 | { |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1863 | if (!psoc) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1864 | obj_mgr_err("psoc obj is NULL for id:%d", id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1865 | QDF_ASSERT(0); |
| 1866 | return QDF_STATUS_E_FAILURE; |
| 1867 | } |
| 1868 | |
| 1869 | wlan_psoc_obj_lock(psoc); |
Srinivas Pitla | 86db6ab | 2018-01-16 10:20:38 +0530 | [diff] [blame] | 1870 | if (psoc->obj_state != WLAN_OBJ_STATE_CREATED) { |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1871 | wlan_psoc_obj_unlock(psoc); |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1872 | if (psoc->soc_objmgr.print_cnt++ <= |
| 1873 | WLAN_OBJMGR_RATELIMIT_THRESH) |
Srinivas Pitla | 86db6ab | 2018-01-16 10:20:38 +0530 | [diff] [blame] | 1874 | obj_mgr_err( |
| 1875 | "[Ref id: %d] psoc is not in Created state(%d)", |
| 1876 | id, psoc->obj_state); |
Srinivas Pitla | 6856482 | 2017-06-28 12:33:07 +0530 | [diff] [blame] | 1877 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1878 | return QDF_STATUS_E_RESOURCES; |
| 1879 | } |
| 1880 | |
| 1881 | /* Increment ref count */ |
| 1882 | wlan_objmgr_psoc_get_ref(psoc, id); |
| 1883 | wlan_psoc_obj_unlock(psoc); |
| 1884 | |
| 1885 | return QDF_STATUS_SUCCESS; |
| 1886 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1887 | qdf_export_symbol(wlan_objmgr_psoc_try_get_ref); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1888 | |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1889 | void wlan_objmgr_psoc_release_ref(struct wlan_objmgr_psoc *psoc, |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1890 | wlan_objmgr_ref_dbgid id) |
| 1891 | { |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1892 | if (!psoc) { |
Vivek | 5747b78 | 2018-01-04 17:26:58 +0530 | [diff] [blame] | 1893 | obj_mgr_err("psoc obj is NULL for id:%d", id); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1894 | QDF_ASSERT(0); |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1895 | return; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1896 | } |
| 1897 | |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1898 | if (!qdf_atomic_read(&psoc->soc_objmgr.ref_id_dbg[id])) { |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1899 | obj_mgr_err("psoc ref cnt was not taken by %d", id); |
Abhinav Kumar | 9791957 | 2018-06-15 16:46:30 +0530 | [diff] [blame] | 1900 | wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, |
| 1901 | QDF_TRACE_LEVEL_FATAL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1902 | WLAN_OBJMGR_BUG(0); |
| 1903 | } |
| 1904 | |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1905 | if (!qdf_atomic_read(&psoc->soc_objmgr.ref_cnt)) { |
Vivek | 2c86b21 | 2017-06-05 00:02:11 +0530 | [diff] [blame] | 1906 | obj_mgr_err("psoc ref cnt is 0"); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1907 | WLAN_OBJMGR_BUG(0); |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1908 | return; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1909 | } |
| 1910 | |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1911 | qdf_atomic_dec(&psoc->soc_objmgr.ref_id_dbg[id]); |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1912 | /* Decrement ref count, free psoc, if ref count == 0 */ |
| 1913 | if (qdf_atomic_dec_and_test(&psoc->soc_objmgr.ref_cnt)) |
| 1914 | wlan_objmgr_psoc_obj_destroy(psoc); |
| 1915 | |
Vivek | 8ed2fe9 | 2017-09-15 18:34:49 +0530 | [diff] [blame] | 1916 | return; |
Srinivas Pitla | 10aa60c | 2017-02-08 12:55:16 +0530 | [diff] [blame] | 1917 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1918 | qdf_export_symbol(wlan_objmgr_psoc_release_ref); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1919 | |
| 1920 | static void wlan_objmgr_psoc_peer_ref_print(struct wlan_objmgr_psoc *psoc, |
| 1921 | void *obj, void *args) |
| 1922 | { |
| 1923 | struct wlan_objmgr_peer *peer = (struct wlan_objmgr_peer *)obj; |
Om Prakash Tripathi | f061845 | 2018-04-05 17:24:47 +0530 | [diff] [blame] | 1924 | WLAN_OBJ_STATE obj_state; |
| 1925 | uint8_t vdev_id; |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1926 | uint8_t *macaddr; |
| 1927 | |
| 1928 | wlan_peer_obj_lock(peer); |
| 1929 | macaddr = wlan_peer_get_macaddr(peer); |
Om Prakash Tripathi | f061845 | 2018-04-05 17:24:47 +0530 | [diff] [blame] | 1930 | obj_state = peer->obj_state; |
| 1931 | vdev_id = wlan_vdev_get_id(wlan_peer_get_vdev(peer)); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1932 | wlan_peer_obj_unlock(peer); |
| 1933 | |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1934 | obj_mgr_alert("Peer MAC:%02x:%02x:%02x:%02x:%02x:%02x state:%d vdev_id:%d", |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1935 | macaddr[0], macaddr[1], macaddr[2], macaddr[3], |
Om Prakash Tripathi | f061845 | 2018-04-05 17:24:47 +0530 | [diff] [blame] | 1936 | macaddr[4], macaddr[5], obj_state, vdev_id); |
Om Prakash Tripathi | bf3428b | 2018-08-02 18:25:35 +0530 | [diff] [blame] | 1937 | wlan_objmgr_print_peer_ref_ids(peer, QDF_TRACE_LEVEL_FATAL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1938 | } |
| 1939 | |
| 1940 | static void wlan_objmgr_psoc_vdev_ref_print(struct wlan_objmgr_psoc *psoc, |
| 1941 | void *obj, void *args) |
| 1942 | { |
| 1943 | struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; |
Om Prakash Tripathi | f061845 | 2018-04-05 17:24:47 +0530 | [diff] [blame] | 1944 | WLAN_OBJ_STATE obj_state; |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1945 | uint8_t id; |
| 1946 | |
| 1947 | wlan_vdev_obj_lock(vdev); |
| 1948 | id = wlan_vdev_get_id(vdev); |
Om Prakash Tripathi | f061845 | 2018-04-05 17:24:47 +0530 | [diff] [blame] | 1949 | obj_state = vdev->obj_state; |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1950 | wlan_vdev_obj_unlock(vdev); |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1951 | obj_mgr_alert("Vdev ID is %d, state %d", id, obj_state); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1952 | |
Abhinav Kumar | 9791957 | 2018-06-15 16:46:30 +0530 | [diff] [blame] | 1953 | wlan_objmgr_print_ref_ids(vdev->vdev_objmgr.ref_id_dbg, |
| 1954 | QDF_TRACE_LEVEL_FATAL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1955 | } |
| 1956 | |
| 1957 | static void wlan_objmgr_psoc_pdev_ref_print(struct wlan_objmgr_psoc *psoc, |
| 1958 | void *obj, void *args) |
| 1959 | { |
| 1960 | struct wlan_objmgr_pdev *pdev = (struct wlan_objmgr_pdev *)obj; |
| 1961 | uint8_t id; |
| 1962 | |
| 1963 | wlan_pdev_obj_lock(pdev); |
Vivek | 2c86b21 | 2017-06-05 00:02:11 +0530 | [diff] [blame] | 1964 | id = wlan_objmgr_pdev_get_pdev_id(pdev); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1965 | wlan_pdev_obj_unlock(pdev); |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1966 | obj_mgr_alert("pdev ID is %d", id); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1967 | |
Abhinav Kumar | 9791957 | 2018-06-15 16:46:30 +0530 | [diff] [blame] | 1968 | wlan_objmgr_print_ref_ids(pdev->pdev_objmgr.ref_id_dbg, |
| 1969 | QDF_TRACE_LEVEL_FATAL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1970 | } |
| 1971 | |
| 1972 | QDF_STATUS wlan_objmgr_print_ref_all_objects_per_psoc( |
| 1973 | struct wlan_objmgr_psoc *psoc) |
| 1974 | { |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1975 | obj_mgr_alert("Ref counts of PEER"); |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 1976 | wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_PEER_OP, |
| 1977 | wlan_objmgr_psoc_peer_ref_print, NULL); |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1978 | obj_mgr_alert("Ref counts of VDEV"); |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 1979 | wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_VDEV_OP, |
| 1980 | wlan_objmgr_psoc_vdev_ref_print, NULL); |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1981 | obj_mgr_alert("Ref counts of PDEV"); |
Srinivas Pitla | 6c56b09 | 2018-03-22 17:02:39 +0530 | [diff] [blame] | 1982 | wlan_objmgr_iterate_obj_list_all_noref(psoc, WLAN_PDEV_OP, |
| 1983 | wlan_objmgr_psoc_pdev_ref_print, NULL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1984 | |
Akshay Kosigi | 41da247 | 2018-04-12 15:31:44 +0530 | [diff] [blame] | 1985 | obj_mgr_alert(" Ref counts of PSOC"); |
Abhinav Kumar | 9791957 | 2018-06-15 16:46:30 +0530 | [diff] [blame] | 1986 | wlan_objmgr_print_ref_ids(psoc->soc_objmgr.ref_id_dbg, |
| 1987 | QDF_TRACE_LEVEL_FATAL); |
Srinivas Pitla | 2f8f8b5 | 2017-02-08 12:55:36 +0530 | [diff] [blame] | 1988 | |
| 1989 | return QDF_STATUS_SUCCESS; |
| 1990 | } |
Manikandan Mohan | 0f3c99b | 2018-03-01 16:22:44 -0800 | [diff] [blame] | 1991 | qdf_export_symbol(wlan_objmgr_print_ref_all_objects_per_psoc); |
Tushnim Bhattacharyya | 99554a3 | 2017-03-02 14:58:21 -0800 | [diff] [blame] | 1992 | |
| 1993 | QDF_STATUS wlan_objmgr_psoc_set_user_config(struct wlan_objmgr_psoc *psoc, |
| 1994 | struct wlan_objmgr_psoc_user_config *user_config_data) |
| 1995 | { |
Jeff Johnson | dcb2769 | 2019-03-20 12:11:48 -0700 | [diff] [blame] | 1996 | if (!user_config_data) { |
Vivek | 2c86b21 | 2017-06-05 00:02:11 +0530 | [diff] [blame] | 1997 | obj_mgr_err("user_config_data is NULL"); |
Tushnim Bhattacharyya | 99554a3 | 2017-03-02 14:58:21 -0800 | [diff] [blame] | 1998 | QDF_BUG(0); |
| 1999 | return QDF_STATUS_E_FAILURE; |
| 2000 | } |
| 2001 | wlan_psoc_obj_lock(psoc); |
| 2002 | qdf_mem_copy(&psoc->soc_nif.user_config, user_config_data, |
Srinivas Pitla | 86db6ab | 2018-01-16 10:20:38 +0530 | [diff] [blame] | 2003 | sizeof(psoc->soc_nif.user_config)); |
Tushnim Bhattacharyya | 99554a3 | 2017-03-02 14:58:21 -0800 | [diff] [blame] | 2004 | wlan_psoc_obj_unlock(psoc); |
| 2005 | |
| 2006 | return QDF_STATUS_SUCCESS; |
| 2007 | } |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2008 | |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2009 | void wlan_objmgr_psoc_check_for_pdev_leaks(struct wlan_objmgr_psoc *psoc) |
| 2010 | { |
| 2011 | struct wlan_objmgr_psoc_objmgr *_psoc; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2012 | struct wlan_objmgr_pdev *pdev; |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2013 | int pdev_id; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2014 | uint32_t leaks = 0; |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2015 | |
| 2016 | QDF_BUG(psoc); |
| 2017 | if (!psoc) |
| 2018 | return; |
| 2019 | |
| 2020 | wlan_psoc_obj_lock(psoc); |
| 2021 | _psoc = &psoc->soc_objmgr; |
| 2022 | if (!_psoc->wlan_pdev_count) { |
| 2023 | wlan_psoc_obj_unlock(psoc); |
| 2024 | return; |
| 2025 | } |
| 2026 | |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2027 | obj_mgr_alert("objmgr pdev leaks detected for psoc %u!", |
| 2028 | _psoc->psoc_id); |
| 2029 | obj_mgr_alert("----------------------------------------------------"); |
| 2030 | obj_mgr_alert("Pdev Id Refs Module"); |
| 2031 | obj_mgr_alert("----------------------------------------------------"); |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2032 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2033 | wlan_objmgr_for_each_psoc_pdev(psoc, pdev_id, pdev) { |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2034 | qdf_atomic_t *ref_id_dbg; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2035 | int ref_id; |
| 2036 | int32_t refs; |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2037 | |
| 2038 | wlan_pdev_obj_lock(pdev); |
| 2039 | ref_id_dbg = pdev->pdev_objmgr.ref_id_dbg; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2040 | wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { |
| 2041 | leaks++; |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2042 | obj_mgr_alert("%7u %4u %s", |
| 2043 | pdev_id, refs, |
| 2044 | string_from_dbgid(ref_id)); |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2045 | } |
| 2046 | wlan_pdev_obj_unlock(pdev); |
| 2047 | } |
| 2048 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2049 | QDF_DEBUG_PANIC("%u objmgr pdev leaks detected for psoc %u!", |
| 2050 | leaks, _psoc->psoc_id); |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2051 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2052 | wlan_psoc_obj_unlock(psoc); |
Dustin Brown | a8eefc8 | 2018-06-18 14:01:25 -0700 | [diff] [blame] | 2053 | } |
| 2054 | qdf_export_symbol(wlan_objmgr_psoc_check_for_pdev_leaks); |
| 2055 | |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2056 | void wlan_objmgr_psoc_check_for_vdev_leaks(struct wlan_objmgr_psoc *psoc) |
| 2057 | { |
| 2058 | struct wlan_objmgr_psoc_objmgr *_psoc; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2059 | struct wlan_objmgr_vdev *vdev; |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2060 | int vdev_id; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2061 | uint32_t leaks = 0; |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2062 | |
| 2063 | QDF_BUG(psoc); |
| 2064 | if (!psoc) |
| 2065 | return; |
| 2066 | |
| 2067 | wlan_psoc_obj_lock(psoc); |
| 2068 | _psoc = &psoc->soc_objmgr; |
| 2069 | if (!_psoc->wlan_vdev_count) { |
| 2070 | wlan_psoc_obj_unlock(psoc); |
| 2071 | return; |
| 2072 | } |
| 2073 | |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2074 | obj_mgr_alert("objmgr vdev leaks detected for psoc %u!", |
| 2075 | _psoc->psoc_id); |
| 2076 | obj_mgr_alert("----------------------------------------------------"); |
| 2077 | obj_mgr_alert("Vdev Id Refs Module"); |
| 2078 | obj_mgr_alert("----------------------------------------------------"); |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2079 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2080 | wlan_objmgr_for_each_psoc_vdev(psoc, vdev_id, vdev) { |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2081 | qdf_atomic_t *ref_id_dbg; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2082 | int ref_id; |
| 2083 | int32_t refs; |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2084 | |
| 2085 | wlan_vdev_obj_lock(vdev); |
| 2086 | ref_id_dbg = vdev->vdev_objmgr.ref_id_dbg; |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2087 | wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { |
| 2088 | leaks++; |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2089 | obj_mgr_alert("%7u %4u %s", |
| 2090 | vdev_id, refs, string_from_dbgid(ref_id)); |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2091 | } |
| 2092 | wlan_vdev_obj_unlock(vdev); |
| 2093 | } |
| 2094 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2095 | QDF_DEBUG_PANIC("%u objmgr vdev leaks detected for psoc %u!", |
| 2096 | leaks, _psoc->psoc_id); |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2097 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2098 | wlan_psoc_obj_unlock(psoc); |
Dustin Brown | 028f560 | 2018-05-24 14:43:29 -0700 | [diff] [blame] | 2099 | } |
| 2100 | qdf_export_symbol(wlan_objmgr_psoc_check_for_vdev_leaks); |
| 2101 | |
Om Prakash Tripathi | bf3428b | 2018-08-02 18:25:35 +0530 | [diff] [blame] | 2102 | #ifdef WLAN_OBJMGR_REF_ID_DEBUG |
| 2103 | static void |
| 2104 | wlan_objmgr_print_peer_ref_leaks(struct wlan_objmgr_peer *peer, int vdev_id) |
| 2105 | { |
| 2106 | qdf_atomic_t *ref_id_dbg; |
| 2107 | int32_t refs; |
| 2108 | int ref_id; |
| 2109 | |
| 2110 | ref_id_dbg = peer->peer_objmgr.ref_id_dbg; |
| 2111 | wlan_objmgr_for_each_refs(ref_id_dbg, ref_id, refs) { |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2112 | obj_mgr_alert(QDF_MAC_ADDR_STR " %7u %4u %s", |
| 2113 | QDF_MAC_ADDR_ARRAY(peer->macaddr), |
| 2114 | vdev_id, |
| 2115 | refs, |
| 2116 | string_from_dbgid(ref_id)); |
Om Prakash Tripathi | bf3428b | 2018-08-02 18:25:35 +0530 | [diff] [blame] | 2117 | } |
| 2118 | } |
| 2119 | #else |
| 2120 | static inline void |
| 2121 | wlan_objmgr_print_peer_ref_leaks(struct wlan_objmgr_peer *peer, int vdev_id) |
| 2122 | { |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2123 | obj_mgr_alert(QDF_MAC_ADDR_STR " %7u %4u %s", |
| 2124 | QDF_MAC_ADDR_ARRAY(peer->macaddr), |
| 2125 | vdev_id, |
| 2126 | qdf_atomic_read(&peer->peer_objmgr.ref_cnt), |
| 2127 | "TOTAL_REF_COUNT"); |
Om Prakash Tripathi | bf3428b | 2018-08-02 18:25:35 +0530 | [diff] [blame] | 2128 | } |
| 2129 | #endif |
| 2130 | |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2131 | void wlan_objmgr_psoc_check_for_peer_leaks(struct wlan_objmgr_psoc *psoc) |
| 2132 | { |
| 2133 | struct wlan_objmgr_psoc_objmgr *_psoc; |
| 2134 | struct wlan_objmgr_vdev *vdev; |
| 2135 | int vdev_id; |
| 2136 | uint32_t leaks = 0; |
| 2137 | |
| 2138 | QDF_BUG(psoc); |
| 2139 | if (!psoc) |
| 2140 | return; |
| 2141 | |
| 2142 | wlan_psoc_obj_lock(psoc); |
| 2143 | _psoc = &psoc->soc_objmgr; |
| 2144 | if (!_psoc->temp_peer_count && !_psoc->wlan_peer_count) { |
| 2145 | wlan_psoc_obj_unlock(psoc); |
| 2146 | return; |
| 2147 | } |
| 2148 | |
Vivek | 994f98b | 2018-10-11 11:07:32 +0530 | [diff] [blame] | 2149 | obj_mgr_alert("objmgr peer leaks detected for psoc %u!", |
| 2150 | _psoc->psoc_id); |
| 2151 | obj_mgr_alert("----------------------------------------------------"); |
| 2152 | obj_mgr_alert("Peer MAC Vdev Id Refs Module"); |
| 2153 | obj_mgr_alert("----------------------------------------------------"); |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2154 | |
| 2155 | wlan_objmgr_for_each_psoc_vdev(psoc, vdev_id, vdev) { |
| 2156 | struct wlan_objmgr_peer *peer; |
| 2157 | |
| 2158 | wlan_vdev_obj_lock(vdev); |
| 2159 | wlan_objmgr_for_each_vdev_peer(vdev, peer) { |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2160 | wlan_peer_obj_lock(peer); |
Om Prakash Tripathi | bf3428b | 2018-08-02 18:25:35 +0530 | [diff] [blame] | 2161 | leaks += qdf_atomic_read(&peer->peer_objmgr.ref_cnt); |
| 2162 | wlan_objmgr_print_peer_ref_leaks(peer, vdev_id); |
Dustin Brown | a0e0bbc | 2018-07-25 13:22:17 -0700 | [diff] [blame] | 2163 | wlan_peer_obj_unlock(peer); |
| 2164 | } |
| 2165 | wlan_vdev_obj_unlock(vdev); |
| 2166 | } |
| 2167 | |
| 2168 | QDF_DEBUG_PANIC("%u objmgr peer leaks detected for psoc %u!", |
| 2169 | leaks, _psoc->psoc_id); |
| 2170 | |
| 2171 | wlan_psoc_obj_unlock(psoc); |
| 2172 | } |
| 2173 | qdf_export_symbol(wlan_objmgr_psoc_check_for_peer_leaks); |
Vivek | 4ad877f | 2019-09-18 16:49:10 +0530 | [diff] [blame^] | 2174 | |
| 2175 | #ifdef WLAN_OBJMGR_DEBUG |
| 2176 | void wlan_print_psoc_info(struct wlan_objmgr_psoc *psoc) |
| 2177 | { |
| 2178 | struct wlan_objmgr_psoc_objmgr *psoc_objmgr; |
| 2179 | struct wlan_objmgr_pdev *pdev; |
| 2180 | struct wlan_objmgr_vdev *vdev; |
| 2181 | uint16_t index = 0; |
| 2182 | |
| 2183 | psoc_objmgr = &psoc->soc_objmgr; |
| 2184 | |
| 2185 | obj_mgr_debug("psoc: %pK", psoc); |
| 2186 | obj_mgr_debug("psoc_id: %d", psoc_objmgr->psoc_id); |
| 2187 | obj_mgr_debug("wlan_pdev_count: %d", psoc_objmgr->wlan_pdev_count); |
| 2188 | obj_mgr_debug("wlan_pdev_id_map: 0x%x", psoc_objmgr->wlan_pdev_id_map); |
| 2189 | obj_mgr_debug("wlan_vdev_count: %d", psoc_objmgr->wlan_vdev_count); |
| 2190 | obj_mgr_debug("max_vdev_count: %d", psoc_objmgr->max_vdev_count); |
| 2191 | obj_mgr_debug("wlan_peer_count: %d", psoc_objmgr->wlan_peer_count); |
| 2192 | obj_mgr_debug("max_peer_count: %d", psoc_objmgr->max_peer_count); |
| 2193 | obj_mgr_debug("temp_peer_count: %d", psoc_objmgr->temp_peer_count); |
| 2194 | obj_mgr_debug("ref_cnt: %d", qdf_atomic_read(&psoc_objmgr->ref_cnt)); |
| 2195 | obj_mgr_debug("qdf_dev: %pK", psoc_objmgr->qdf_dev); |
| 2196 | |
| 2197 | obj_mgr_debug("wlan_vdev_id_map[%d]: 0x%x", |
| 2198 | index, psoc_objmgr->wlan_vdev_id_map[index]); |
| 2199 | index++; |
| 2200 | obj_mgr_debug("wlan_vdev_id_map[%d]: 0x%x", |
| 2201 | index, psoc_objmgr->wlan_vdev_id_map[index]); |
| 2202 | |
| 2203 | wlan_objmgr_for_each_psoc_pdev(psoc, index, pdev) { |
| 2204 | obj_mgr_debug("wlan_pdev_list[%d]: %pK", index, pdev); |
| 2205 | wlan_print_pdev_info(pdev); |
| 2206 | } |
| 2207 | |
| 2208 | wlan_objmgr_for_each_psoc_vdev(psoc, index, vdev) { |
| 2209 | obj_mgr_debug("wlan_vdev_list[%d]: %pK", index, vdev); |
| 2210 | wlan_print_vdev_info(vdev); |
| 2211 | } |
| 2212 | } |
| 2213 | |
| 2214 | qdf_export_symbol(wlan_print_psoc_info); |
| 2215 | #endif |