qcacmn: MCL part change after serialization enhancement

1. Keep serialization legacy api not broken.
Serialization enhancement have much changes on internal struct
and API, need re-implement serialization legacy APIs.

2. Set all cmds on MCL platform as blocking type.
MCL dones't support cmd concurrency on multi vdevs, while WIN need
it.

Change-Id: I5d5d6e0e16becb0b0f285fd8ed20982f2819659c
CRs-Fixed: 2315407

umac/cmn_services/serialization/src/wlan_serialization_legacy_api.c

@@ -26,6 +26,9 @@
 #include "wlan_serialization_main_i.h"
 #include "wlan_serialization_utils_i.h"
 #include "wlan_objmgr_vdev_obj.h"
+#include "wlan_serialization_internal_i.h"
+#include "wlan_serialization_scan_i.h"
+#include "wlan_serialization_non_scan_i.h"
 
 extern struct serialization_legacy_callback ser_legacy_cb;
 
@@ -36,7 +39,7 @@ static struct wlan_objmgr_pdev *wlan_serialization_get_first_pdev(
 	uint8_t i = 0;
 
 	if (!psoc) {
-		serialization_err("invalid psoc");
+		ser_err("invalid psoc");
 		return NULL;
 	}
 	for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) {
@@ -49,27 +52,27 @@ static struct wlan_objmgr_pdev *wlan_serialization_get_first_pdev(
 	return pdev;
 }
 
-static struct wlan_serialization_pdev_priv_obj *
+static struct wlan_ser_pdev_obj *
 wlan_serialization_get_pdev_priv_obj_using_psoc(struct wlan_objmgr_psoc *psoc)
 {
 	struct wlan_objmgr_pdev *pdev = NULL;
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 
 	if (!psoc) {
-		serialization_err("invalid psoc");
+		ser_err("invalid psoc");
 		return NULL;
 	}
 
 	pdev = wlan_serialization_get_first_pdev(psoc);
 	if (!pdev) {
-		serialization_err("invalid pdev");
+		ser_err("invalid pdev");
 		return NULL;
 	}
 
-	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj(pdev);
+	ser_pdev_obj =  wlan_serialization_get_pdev_obj(pdev);
 	wlan_objmgr_pdev_release_ref(pdev, WLAN_SERIALIZATION_ID);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return NULL;
 	}
 
@@ -80,24 +83,27 @@ uint32_t wlan_serialization_get_active_list_count(
 			struct wlan_objmgr_psoc *psoc,
 			uint8_t is_cmd_from_active_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 	uint32_t count;
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return 0;
 	}
 
-	wlan_serialization_acquire_lock(ser_pdev_obj);
 	if (is_cmd_from_active_scan_queue)
-		queue = &ser_pdev_obj->active_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->active_list;
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
 
+	wlan_serialization_acquire_lock(&pdev_queue->pdev_queue_lock);
+	queue = &pdev_queue->active_list;
 	count = qdf_list_size(queue);
-	wlan_serialization_release_lock(ser_pdev_obj);
+	wlan_serialization_release_lock(&pdev_queue->pdev_queue_lock);
 
 	return count;
 }
@@ -106,24 +112,26 @@ uint32_t wlan_serialization_get_pending_list_count(
 				struct wlan_objmgr_psoc *psoc,
 				uint8_t is_cmd_from_pending_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	qdf_list_t *queue;
 	uint32_t count = 0;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return 0;
 	}
 
-	wlan_serialization_acquire_lock(ser_pdev_obj);
 	if (is_cmd_from_pending_scan_queue)
-		queue = &ser_pdev_obj->pending_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->pending_list;
-
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	queue = &pdev_queue->pending_list;
+	wlan_serialization_acquire_lock(&pdev_queue->pdev_queue_lock);
 	count = qdf_list_size(queue);
-	wlan_serialization_release_lock(ser_pdev_obj);
+	wlan_serialization_release_lock(&pdev_queue->pdev_queue_lock);
 
 	return count;
 }
