xref: /wlan-driver/qca-wifi-host-cmn/umac/cmn_services/serialization/src/wlan_serialization_main.c (revision 5113495b16420b49004c444715d2daae2066e7dc)
1 /*
2  * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
3  * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for
6  * any purpose with or without fee is hereby granted, provided that the
7  * above copyright notice and this permission notice appear in all
8  * copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17  * PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 /**
21  * DOC: wlan_serialization_main.c
22  * This file defines the important functions pertinent to
23  * serialization to initialize and de-initialize the
24  * component.
25  */
26 #include <qdf_status.h>
27 #include <qdf_list.h>
28 #include <wlan_objmgr_cmn.h>
29 #include <wlan_objmgr_global_obj.h>
30 #include <wlan_objmgr_psoc_obj.h>
31 #include "wlan_serialization_main_i.h"
32 #include "wlan_serialization_rules_i.h"
33 #include "wlan_serialization_utils_i.h"
34 
wlan_serialization_psoc_disable(struct wlan_objmgr_psoc * psoc)35 QDF_STATUS wlan_serialization_psoc_disable(struct wlan_objmgr_psoc *psoc)
36 {
37 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
38 	struct wlan_ser_psoc_obj *ser_soc_obj =
39 		wlan_serialization_get_psoc_obj(psoc);
40 
41 	if (!ser_soc_obj) {
42 		ser_err("invalid ser_soc_obj");
43 		goto error;
44 	}
45 
46 	/*
47 	 * purge all serialization command if there are any pending to make
48 	 * sure memory and vdev ref are freed.
49 	 */
50 	wlan_serialization_purge_all_cmd(psoc);
51 	/* clean up all timers before exiting */
52 	status = wlan_serialization_cleanup_all_timers(ser_soc_obj);
53 	if (status != QDF_STATUS_SUCCESS)
54 		ser_err("ser cleaning up all timer failed");
55 
56 	/* Use lock to free to avoid any race where timer is still in use */
57 	wlan_serialization_acquire_lock(&ser_soc_obj->timer_lock);
58 	qdf_mem_free(ser_soc_obj->timers);
59 	ser_soc_obj->timers = NULL;
60 	ser_soc_obj->max_active_cmds = 0;
61 	wlan_serialization_release_lock(&ser_soc_obj->timer_lock);
62 error:
63 	return status;
64 }
65 
wlan_serialization_psoc_enable(struct wlan_objmgr_psoc * psoc)66 QDF_STATUS wlan_serialization_psoc_enable(struct wlan_objmgr_psoc *psoc)
67 {
68 	uint8_t pdev_count;
69 	struct wlan_ser_psoc_obj *ser_soc_obj =
70 		wlan_serialization_get_psoc_obj(psoc);
71 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
72 
73 	if (!ser_soc_obj) {
74 		ser_err("invalid ser_soc_obj");
75 		goto error;
76 	}
77 
78 	pdev_count = wlan_psoc_get_pdev_count(psoc);
79 	ser_soc_obj->max_active_cmds = WLAN_SER_MAX_ACTIVE_SCAN_CMDS +
80 					(pdev_count * WLAN_SER_MAX_VDEVS);
81 
82 	ser_debug("max_active_cmds %d", ser_soc_obj->max_active_cmds);
83 
84 	ser_soc_obj->timers =
85 		qdf_mem_malloc(sizeof(struct wlan_serialization_timer) *
86 				ser_soc_obj->max_active_cmds);
87 	if (!ser_soc_obj->timers) {
88 		status = QDF_STATUS_E_NOMEM;
89 		goto error;
90 	}
91 
92 	status = QDF_STATUS_SUCCESS;
93 
94 error:
95 	return status;
96 }
97 
98 /**
99  * wlan_serialization_psoc_create_handler() - PSOC obj create callback
100  * @psoc: PSOC object
101  * @arg_list: Variable argument list
102  *
103  * This callback is registered with object manager during initialization and
104  * when obj manager gets its turn to create the object, it would notify each
105  * component with the corresponding callback registered to inform the
106  * completion of the creation of the respective object.
107  *
108  * Return: QDF Status
109  */
wlan_serialization_psoc_create_handler(struct wlan_objmgr_psoc * psoc,void * arg_list)110 static QDF_STATUS wlan_serialization_psoc_create_handler(
111 		struct wlan_objmgr_psoc *psoc, void *arg_list)
112 {
113 	struct wlan_ser_psoc_obj *soc_ser_obj;
114 	QDF_STATUS status = QDF_STATUS_E_NOMEM;
115 
116 	soc_ser_obj =
117 		qdf_mem_malloc(sizeof(*soc_ser_obj));
118 	if (!soc_ser_obj)
119 		goto error;
120 
121 	status = wlan_objmgr_psoc_component_obj_attach(
122 					psoc,
123 					WLAN_UMAC_COMP_SERIALIZATION,
124 					soc_ser_obj,
125 					QDF_STATUS_SUCCESS);
126 	if (QDF_IS_STATUS_ERROR(status)) {
127 		qdf_mem_free(soc_ser_obj);
128 		ser_err("Obj attach failed");
129 		goto error;
130 	}
131 	wlan_serialization_create_lock(&soc_ser_obj->timer_lock);
132 	ser_debug("ser psoc obj created");
133 	status = QDF_STATUS_SUCCESS;
134 
135 error:
136 	return status;
137 }
138 
139 /**
140  * wlan_serialization_destroy_cmd_pool() - Destroy the global cmd pool
141  * @pdev_queue: Serialization pdev queue
142  *
143  * Return: None
144  */
wlan_serialization_destroy_cmd_pool(struct wlan_serialization_pdev_queue * pdev_queue)145 static void wlan_serialization_destroy_cmd_pool(
146 		struct wlan_serialization_pdev_queue *pdev_queue)
147 {
148 	qdf_list_node_t *node = NULL;
149 
150 	ser_debug("Destroy cmd pool list %pK, size %d",
151 		  &pdev_queue->cmd_pool_list,
152 		  qdf_list_size(&pdev_queue->cmd_pool_list));
153 	while (!qdf_list_empty(&pdev_queue->cmd_pool_list)) {
154 		qdf_list_remove_front(&pdev_queue->cmd_pool_list,
155 				      &node);
156 		qdf_mem_free(node);
157 	}
158 
159 	qdf_list_destroy(&pdev_queue->cmd_pool_list);
160 
161 }
162 
163 /**
164  * wlan_serialization_create_cmd_pool() - Create the global cmd pool
165  * @pdev_queue: Serialization pdev queue
166  * @cmd_pool_size: Size of the command pool
167  *
168  * Global command pool of memory is created here.
169  * It is safe to allocate memory individually for each command rather than
170  * requesting for a huge chunk of memory at once.
171  *
172  * The individual command nodes allocated above will keep moving between
173  * the active, pending and global pool lists dynamically, but all the
174  * memory will be freed during driver unload only.
175  *
176  * Return: QDF Status
177  */
178 static QDF_STATUS
wlan_serialization_create_cmd_pool(struct wlan_serialization_pdev_queue * pdev_queue,uint16_t cmd_pool_size)179 wlan_serialization_create_cmd_pool(
180 		struct wlan_serialization_pdev_queue *pdev_queue,
181 		uint16_t cmd_pool_size)
182 {
183 	struct wlan_serialization_command_list *cmd_list_ptr;
184 	uint16_t i;
185 	QDF_STATUS status = QDF_STATUS_E_NOMEM;
186 
187 	qdf_list_create(&pdev_queue->cmd_pool_list, cmd_pool_size);
188 
189 	for (i = 0; i < cmd_pool_size; i++) {
190 		cmd_list_ptr = qdf_mem_malloc(sizeof(*cmd_list_ptr));
191 		if (!cmd_list_ptr) {
192 			wlan_serialization_destroy_cmd_pool(pdev_queue);
193 			goto error;
194 		}
195 
196 		qdf_mem_zero(cmd_list_ptr, sizeof(*cmd_list_ptr));
197 		qdf_list_insert_back(
198 				     &pdev_queue->cmd_pool_list,
199 				     &cmd_list_ptr->pdev_node);
200 		cmd_list_ptr->cmd_in_use = 0;
201 	}
202 
203 	ser_debug("Create cmd pool list %pK, size %d",
204 		  &pdev_queue->cmd_pool_list,
205 		  qdf_list_size(&pdev_queue->cmd_pool_list));
206 
207 	status = QDF_STATUS_SUCCESS;
208 
209 error:
210 	return status;
211 }
212 
213 /**
214  * wlan_serialization_pdev_create_handler() - PDEV obj create callback
215  * @pdev: PDEV object
216  * @arg_list: Variable argument list
217  *
218  * This callback is registered with object manager during initialization and
219  * when obj manager gets its turn to create the object, it would notify each
220  * component with the corresponding callback registered to inform the
221  * completion of the creation of the respective object.
222  *
223  * Return: QDF Status
224  */
wlan_serialization_pdev_create_handler(struct wlan_objmgr_pdev * pdev,void * arg_list)225 static QDF_STATUS wlan_serialization_pdev_create_handler(
226 		struct wlan_objmgr_pdev *pdev, void *arg_list)
227 {
228 	struct wlan_ser_pdev_obj *ser_pdev_obj;
229 	struct wlan_serialization_pdev_queue *pdev_queue;
230 	QDF_STATUS status = QDF_STATUS_E_NOMEM;
231 	uint8_t index;
232 	uint8_t free_index;
233 	uint16_t max_active_cmds;
234 	uint16_t max_pending_cmds;
235 	uint16_t cmd_pool_size;
236 
237 	ser_pdev_obj =
238 		qdf_mem_malloc(sizeof(*ser_pdev_obj));
239 	if (!ser_pdev_obj)
240 		goto error;
241 
242 	for (index = 0; index < SER_PDEV_QUEUE_COMP_MAX; index++) {
243 		pdev_queue = &ser_pdev_obj->pdev_q[index];
244 
245 		wlan_serialization_create_lock(&pdev_queue->pdev_queue_lock);
246 
247 		switch (index) {
248 		case SER_PDEV_QUEUE_COMP_SCAN:
249 			max_active_cmds = WLAN_SER_MAX_ACTIVE_SCAN_CMDS;
250 			max_pending_cmds = WLAN_SER_MAX_PENDING_SCAN_CMDS;
251 			cmd_pool_size = max_active_cmds + max_pending_cmds;
252 			break;
253 
254 		case SER_PDEV_QUEUE_COMP_NON_SCAN:
255 			max_active_cmds = WLAN_SER_MAX_ACTIVE_CMDS;
256 			max_pending_cmds = WLAN_SER_MAX_PENDING_CMDS;
257 			cmd_pool_size = max_active_cmds + max_pending_cmds;
258 			ser_debug("max_active_cmds %d max_pending_cmds %d",
259 				  max_active_cmds, max_pending_cmds);
260 			break;
261 		}
262 		qdf_list_create(&pdev_queue->active_list,
263 				max_active_cmds);
264 		qdf_list_create(&pdev_queue->pending_list,
265 				max_pending_cmds);
266 
267 		status = wlan_serialization_create_cmd_pool(pdev_queue,
268 							    cmd_pool_size);
269 		if (status != QDF_STATUS_SUCCESS) {
270 			ser_err("Create cmd pool failed, status %d", status);
271 			goto error_free;
272 		}
273 
274 		qdf_mem_zero(pdev_queue->vdev_active_cmd_bitmap,
275 			     sizeof(pdev_queue->vdev_active_cmd_bitmap));
276 
277 		pdev_queue->blocking_cmd_active = 0;
278 		pdev_queue->blocking_cmd_waiting = 0;
279 	}
280 
281 	status = wlan_objmgr_pdev_component_obj_attach(
282 			pdev, WLAN_UMAC_COMP_SERIALIZATION,
283 			ser_pdev_obj, QDF_STATUS_SUCCESS);
284 
285 	if (status != QDF_STATUS_SUCCESS) {
286 		ser_err("Pdev obj attach failed, status %d", status);
287 		goto error_free;
288 	}
289 
290 	return QDF_STATUS_SUCCESS;
291 
292 error_free:
293 	for (free_index = 0; free_index <= index; free_index++) {
294 		pdev_queue = &ser_pdev_obj->pdev_q[free_index];
295 
296 		wlan_serialization_destroy_cmd_pool(pdev_queue);
297 		qdf_list_destroy(&pdev_queue->pending_list);
298 		qdf_list_destroy(&pdev_queue->active_list);
299 		wlan_serialization_destroy_lock(&pdev_queue->pdev_queue_lock);
300 	}
301 error:
302 	return status;
303 }
304 
305 /**
306  * wlan_serialization_psoc_destroy_handler() - PSOC obj delete callback
307  * @psoc: PSOC object
308  * @arg_list: Variable argument list
309  *
310  * This callback is registered with object manager during initialization and
311  * when obj manager gets its turn to delete the object, it would notify each
312  * component with the corresponding callback registered to inform the
313  * completion of the deletion of the respective object.
314  *
315  * Return: QDF Status
316  */
317 static QDF_STATUS
wlan_serialization_psoc_destroy_handler(struct wlan_objmgr_psoc * psoc,void * arg_list)318 wlan_serialization_psoc_destroy_handler(struct wlan_objmgr_psoc *psoc,
319 					void *arg_list)
320 {
321 	QDF_STATUS status = QDF_STATUS_E_FAULT;
322 	struct wlan_ser_psoc_obj *ser_soc_obj =
323 		wlan_serialization_get_psoc_obj(psoc);
324 
325 	if (!ser_soc_obj) {
326 		ser_err("invalid ser_soc_obj");
327 		goto error;
328 	}
329 	status = wlan_objmgr_psoc_component_obj_detach(
330 			psoc, WLAN_UMAC_COMP_SERIALIZATION, ser_soc_obj);
331 	if (status != QDF_STATUS_SUCCESS)
332 		ser_err("ser psoc private obj detach failed");
333 
334 	wlan_serialization_destroy_lock(&ser_soc_obj->timer_lock);
335 	ser_debug("ser psoc obj deleted with status %d", status);
336 	qdf_mem_free(ser_soc_obj);
337 
338 error:
339 	return status;
340 }
341 
342 /**
343  * wlan_serialization_pdev_destroy_handler() - PDEV obj delete callback
344  * @pdev: PDEV object
345  * @arg_list: Variable argument list
346  *
347  * This callback is registered with object manager during initialization and
348  * when obj manager gets its turn to delete the object, it would notify each
349  * component with the corresponding callback registered to inform the
350  * completion of the deletion of the respective object.
351  *
352  * Return: QDF Status
353  */
wlan_serialization_pdev_destroy_handler(struct wlan_objmgr_pdev * pdev,void * arg_list)354 static QDF_STATUS wlan_serialization_pdev_destroy_handler(
355 		struct wlan_objmgr_pdev *pdev, void *arg_list)
356 {
357 	QDF_STATUS status;
358 	struct wlan_serialization_pdev_queue *pdev_queue;
359 	struct wlan_ser_pdev_obj *ser_pdev_obj =
360 		wlan_serialization_get_pdev_obj(pdev);
361 	uint8_t index;
362 
363 	if (!ser_pdev_obj) {
364 		ser_err("ser_pdev_obj NULL");
365 		return QDF_STATUS_E_INVAL;
366 	}
367 	status = wlan_objmgr_pdev_component_obj_detach(
368 			pdev, WLAN_UMAC_COMP_SERIALIZATION, ser_pdev_obj);
369 
370 	for (index = 0; index < SER_PDEV_QUEUE_COMP_MAX; index++) {
371 		pdev_queue = &ser_pdev_obj->pdev_q[index];
372 
373 		wlan_serialization_destroy_pdev_list(pdev_queue);
374 		wlan_serialization_destroy_cmd_pool(pdev_queue);
375 
376 		wlan_serialization_destroy_lock(&pdev_queue->pdev_queue_lock);
377 	}
378 	qdf_mem_free(ser_pdev_obj);
379 
380 	return status;
381 }
382 
383 /**
384  * wlan_serialization_vdev_create_handler() - VDEV obj create callback
385  * @vdev: VDEV object
386  * @arg_list: Variable argument list
387  *
388  * This callback is registered with object manager during initialization and
389  * when obj manager gets its turn to create the object, it would notify each
390  * component with the corresponding callback registered to inform the
391  * completion of the creation of the respective object.
392  *
393  * Return: QDF Status
394  */
395 static QDF_STATUS
wlan_serialization_vdev_create_handler(struct wlan_objmgr_vdev * vdev,void * arg_list)396 wlan_serialization_vdev_create_handler(struct wlan_objmgr_vdev *vdev,
397 				       void *arg_list)
398 {
399 	struct wlan_ser_vdev_obj *ser_vdev_obj;
400 	struct wlan_serialization_vdev_queue *vdev_q;
401 	QDF_STATUS status = QDF_STATUS_E_NOMEM;
402 	uint8_t index;
403 	uint8_t max_active_cmds;
404 	uint8_t max_pending_cmds;
405 
406 	ser_vdev_obj = qdf_mem_malloc(sizeof(*ser_vdev_obj));
407 	if (!ser_vdev_obj)
408 		goto error;
409 
410 	for (index = 0; index < SER_VDEV_QUEUE_COMP_MAX; index++) {
411 		vdev_q = &ser_vdev_obj->vdev_q[index];
412 
413 		switch (index) {
414 		case SER_VDEV_QUEUE_COMP_NON_SCAN:
415 			max_active_cmds = WLAN_SER_MAX_ACTIVE_CMDS /
416 				WLAN_SER_MAX_VDEVS;
417 			if (wlan_vdev_mlme_get_opmode(vdev) == QDF_SAP_MODE ||
418 			    wlan_vdev_mlme_get_opmode(vdev) == QDF_P2P_GO_MODE)
419 				max_pending_cmds = WLAN_SER_MAX_PENDING_CMDS_AP;
420 			else
421 				max_pending_cmds =
422 						WLAN_SER_MAX_PENDING_CMDS_STA;
423 
424 			ser_debug("Vdev type %d max_pending_cmds %d",
425 				  wlan_vdev_mlme_get_opmode(vdev),
426 				  max_pending_cmds);
427 			break;
428 		}
429 
430 		qdf_list_create(&vdev_q->active_list,
431 				max_active_cmds);
432 		qdf_list_create(&vdev_q->pending_list,
433 				max_pending_cmds);
434 	}
435 
436 	status = wlan_objmgr_vdev_component_obj_attach(
437 			vdev, WLAN_UMAC_COMP_SERIALIZATION, ser_vdev_obj,
438 			QDF_STATUS_SUCCESS);
439 
440 	if (status != QDF_STATUS_SUCCESS) {
441 		for (index = 0; index < SER_VDEV_QUEUE_COMP_MAX; index++) {
442 			vdev_q = &ser_vdev_obj->vdev_q[index];
443 			qdf_list_destroy(&vdev_q->pending_list);
444 			qdf_list_destroy(&vdev_q->active_list);
445 		}
446 		qdf_mem_free(ser_vdev_obj);
447 		ser_err("serialization vdev obj attach failed");
448 	}
449 error:
450 	return status;
451 }
452 
453 /**
454  * wlan_serialization_vdev_destroy_handler() - vdev obj delete callback
455  * @vdev: VDEV object
456  * @arg_list: Variable argument list
457  *
458  * This callback is registered with object manager during initialization and
459  * when obj manager gets its turn to delete the object, it would notify each
460  * component with the corresponding callback registered to inform the
461  * completion of the deletion of the respective object.
462  *
463  * Return: QDF Status
464  */
wlan_serialization_vdev_destroy_handler(struct wlan_objmgr_vdev * vdev,void * arg_list)465 static QDF_STATUS wlan_serialization_vdev_destroy_handler(
466 		struct wlan_objmgr_vdev *vdev, void *arg_list)
467 {
468 	QDF_STATUS status = QDF_STATUS_SUCCESS;
469 	struct wlan_serialization_vdev_queue *vdev_q;
470 	struct wlan_ser_vdev_obj *ser_vdev_obj =
471 		wlan_serialization_get_vdev_obj(vdev);
472 	uint8_t index;
473 
474 	if (!ser_vdev_obj) {
475 		ser_err("ser_vdev_obj NULL");
476 		return QDF_STATUS_E_INVAL;
477 	}
478 
479 	status = wlan_objmgr_vdev_component_obj_detach(
480 			vdev, WLAN_UMAC_COMP_SERIALIZATION, ser_vdev_obj);
481 
482 	/*Clean up serialization timers if any for this vdev*/
483 	wlan_serialization_cleanup_vdev_timers(vdev);
484 
485 	for (index = 0; index < SER_VDEV_QUEUE_COMP_MAX; index++) {
486 		vdev_q = &ser_vdev_obj->vdev_q[index];
487 		wlan_serialization_destroy_vdev_list(&vdev_q->pending_list);
488 		wlan_serialization_destroy_vdev_list(&vdev_q->active_list);
489 	}
490 
491 	qdf_mem_free(ser_vdev_obj);
492 
493 	return status;
494 }
495 
wlan_serialization_init(void)496 QDF_STATUS wlan_serialization_init(void)
497 {
498 	QDF_STATUS status = QDF_STATUS_SUCCESS;
499 
500 	status = wlan_objmgr_register_psoc_create_handler(
501 			WLAN_UMAC_COMP_SERIALIZATION,
502 			wlan_serialization_psoc_create_handler, NULL);
503 	if (status != QDF_STATUS_SUCCESS) {
504 		ser_err("Failed to reg soc ser obj create handler");
505 		goto err_psoc_create;
506 	}
507 
508 	status = wlan_objmgr_register_psoc_destroy_handler(
509 			WLAN_UMAC_COMP_SERIALIZATION,
510 			wlan_serialization_psoc_destroy_handler, NULL);
511 	if (status != QDF_STATUS_SUCCESS) {
512 		ser_err("Failed to reg soc ser obj delete handler");
513 		goto err_psoc_delete;
514 	}
515 
516 	status = wlan_objmgr_register_pdev_create_handler(
517 			WLAN_UMAC_COMP_SERIALIZATION,
518 			wlan_serialization_pdev_create_handler, NULL);
519 	if (status != QDF_STATUS_SUCCESS) {
520 		ser_err("Failed to reg pdev ser obj create handler");
521 		goto err_pdev_create;
522 	}
523 
524 	status = wlan_objmgr_register_pdev_destroy_handler(
525 			WLAN_UMAC_COMP_SERIALIZATION,
526 			wlan_serialization_pdev_destroy_handler, NULL);
527 	if (status != QDF_STATUS_SUCCESS) {
528 		ser_err("Failed to reg pdev ser obj delete handler");
529 		goto err_pdev_delete;
530 	}
531 
532 	status = wlan_objmgr_register_vdev_create_handler(
533 			WLAN_UMAC_COMP_SERIALIZATION,
534 			wlan_serialization_vdev_create_handler, NULL);
535 	if (status != QDF_STATUS_SUCCESS) {
536 		ser_err("Failed to reg vdev ser obj create handler");
537 		goto err_vdev_create;
538 	}
539 
540 	status = wlan_objmgr_register_vdev_destroy_handler(
541 			WLAN_UMAC_COMP_SERIALIZATION,
542 			wlan_serialization_vdev_destroy_handler, NULL);
543 	if (status != QDF_STATUS_SUCCESS) {
544 		ser_err("Failed to reg vdev ser obj delete handler");
545 		goto err_vdev_delete;
546 	}
547 
548 	status = QDF_STATUS_SUCCESS;
549 	goto exit;
550 
551 err_vdev_delete:
552 	wlan_objmgr_unregister_vdev_create_handler(
553 			WLAN_UMAC_COMP_SERIALIZATION,
554 			wlan_serialization_vdev_create_handler,
555 			NULL);
556 err_vdev_create:
557 	wlan_objmgr_unregister_pdev_destroy_handler(
558 			WLAN_UMAC_COMP_SERIALIZATION,
559 			wlan_serialization_pdev_destroy_handler,
560 			NULL);
561 err_pdev_delete:
562 	wlan_objmgr_unregister_pdev_create_handler(
563 			WLAN_UMAC_COMP_SERIALIZATION,
564 			wlan_serialization_pdev_create_handler,
565 			NULL);
566 err_pdev_create:
567 	wlan_objmgr_unregister_psoc_destroy_handler(
568 			WLAN_UMAC_COMP_SERIALIZATION,
569 			wlan_serialization_psoc_destroy_handler,
570 			NULL);
571 err_psoc_delete:
572 	wlan_objmgr_unregister_psoc_create_handler(
573 			WLAN_UMAC_COMP_SERIALIZATION,
574 			wlan_serialization_psoc_create_handler,
575 			NULL);
576 err_psoc_create:
577 exit:
578 	return status;
579 }
580 
wlan_serialization_deinit(void)581 QDF_STATUS wlan_serialization_deinit(void)
582 {
583 	QDF_STATUS status;
584 	QDF_STATUS ret_status = QDF_STATUS_SUCCESS;
585 
586 	status = wlan_objmgr_unregister_psoc_create_handler(
587 			WLAN_UMAC_COMP_SERIALIZATION,
588 			wlan_serialization_psoc_create_handler,
589 			NULL);
590 
591 	if (status != QDF_STATUS_SUCCESS) {
592 		ser_err("unreg fail for psoc ser obj create notf:%d", status);
593 		ret_status = QDF_STATUS_E_FAILURE;
594 	}
595 	status = wlan_objmgr_unregister_psoc_destroy_handler(
596 			WLAN_UMAC_COMP_SERIALIZATION,
597 			wlan_serialization_psoc_destroy_handler,
598 			NULL);
599 
600 	if (status != QDF_STATUS_SUCCESS) {
601 		ser_err("unreg fail for psoc ser obj destroy notf:%d", status);
602 		ret_status = QDF_STATUS_E_FAILURE;
603 	}
604 
605 	status = wlan_objmgr_unregister_pdev_create_handler(
606 			WLAN_UMAC_COMP_SERIALIZATION,
607 			wlan_serialization_pdev_create_handler,
608 			NULL);
609 	if (status != QDF_STATUS_SUCCESS) {
610 		ser_err("unreg fail for pdev ser obj create notf:%d", status);
611 		ret_status = QDF_STATUS_E_FAILURE;
612 	}
613 
614 	status = wlan_objmgr_unregister_pdev_destroy_handler(
615 			WLAN_UMAC_COMP_SERIALIZATION,
616 			wlan_serialization_pdev_destroy_handler,
617 			NULL);
618 
619 	if (status != QDF_STATUS_SUCCESS) {
620 		ser_err("unreg fail for pdev ser destroy notf:%d", status);
621 		ret_status = QDF_STATUS_E_FAILURE;
622 	}
623 
624 	ser_debug("deregistered callbacks with obj mgr successfully");
625 
626 	return ret_status;
627 }
628