@@ -133,38 +141,41 @@ wlan_serialization_peek_head_active_cmd_using_psoc(
 			struct wlan_objmgr_psoc *psoc,
 			uint8_t is_cmd_from_active_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	struct wlan_serialization_command_list *cmd_list = NULL;
 	struct wlan_serialization_command *cmd = NULL;
 	qdf_list_node_t *nnode = NULL;
 	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return NULL;
 	}
 
 	if (is_cmd_from_active_scan_queue)
-		queue = &ser_pdev_obj->active_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->active_list;
-	if (wlan_serialization_list_empty(queue, ser_pdev_obj)) {
-		serialization_err("Empty Queue");
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	queue = &pdev_queue->active_list;
+	if (wlan_serialization_list_empty(queue)) {
+		ser_err("Empty Queue");
 		goto end;
 	}
 
 	if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(queue,
-						&nnode, ser_pdev_obj)) {
-		serialization_err("Can't get command from queue");
+						&nnode)) {
+		ser_err("Can't get command from queue");
 		goto end;
 	}
 
 	cmd_list = qdf_container_of(nnode,
-			struct wlan_serialization_command_list, node);
+			struct wlan_serialization_command_list, pdev_node);
 	cmd = &cmd_list->cmd;
-	serialization_debug("cmd_type[%d], cmd_id[%d]",
-			    cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
+	ser_debug("cmd_type[%d], cmd_id[%d]",
+		  cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
 
 end:
 	return cmd;
@@ -175,36 +186,40 @@ wlan_serialization_peek_head_pending_cmd_using_psoc(
 			struct wlan_objmgr_psoc *psoc,
 			uint8_t is_cmd_from_pending_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	struct wlan_serialization_command_list *cmd_list = NULL;
 	struct wlan_serialization_command *cmd = NULL;
 	qdf_list_node_t *nnode = NULL;
 	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return NULL;
 	}
 	if (is_cmd_from_pending_scan_queue)
-		queue = &ser_pdev_obj->pending_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->pending_list;
-	if (wlan_serialization_list_empty(queue, ser_pdev_obj)) {
-		serialization_err("Empty Queue");
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	queue = &pdev_queue->pending_list;
+	if (wlan_serialization_list_empty(queue)) {
+		ser_err("Empty Queue");
 		goto end;
 	}
 
-	if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(queue,
-							&nnode, ser_pdev_obj)) {
-		serialization_err("Can't get command from queue");
+	if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(
+							queue,
+							&nnode)) {
+		ser_err("Can't get command from queue");
 		goto end;
 	}
 	cmd_list = qdf_container_of(nnode,
-			struct wlan_serialization_command_list, node);
+			struct wlan_serialization_command_list, pdev_node);
 	cmd = &cmd_list->cmd;
-	serialization_debug("cmd_type[%d] cmd_id[%d]matched",
-			    cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
+	ser_debug("cmd_type[%d] cmd_id[%d]matched",
+		  cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
 
 end:
 	return cmd;
@@ -213,7 +228,7 @@ end:
 static struct wlan_serialization_command*
 wlan_serialization_get_list_next_node(qdf_list_t *queue,
 			struct wlan_serialization_command *cmd,
-			struct wlan_serialization_pdev_priv_obj *ser_pdev_obj)
+			struct wlan_ser_pdev_obj *ser_pdev_obj)
 {
 	struct wlan_serialization_command_list *cmd_list = NULL;
 	qdf_list_node_t *pnode = NULL, *nnode = NULL;
@@ -222,19 +237,17 @@ wlan_serialization_get_list_next_node(qdf_list_t *queue,
 	QDF_STATUS status;
 	struct wlan_serialization_command *ret_cmd = NULL;
 
-	i = wlan_serialization_list_size(queue, ser_pdev_obj);
+	i = wlan_serialization_list_size(queue);
 	if (i == 0) {
-		serialization_err("Empty Queue");
+		ser_err("Empty Queue");
 		return NULL;
 	}
 	while (i--) {
 		if (!cmd_list)
-			status = wlan_serialization_peek_front(queue, &nnode,
-							       ser_pdev_obj);
+			status = wlan_serialization_peek_front(queue, &nnode);
 		else
 			status = wlan_serialization_peek_next(queue, pnode,
-							      &nnode,
-							      ser_pdev_obj);
+							      &nnode);
 
 		if ((status != QDF_STATUS_SUCCESS) || found)
 			break;
@@ -243,26 +256,29 @@ wlan_serialization_get_list_next_node(qdf_list_t *queue,
 		cmd_list = qdf_container_of(
 					nnode,
 					struct wlan_serialization_command_list,
-					node);
-		if (wlan_serialization_match_cmd_id_type(nnode, cmd,
-							 ser_pdev_obj) &&
-				wlan_serialization_match_cmd_vdev(nnode,
-								  cmd->vdev)) {
+					pdev_node);
+		if (wlan_serialization_match_cmd_id_type(
+				nnode, cmd, WLAN_SER_PDEV_NODE) &&
+		    wlan_serialization_match_cmd_vdev(nnode,
+						      cmd->vdev,
+						      WLAN_SER_PDEV_NODE)) {
 			found = true;
 		}
 		nnode = NULL;
 	}
 	if (nnode && found) {
-		cmd_list = qdf_container_of(nnode,
-				struct wlan_serialization_command_list, node);
+		cmd_list = qdf_container_of(
+				nnode,
+				struct wlan_serialization_command_list,
+				pdev_node);
 		ret_cmd = &cmd_list->cmd;
 	}
 	if (!found) {
-		serialization_err("Can't locate next command");
+		ser_err("Can't locate next command");
 		return NULL;
 	}
 	if (!nnode) {
-		serialization_debug("next node is empty, so fine");
+		ser_debug("next node is empty, so fine");
 		return NULL;
 	}
 
@@ -275,25 +291,27 @@ wlan_serialization_get_active_list_next_node_using_psoc(
 			struct wlan_serialization_command *prev_cmd,
 			uint8_t is_cmd_for_active_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 
 	if (!prev_cmd) {
-		serialization_err("invalid prev_cmd");
+		ser_err("invalid prev_cmd");
 		return NULL;
 	}
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return NULL;
 	}
 
 	if (is_cmd_for_active_scan_queue)
-		queue = &ser_pdev_obj->active_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->active_list;
-
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	queue = &pdev_queue->active_list;
 	return wlan_serialization_get_list_next_node(queue, prev_cmd,
 						     ser_pdev_obj);
 }
@@ -304,24 +322,26 @@ wlan_serialization_get_pending_list_next_node_using_psoc(
 			struct wlan_serialization_command *prev_cmd,
 			uint8_t is_cmd_for_pending_scan_queue)
 {
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue  *pdev_queue;
 
 	if (!prev_cmd) {
-		serialization_err("invalid prev_cmd");
+		ser_err("invalid prev_cmd");
 		return NULL;
 	}
 
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("invalid ser_pdev_obj");
+		ser_err("invalid ser_pdev_obj");
 		return NULL;
 	}
 	if (is_cmd_for_pending_scan_queue)
-		queue = &ser_pdev_obj->pending_scan_list;
+		pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
 	else
-		queue = &ser_pdev_obj->pending_list;
-
+		pdev_queue =
+		&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	queue = &pdev_queue->pending_list;
 	return wlan_serialization_get_list_next_node(queue, prev_cmd,
 						     ser_pdev_obj);
 }
@@ -332,7 +352,8 @@ void wlan_serialization_legacy_init_callback(void)
 			wlan_serialization_purge_cmd_list;
 }
 
-void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
+void wlan_serialization_purge_cmd_list_by_vdev_id(
+			struct wlan_objmgr_psoc *psoc,
 			uint8_t vdev_id, bool purge_scan_active_queue,
 			bool purge_scan_pending_queue,
 			bool purge_nonscan_active_queue,
@@ -344,10 +365,11 @@ void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 			WLAN_SERIALIZATION_ID);
 	if (!vdev) {
-		serialization_err("Invalid vdev");
+		ser_err("Invalid vdev");
 		return;
 	}
-	wlan_serialization_purge_cmd_list(psoc, vdev, purge_scan_active_queue,
+	wlan_serialization_purge_cmd_list(
+				psoc, vdev, purge_scan_active_queue,
 				purge_scan_pending_queue,
 				purge_nonscan_active_queue,
 				purge_nonscan_pending_queue,
@@ -355,7 +377,8 @@ void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_SERIALIZATION_ID);
 }
 
-void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
+void wlan_serialization_purge_cmd_list(
+		struct wlan_objmgr_psoc *psoc,
 		struct wlan_objmgr_vdev *vdev,
 		bool purge_scan_active_queue,
 		bool purge_scan_pending_queue,
@@ -364,28 +387,28 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
 		bool purge_all_queues)
 {
 	struct wlan_serialization_timer *ser_timer;
-	struct wlan_serialization_psoc_priv_obj *psoc_ser_obj;
-	struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
+	struct wlan_ser_psoc_obj *psoc_ser_obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
 	struct wlan_objmgr_pdev *pdev = NULL;
 	uint32_t i = 0;
 
 	if (!psoc) {
-		serialization_err("Invalid psoc");
+		ser_err("Invalid psoc");
 		return;
 	}
 	ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
 	if (!ser_pdev_obj) {
-		serialization_err("Invalid ser_pdev_obj");
+		ser_err("Invalid ser_pdev_obj");
 		return;
 	}
-	psoc_ser_obj = wlan_serialization_get_psoc_priv_obj(psoc);
+	psoc_ser_obj = wlan_serialization_get_psoc_obj(psoc);
 	if (!psoc_ser_obj) {
-		serialization_err("Invalid psoc_ser_obj");
+		ser_err("Invalid psoc_ser_obj");
 		return;
 	}
 	pdev = wlan_serialization_get_first_pdev(psoc);
 	if (!pdev) {
-		serialization_err("Invalid pdev");
+		ser_err("Invalid pdev");
 		return;
 	}
 	for (i = 0; psoc_ser_obj->max_active_cmds > i; i++) {
@@ -400,7 +423,7 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
 		 * de-activate all the timers.
 		 */
 		if (!purge_all_queues && purge_scan_active_queue &&
-			     (ser_timer->cmd->cmd_type >= WLAN_SER_CMD_NONSCAN))
+		    (ser_timer->cmd->cmd_type >= WLAN_SER_CMD_NONSCAN))
 			continue;
 		/*
 		 * if request is to purge active nonscan then don't de-activate
@@ -408,37 +431,49 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
 		 * de-activate all the timers.
 		 */
 		if (!purge_all_queues && purge_nonscan_active_queue &&
-			     (ser_timer->cmd->cmd_type < WLAN_SER_CMD_NONSCAN))
+		    (ser_timer->cmd->cmd_type < WLAN_SER_CMD_NONSCAN))
 			continue;
 
 		if (QDF_STATUS_SUCCESS !=
-				wlan_serialization_find_and_stop_timer(psoc,
+				wlan_serialization_find_and_stop_timer(
+							psoc,
 							ser_timer->cmd))
-			serialization_err("some error in stopping timer");
+			ser_err("some error in stopping timer");
 	}
 	if (purge_all_queues || purge_scan_active_queue) {
-		/* sending active queue as pending queue to leverage the API */
-		wlan_serialization_remove_all_cmd_from_queue(
-			&ser_pdev_obj->active_scan_list, ser_pdev_obj,
-			pdev, vdev, NULL, false);
+		wlan_ser_cancel_scan_cmd(ser_pdev_obj,
+					 pdev,
+					 vdev,
+					 NULL,
+					 WLAN_SER_CMD_SCAN,
+					 true);
 	}
 	if (purge_all_queues || purge_scan_pending_queue) {
-		wlan_serialization_remove_all_cmd_from_queue(
-			&ser_pdev_obj->pending_scan_list, ser_pdev_obj,
-			pdev, vdev, NULL, false);
+		wlan_ser_cancel_scan_cmd(ser_pdev_obj,
+					 pdev,
+					 vdev,
+					 NULL,
+					 WLAN_SER_CMD_SCAN,
+					 false);
 	}
 	if (purge_all_queues || purge_nonscan_active_queue) {
-		/* sending active queue as pending queue to leverage the API */
-		wlan_serialization_remove_all_cmd_from_queue(
-			&ser_pdev_obj->active_list, ser_pdev_obj,
-			pdev, vdev, NULL, false);
+		wlan_ser_cancel_non_scan_cmd(
+			ser_pdev_obj,
+			pdev, vdev,
+			NULL,
+			WLAN_SER_CMD_NONSCAN,
+			true);
 	}
 	if (purge_all_queues || purge_nonscan_pending_queue) {
-		wlan_serialization_remove_all_cmd_from_queue(
-			&ser_pdev_obj->pending_list, ser_pdev_obj,
-			pdev, vdev, NULL, false);
+		wlan_ser_cancel_non_scan_cmd(
+			ser_pdev_obj,
+			pdev, vdev,
+			NULL,
+			WLAN_SER_CMD_NONSCAN,
+			false);
 	}
 	wlan_objmgr_pdev_release_ref(pdev, WLAN_SERIALIZATION_ID);
 
 	return;
 }
+

umac/nan/core/src/nan_main.c

@@ -226,6 +226,7 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg)
 	cmd.is_high_priority = false;
 	cmd.cmd_timeout_duration = 30000 /* 30 sec for now. TBD */;
 	nan_debug("cmd_type: %d", cmd.cmd_type);
+	cmd.is_blocking = true;
 
 	status = wlan_serialization_request(&cmd);
 	/* following is TBD */

umac/tdls/core/src/wlan_tdls_cmds_process.c

@@ -825,6 +825,7 @@ QDF_STATUS tdls_process_add_peer(struct tdls_add_peer_request *req)
 	cmd.is_high_priority = false;
 	cmd.cmd_timeout_duration = WAIT_TIME_TDLS_ADD_STA;
 	cmd.vdev = vdev;
+	cmd.is_blocking = true;
 
 	ser_cmd_status = wlan_serialization_request(&cmd);
 	tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,
@@ -1034,6 +1035,7 @@ QDF_STATUS tdls_process_update_peer(struct tdls_update_peer_request *req)
 	cmd.is_high_priority = false;
 	cmd.cmd_timeout_duration = WAIT_TIME_TDLS_ADD_STA;
 	cmd.vdev = req->vdev;
+	cmd.is_blocking = true;
 
 	ser_cmd_status = wlan_serialization_request(&cmd);
 	tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,
@@ -1187,6 +1189,7 @@ QDF_STATUS tdls_process_del_peer(struct tdls_oper_request *req)
 	cmd.is_high_priority = false;
 	cmd.cmd_timeout_duration = WAIT_TIME_TDLS_DEL_STA;
 	cmd.vdev = vdev;
+	cmd.is_blocking = true;
 
 	ser_cmd_status = wlan_serialization_request(&cmd);
 	tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,

umac/tdls/core/src/wlan_tdls_mgmt.c

@@ -403,6 +403,7 @@ QDF_STATUS tdls_process_mgmt_req(
 	cmd.cmd_timeout_duration = TDLS_DEFAULT_SERIALIZE_CMD_TIMEOUT;
 
 	cmd.vdev = tdls_mgmt_req->vdev;
+	cmd.is_blocking = true;
 
 	ser_cmd_status = wlan_serialization_request(&cmd);
 	tdls_debug("wlan_serialization_request status:%d", ser_cmd_status);