xref: /wlan-driver/qca-wifi-host-cmn/umac/cmn_services/serialization/src/wlan_serialization_utf.c (revision 5113495b16420b49004c444715d2daae2066e7dc)
1 /*
2  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
3  *
4  * Permission to use, copy, modify, and/or distribute this software for
5  * any purpose with or without fee is hereby granted, provided that the
6  * above copyright notice and this permission notice appear in all
7  * copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
10  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
11  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
12  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
13  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
14  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
15  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
16  * PERFORMANCE OF THIS SOFTWARE.
17  */
18 
19 /**
20  * DOC: Implements the unit test framework for serialization module
21  */
22 
23 #include <qdf_status.h>
24 #include <qdf_timer.h>
25 #include <wlan_objmgr_cmn.h>
26 #include <wlan_objmgr_vdev_obj.h>
27 #include <wlan_serialization_api.h>
28 #include "wlan_serialization_main_i.h"
29 #include "wlan_serialization_utf_i.h"
30 
31 struct wlan_ser_utf_vdev_info ser_utf_vdev[WLAN_SER_UTF_MAX_VDEVS];
32 
33 struct wlan_ser_utf_data *
wlan_ser_utf_data_alloc(struct wlan_ser_utf_data ** ser_data,struct wlan_objmgr_vdev * vdev,uint8_t cmd_id)34 wlan_ser_utf_data_alloc(struct wlan_ser_utf_data **ser_data,
35 			struct wlan_objmgr_vdev *vdev,
36 			uint8_t cmd_id)
37 {
38 	struct wlan_ser_utf_data *data;
39 
40 	data = qdf_mem_malloc(sizeof(*data));
41 
42 	if (!data) {
43 		QDF_ASSERT(0);
44 		return data;
45 	}
46 
47 	data->id = cmd_id;
48 	WLAN_SER_DATA_STR(data->str, wlan_vdev_get_id(vdev), cmd_id);
49 
50 	*ser_data = data;
51 	return data;
52 }
53 
54 enum wlan_serialization_status
wlan_ser_utf_add_cmd(struct wlan_serialization_command * cmd)55 wlan_ser_utf_add_cmd(struct wlan_serialization_command *cmd)
56 {
57 	enum wlan_serialization_status status;
58 	struct wlan_ser_utf_data *data = cmd->umac_cmd;
59 
60 	cmd->cmd_timeout_duration = WLAN_SER_UTF_TEST_CMD_TIMEOUT_MS;
61 	cmd->source = WLAN_UMAC_COMP_SERIALIZATION;
62 	cmd->cmd_cb = wlan_ser_utf_cb;
63 
64 	status = wlan_serialization_request(cmd);
65 	ser_debug("ADD : cmd_type:%d %9s %s status: %s",
66 		  cmd->cmd_type, SER_UTF_BLOCK_STR(cmd->is_blocking), data->str,
67 		  wlan_serialization_status_strings[status]);
68 
69 	return status;
70 }
71 
72 enum wlan_serialization_status
wlan_ser_utf_add_scan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,void * umac_cmd,bool is_high_priority)73 wlan_ser_utf_add_scan_cmd(struct wlan_objmgr_vdev *vdev,
74 			  uint32_t cmd_id, void *umac_cmd,
75 			  bool is_high_priority)
76 {
77 	struct wlan_serialization_command cmd;
78 
79 	cmd.vdev = vdev;
80 	cmd.cmd_id = cmd_id;
81 	cmd.umac_cmd = umac_cmd;
82 	cmd.is_high_priority = is_high_priority;
83 	cmd.is_blocking = false;
84 	cmd.cmd_type = WLAN_SER_CMD_SCAN;
85 
86 	return wlan_ser_utf_add_cmd(&cmd);
87 }
88 
89 enum wlan_serialization_status
wlan_ser_utf_add_nonscan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,void * umac_cmd,bool is_high_priority,bool is_blocking)90 wlan_ser_utf_add_nonscan_cmd(struct wlan_objmgr_vdev *vdev,
91 			     uint32_t cmd_id, void *umac_cmd,
92 			     bool is_high_priority, bool is_blocking)
93 {
94 	struct wlan_serialization_command cmd;
95 
96 	cmd.vdev = vdev;
97 	cmd.cmd_id = cmd_id;
98 	cmd.umac_cmd = umac_cmd;
99 	cmd.is_blocking = is_blocking;
100 	cmd.is_high_priority = is_high_priority;
101 	cmd.cmd_type = WLAN_SER_CMD_NONSCAN;
102 
103 	return wlan_ser_utf_add_cmd(&cmd);
104 }
105 
wlan_ser_utf_remove_scan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id)106 void wlan_ser_utf_remove_scan_cmd(struct wlan_objmgr_vdev *vdev,
107 				  uint32_t cmd_id)
108 {
109 	struct wlan_serialization_queued_cmd_info cmd;
110 
111 	cmd.vdev = vdev;
112 	cmd.cmd_id = cmd_id;
113 	cmd.cmd_type = WLAN_SER_CMD_SCAN;
114 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
115 
116 	wlan_serialization_remove_cmd(&cmd);
117 }
118 
wlan_ser_utf_remove_nonscan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id)119 void wlan_ser_utf_remove_nonscan_cmd(struct wlan_objmgr_vdev *vdev,
120 				     uint32_t cmd_id)
121 {
122 	struct wlan_serialization_queued_cmd_info cmd;
123 
124 	cmd.vdev = vdev;
125 	cmd.cmd_id = cmd_id;
126 	cmd.cmd_type = WLAN_SER_CMD_NONSCAN;
127 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
128 
129 	wlan_serialization_remove_cmd(&cmd);
130 }
131 
132 enum wlan_serialization_cmd_status
wlan_ser_utf_cancel_scan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,uint8_t queue_type,enum wlan_serialization_cancel_type req_type)133 wlan_ser_utf_cancel_scan_cmd(struct wlan_objmgr_vdev *vdev,
134 			     uint32_t cmd_id, uint8_t queue_type,
135 			     enum wlan_serialization_cancel_type req_type)
136 {
137 	struct wlan_serialization_queued_cmd_info cmd;
138 
139 	cmd.vdev = vdev;
140 	cmd.cmd_id = cmd_id;
141 	cmd.queue_type = queue_type;
142 	cmd.req_type = req_type;
143 	cmd.cmd_type = WLAN_SER_CMD_SCAN;
144 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
145 
146 	return wlan_serialization_cancel_request(&cmd);
147 }
148 
149 enum wlan_serialization_cmd_status
wlan_ser_utf_cancel_nonscan_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,uint8_t queue_type,enum wlan_serialization_cancel_type req_type)150 wlan_ser_utf_cancel_nonscan_cmd(struct wlan_objmgr_vdev *vdev,
151 				uint32_t cmd_id, uint8_t queue_type,
152 				enum wlan_serialization_cancel_type req_type)
153 {
154 	struct wlan_serialization_queued_cmd_info cmd;
155 
156 	cmd.vdev = vdev;
157 	cmd.cmd_id = cmd_id;
158 	cmd.queue_type = queue_type;
159 	cmd.req_type = req_type;
160 	cmd.cmd_type = WLAN_SER_CMD_NONSCAN;
161 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
162 
163 	return wlan_serialization_cancel_request(&cmd);
164 }
165 
wlan_ser_utf_remove_start_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id)166 void wlan_ser_utf_remove_start_bss_cmd(struct wlan_objmgr_vdev *vdev,
167 				       uint32_t cmd_id)
168 {
169 	struct wlan_serialization_queued_cmd_info cmd;
170 
171 	cmd.vdev = vdev;
172 	cmd.cmd_id = cmd_id;
173 	cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS;
174 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
175 
176 	wlan_serialization_remove_cmd(&cmd);
177 }
178 
wlan_ser_utf_remove_stop_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id)179 void wlan_ser_utf_remove_stop_bss_cmd(struct wlan_objmgr_vdev *vdev,
180 				      uint32_t cmd_id)
181 {
182 	struct wlan_serialization_queued_cmd_info cmd;
183 
184 	cmd.vdev = vdev;
185 	cmd.cmd_id = cmd_id;
186 	cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS;
187 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
188 
189 	wlan_serialization_remove_cmd(&cmd);
190 }
191 
192 enum wlan_serialization_cmd_status
wlan_ser_utf_cancel_start_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,uint8_t queue_type,enum wlan_serialization_cancel_type req_type)193 wlan_ser_utf_cancel_start_bss_cmd(struct wlan_objmgr_vdev *vdev,
194 				  uint32_t cmd_id, uint8_t queue_type,
195 				  enum wlan_serialization_cancel_type req_type)
196 {
197 	struct wlan_serialization_queued_cmd_info cmd;
198 
199 	cmd.vdev = vdev;
200 	cmd.cmd_id = cmd_id;
201 	cmd.queue_type = queue_type;
202 	cmd.req_type = req_type;
203 	cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS;
204 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
205 
206 	return wlan_serialization_cancel_request(&cmd);
207 }
208 
209 enum wlan_serialization_cmd_status
wlan_ser_utf_cancel_stop_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,uint8_t queue_type,enum wlan_serialization_cancel_type req_type)210 wlan_ser_utf_cancel_stop_bss_cmd(struct wlan_objmgr_vdev *vdev,
211 				 uint32_t cmd_id, uint8_t queue_type,
212 				 enum wlan_serialization_cancel_type req_type)
213 {
214 	struct wlan_serialization_queued_cmd_info cmd;
215 
216 	cmd.vdev = vdev;
217 	cmd.cmd_id = cmd_id;
218 	cmd.queue_type = queue_type;
219 	cmd.req_type = req_type;
220 	cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS;
221 	cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION;
222 
223 	return wlan_serialization_cancel_request(&cmd);
224 }
225 
226 enum wlan_serialization_status
wlan_ser_utf_add_vdev_stop_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,void * umac_cmd,bool is_high_priority,bool is_blocking)227 wlan_ser_utf_add_vdev_stop_bss_cmd(struct wlan_objmgr_vdev *vdev,
228 				   uint32_t cmd_id, void *umac_cmd,
229 				   bool is_high_priority, bool is_blocking)
230 {
231 	struct wlan_serialization_command cmd;
232 	uint8_t queue_type;
233 	enum wlan_serialization_cancel_type req_type;
234 
235 	cmd.vdev = vdev;
236 	cmd.cmd_id = cmd_id;
237 	cmd.umac_cmd = umac_cmd;
238 	cmd.is_blocking = is_blocking;
239 	cmd.is_high_priority = is_high_priority;
240 	cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS;
241 
242 	/* Command filtering logic */
243 	req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
244 	queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
245 	wlan_ser_utf_cancel_start_bss_cmd(vdev, cmd_id,
246 					  queue_type, req_type);
247 
248 	wlan_ser_utf_cancel_stop_bss_cmd(vdev, cmd_id,
249 					 queue_type, req_type);
250 
251 	if (wlan_serialization_is_cmd_present_in_active_queue(NULL, &cmd))
252 		return WLAN_SER_CMD_ACTIVE;
253 
254 	return wlan_ser_utf_add_cmd(&cmd);
255 }
256 
257 enum wlan_serialization_status
wlan_ser_utf_add_vdev_start_bss_cmd(struct wlan_objmgr_vdev * vdev,uint32_t cmd_id,void * umac_cmd,bool is_high_priority,bool is_blocking)258 wlan_ser_utf_add_vdev_start_bss_cmd(struct wlan_objmgr_vdev *vdev,
259 				    uint32_t cmd_id, void *umac_cmd,
260 				    bool is_high_priority, bool is_blocking)
261 {
262 	struct wlan_serialization_command cmd;
263 	uint8_t queue_type;
264 	enum wlan_serialization_cancel_type req_type;
265 	struct wlan_ser_utf_data *data;
266 
267 	cmd.vdev = vdev;
268 	cmd.cmd_id = cmd_id;
269 	cmd.umac_cmd = umac_cmd;
270 	cmd.is_blocking = is_blocking;
271 	cmd.is_high_priority = is_high_priority;
272 	cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS;
273 
274 	/* Command filtering logic */
275 	req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
276 	queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
277 	wlan_ser_utf_cancel_start_bss_cmd(vdev, cmd_id,
278 					  queue_type, req_type);
279 
280 	if (wlan_serialization_is_cmd_present_in_active_queue(NULL, &cmd)) {
281 		cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS;
282 		if (!wlan_serialization_is_cmd_present_in_pending_queue(
283 					NULL, &cmd)) {
284 		if (!wlan_ser_utf_data_alloc(&data, vdev, cmd_id))
285 			return WLAN_SER_CMD_DENIED_UNSPECIFIED;
286 			wlan_ser_utf_add_vdev_stop_bss_cmd(
287 					vdev, cmd_id, (void *)data,
288 					is_high_priority, is_blocking);
289 		}
290 	}
291 
292 	cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS;
293 	return wlan_ser_utf_add_cmd(&cmd);
294 }
295 
wlan_ser_utf_cb(struct wlan_serialization_command * cmd,enum wlan_serialization_cb_reason reason)296 QDF_STATUS wlan_ser_utf_cb(struct wlan_serialization_command *cmd,
297 			   enum wlan_serialization_cb_reason reason)
298 {
299 	QDF_STATUS status = QDF_STATUS_SUCCESS;
300 	uint8_t vdev_id;
301 	struct wlan_ser_utf_data *data;
302 
303 	if (!cmd) {
304 		ser_err("Error: reason:%d", reason);
305 		QDF_ASSERT(0);
306 		return QDF_STATUS_E_NULL_VALUE;
307 	}
308 
309 	vdev_id = wlan_vdev_get_id(cmd->vdev);
310 	data = cmd->umac_cmd;
311 	if (!data) {
312 		ser_err("Error: reason:%d", reason);
313 		QDF_ASSERT(0);
314 		return QDF_STATUS_E_NULL_VALUE;
315 	}
316 
317 	switch (reason) {
318 	case WLAN_SER_CB_ACTIVATE_CMD:
319 		ser_debug("ACTIVATE: cmd_type:%d %9s %s\n", cmd->cmd_type,
320 			  SER_UTF_BLOCK_STR(cmd->is_blocking), data->str);
321 		break;
322 
323 	case WLAN_SER_CB_CANCEL_CMD:
324 		ser_debug("CANCEL  : cmd_type:%d %9s %s", cmd->cmd_type,
325 			  SER_UTF_BLOCK_STR(cmd->is_blocking), data->str);
326 		break;
327 
328 	case WLAN_SER_CB_ACTIVE_CMD_TIMEOUT:
329 		ser_debug("TIMEOUT : cmd_type:%d %9s %s", cmd->cmd_type,
330 			  SER_UTF_BLOCK_STR(cmd->is_blocking), data->str);
331 		qdf_mem_free(data);
332 		QDF_ASSERT(0);
333 		status = QDF_STATUS_E_INVAL;
334 		break;
335 
336 	case WLAN_SER_CB_RELEASE_MEM_CMD:
337 		ser_debug("RELEASE : cmd_type:%d %9s %s", cmd->cmd_type,
338 			  SER_UTF_BLOCK_STR(cmd->is_blocking), data->str);
339 		qdf_mem_free(data);
340 		break;
341 
342 	default:
343 		status = QDF_STATUS_E_INVAL;
344 		break;
345 	}
346 
347 	return status;
348 }
349 
wlan_ser_utf_scan_timer_cb(void * arg)350 static void wlan_ser_utf_scan_timer_cb(void *arg)
351 {
352 	struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)arg;
353 	uint8_t vdev_id = wlan_vdev_get_id(vdev);
354 
355 	wlan_ser_utf_remove_scan_cmd(vdev, ser_utf_vdev[vdev_id].ser_count++);
356 }
357 
wlan_ser_utf_nonscan_timer_cb(void * arg)358 static void wlan_ser_utf_nonscan_timer_cb(void *arg)
359 {
360 	struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)arg;
361 	uint8_t vdev_id = wlan_vdev_get_id(vdev);
362 
363 	wlan_ser_utf_remove_nonscan_cmd(vdev,
364 					ser_utf_vdev[vdev_id].ser_count++);
365 }
366 
wlan_ser_utf_run(struct wlan_objmgr_vdev * vdev,uint8_t scan_cmd,uint8_t max_cmds,bool is_high_priority,bool is_blocking)367 void wlan_ser_utf_run(struct wlan_objmgr_vdev *vdev, uint8_t scan_cmd,
368 		      uint8_t max_cmds,
369 		      bool is_high_priority, bool is_blocking)
370 {
371 	struct wlan_ser_utf_data *data;
372 	uint8_t id;
373 	uint8_t vdev_id = wlan_vdev_get_id(vdev);
374 	enum wlan_serialization_status ret;
375 
376 	if (!max_cmds)
377 		max_cmds = WLAN_SER_UTF_SCAN_CMD_TESTS;
378 
379 	ser_utf_vdev[vdev_id].ser_count = 0;
380 	for (id = 0; id < max_cmds; id++) {
381 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
382 			return;
383 
384 		if (scan_cmd)
385 			ret = wlan_ser_utf_add_scan_cmd(vdev, id, data,
386 							is_high_priority);
387 		else
388 			ret = wlan_ser_utf_add_nonscan_cmd(vdev, id,
389 							   data,
390 							   is_high_priority,
391 							   is_blocking);
392 	}
393 
394 	for (id = 0; id < max_cmds; id++) {
395 		if (scan_cmd)
396 			qdf_timer_mod(
397 			&ser_utf_vdev[vdev_id].utf_scan_timer[id],
398 			WLAN_SER_UTF_TIMER_TIMEOUT_MS);
399 		else
400 			qdf_timer_mod(
401 			&ser_utf_vdev[vdev_id].utf_nonscan_timer[id],
402 			WLAN_SER_UTF_TIMER_TIMEOUT_MS);
403 	}
404 }
405 
wlan_ser_utf_init_iter_op(struct wlan_objmgr_pdev * pdev,void * obj,void * args)406 static void wlan_ser_utf_init_iter_op(struct wlan_objmgr_pdev *pdev,
407 				      void *obj, void *args)
408 {
409 	struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj;
410 	uint8_t vdev_id = wlan_vdev_get_id(vdev);
411 	uint8_t id;
412 
413 	ser_utf_vdev[vdev_id].vdev = vdev;
414 	for (id = 0; id < WLAN_SER_UTF_SCAN_CMD_TESTS; id++) {
415 		qdf_timer_init(NULL,
416 			       &ser_utf_vdev[vdev_id].utf_scan_timer[id],
417 			       wlan_ser_utf_scan_timer_cb,
418 			       (void *)vdev, QDF_TIMER_TYPE_WAKE_APPS);
419 		qdf_timer_init(NULL,
420 			       &ser_utf_vdev[vdev_id].utf_nonscan_timer[id],
421 			       wlan_ser_utf_nonscan_timer_cb,
422 			       (void *)vdev, QDF_TIMER_TYPE_WAKE_APPS);
423 	}
424 }
425 
wlan_ser_utf_deinit_iter_op(struct wlan_objmgr_pdev * pdev,void * obj,void * args)426 static void wlan_ser_utf_deinit_iter_op(struct wlan_objmgr_pdev *pdev,
427 					void *obj, void *args)
428 {
429 	struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj;
430 	uint8_t vdev_id = wlan_vdev_get_id(vdev);
431 	uint8_t id;
432 
433 	for (id = 0; id < WLAN_SER_UTF_SCAN_CMD_TESTS; id++) {
434 		qdf_timer_free(
435 			&ser_utf_vdev[vdev_id].utf_nonscan_timer[id]);
436 		qdf_timer_free(
437 			&ser_utf_vdev[vdev_id].utf_scan_timer[id]);
438 	}
439 }
440 
wlan_ser_utf_vdev_iter_op(struct wlan_objmgr_pdev * pdev,void * obj,void * args)441 static void wlan_ser_utf_vdev_iter_op(struct wlan_objmgr_pdev *pdev,
442 				      void *obj, void *args)
443 {
444 	struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj;
445 	uint8_t is_blocking = *(uint8_t *)args;
446 
447 	wlan_ser_utf_run(vdev, false, 2, false, is_blocking);
448 }
449 
450 /*
451  * List of available APIs
452  * 1. wlan_serialization_request(
453  *	struct wlan_serialization_command *cmd)
454  * 2. wlan_serialization_remove_cmd(
455  *	struct wlan_serialization_queued_cmd_info *cmd_info)
456  * 3. wlan_serialization_cancel_request(
457  *	struct wlan_serialization_queued_cmd_info *cmd_info)
458  *	sub_val:
459  *		1st byte : cmd_id
460  *		2nd byte : scan_cmd
461  *		3rd byte : queue_type
462  *		4th byte : req_type
463  */
wlan_ser_utf_main(struct wlan_objmgr_vdev * vdev,uint8_t val,uint32_t sub_val)464 int wlan_ser_utf_main(struct wlan_objmgr_vdev *vdev, uint8_t val,
465 		      uint32_t sub_val)
466 {
467 	uint8_t id;
468 	uint8_t vdev_id;
469 	static uint8_t wlan_ser_utf_init;
470 	struct wlan_ser_utf_data *data;
471 	bool is_blocking;
472 	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
473 	uint8_t cmd_id = (uint8_t)sub_val;
474 	uint8_t scan_cmd = (uint8_t)(sub_val >> 8);
475 	uint8_t queue_type = (uint8_t)(sub_val >> 16);
476 	enum wlan_serialization_cancel_type req_type = (uint8_t)(sub_val >> 24);
477 
478 	if (wlan_ser_utf_init == 0 && val != 1) {
479 		ser_err("Init UTF before running test cases");
480 		return 0;
481 	}
482 
483 	switch (val) {
484 	case SER_UTF_TC_DEINIT:
485 		if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) ==
486 				QDF_STATUS_SUCCESS) {
487 			wlan_objmgr_pdev_iterate_obj_list(
488 					pdev, WLAN_VDEV_OP,
489 					wlan_ser_utf_deinit_iter_op,
490 					NULL, 0, WLAN_SERIALIZATION_ID);
491 			wlan_objmgr_pdev_release_ref(pdev,
492 						     WLAN_SERIALIZATION_ID);
493 			ser_err("Serialization Timer Deinit Done");
494 		}
495 		break;
496 	case SER_UTF_TC_INIT:
497 		if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) ==
498 				QDF_STATUS_SUCCESS) {
499 			wlan_objmgr_pdev_iterate_obj_list(
500 					pdev, WLAN_VDEV_OP,
501 					wlan_ser_utf_init_iter_op,
502 					NULL, 0, WLAN_SERIALIZATION_ID);
503 			wlan_objmgr_pdev_release_ref(pdev,
504 						     WLAN_SERIALIZATION_ID);
505 			wlan_ser_utf_init = 1;
506 			ser_err("Serialization Timer Init Done");
507 		}
508 		break;
509 	case SER_UTF_TC_ADD:
510 		ser_err("Add:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN", cmd_id);
511 		if (!wlan_ser_utf_data_alloc(&data, vdev, cmd_id))
512 			break;
513 
514 		if (scan_cmd)
515 			wlan_ser_utf_add_scan_cmd(vdev, cmd_id, data, false);
516 		else
517 			wlan_ser_utf_add_nonscan_cmd(vdev, cmd_id, data,
518 						     false, false);
519 		break;
520 	case SER_UTF_TC_REMOVE:
521 		ser_err("Remove:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN",
522 			cmd_id);
523 		if (scan_cmd)
524 			wlan_ser_utf_remove_scan_cmd(vdev, cmd_id);
525 		else
526 			wlan_ser_utf_remove_nonscan_cmd(vdev, cmd_id);
527 		break;
528 	case SER_UTF_TC_CANCEL:
529 		ser_err("Cancel:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN",
530 			cmd_id);
531 		if (scan_cmd)
532 			wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
533 						     req_type);
534 		else
535 			wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id,
536 							queue_type, req_type);
537 		break;
538 	case SER_UTF_TC_SINGLE_SCAN:
539 		id = 1;
540 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
541 			break;
542 		wlan_ser_utf_add_scan_cmd(vdev, id, data, false);
543 		wlan_ser_utf_remove_scan_cmd(vdev, id);
544 		break;
545 	case SER_UTF_TC_MULTI_SCAN:
546 		wlan_ser_utf_run(vdev, true, 10, false, false);
547 		break;
548 	case SER_UTF_TC_MAX_SCAN:
549 		wlan_ser_utf_run(vdev, true, 0, false, false);
550 		break;
551 	case SER_UTF_TC_SINGLE_NONSCAN:
552 		id = 1;
553 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
554 			break;
555 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
556 		wlan_ser_utf_remove_nonscan_cmd(vdev, id);
557 		break;
558 	case SER_UTF_TC_MULTI_NONSCAN:
559 		wlan_ser_utf_run(vdev, false, 10, false, false);
560 		break;
561 	case SER_UTF_TC_MAX_NONSCAN:
562 		wlan_ser_utf_run(vdev, false, 0, false, false);
563 		break;
564 	case SER_UTF_TC_MULTI_VDEV_NONSCAN:
565 		is_blocking = false;
566 		if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) ==
567 				QDF_STATUS_SUCCESS) {
568 			wlan_objmgr_pdev_iterate_obj_list(
569 					pdev, WLAN_VDEV_OP,
570 					wlan_ser_utf_vdev_iter_op,
571 					&is_blocking, 0, WLAN_SERIALIZATION_ID);
572 			wlan_objmgr_pdev_release_ref(pdev,
573 						     WLAN_SERIALIZATION_ID);
574 		}
575 		break;
576 	case SER_UTF_TC_CANCEL_SCAN_AC_SINGLE:
577 		id = 1;
578 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
579 			break;
580 		wlan_ser_utf_add_scan_cmd(vdev, id, data, false);
581 		req_type = WLAN_SER_CANCEL_SINGLE_SCAN;
582 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
583 		wlan_ser_utf_cancel_scan_cmd(vdev, id, queue_type,
584 					     req_type);
585 		break;
586 	case SER_UTF_TC_CANCEL_SCAN_AC_PDEV:
587 		wlan_ser_utf_run(vdev, true, 15, false, false);
588 		req_type = WLAN_SER_CANCEL_PDEV_SCANS;
589 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
590 		wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
591 					     req_type);
592 		break;
593 	case SER_UTF_TC_CANCEL_SCAN_AC_VDEV:
594 		wlan_ser_utf_run(vdev, true, 15, false, false);
595 		req_type = WLAN_SER_CANCEL_VDEV_SCANS;
596 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
597 		wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
598 					     req_type);
599 		break;
600 	case SER_UTF_TC_CANCEL_SCAN_PD_SINGLE:
601 		wlan_ser_utf_run(vdev, true, 15, false, false);
602 		req_type = WLAN_SER_CANCEL_SINGLE_SCAN;
603 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
604 		wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
605 					     req_type);
606 		break;
607 	case SER_UTF_TC_CANCEL_SCAN_PD_PDEV:
608 		wlan_ser_utf_run(vdev, true, 15, false, false);
609 		req_type = WLAN_SER_CANCEL_PDEV_SCANS;
610 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
611 		wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
612 					     req_type);
613 		break;
614 	case SER_UTF_TC_CANCEL_SCAN_PD_VDEV:
615 		wlan_ser_utf_run(vdev, true, 15, false, false);
616 		req_type = WLAN_SER_CANCEL_VDEV_SCANS;
617 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
618 		wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type,
619 					     req_type);
620 		break;
621 	case SER_UTF_TC_CANCEL_NONSCAN_AC_SINGLE:
622 		req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
623 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
624 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
625 						req_type);
626 		break;
627 	case SER_UTF_TC_CANCEL_NONSCAN_AC_PDEV:
628 		req_type = WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD;
629 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
630 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
631 						req_type);
632 		break;
633 	case SER_UTF_TC_CANCEL_NONSCAN_AC_VDEV:
634 		req_type = WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD;
635 		queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
636 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
637 						req_type);
638 		break;
639 	case SER_UTF_TC_CANCEL_NONSCAN_PD_SINGLE:
640 		req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
641 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
642 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
643 						req_type);
644 		break;
645 	case SER_UTF_TC_CANCEL_NONSCAN_PD_PDEV:
646 		req_type = WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD;
647 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
648 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
649 						req_type);
650 		break;
651 	case SER_UTF_TC_CANCEL_NONSCAN_PD_VDEV:
652 		req_type = WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD;
653 		queue_type = WLAN_SERIALIZATION_PENDING_QUEUE;
654 		wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type,
655 						req_type);
656 		break;
657 	case SER_UTF_TC_START_BSS_FILTERING:
658 		id = 1;
659 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
660 			break;
661 		wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data,
662 						    false, false);
663 
664 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
665 			break;
666 		wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data,
667 						    false, false);
668 
669 		wlan_ser_utf_remove_start_bss_cmd(vdev, id);
670 		wlan_ser_utf_remove_stop_bss_cmd(vdev, id);
671 		wlan_ser_utf_remove_start_bss_cmd(vdev, id);
672 		break;
673 	case SER_UTF_TC_STOP_BSS_FILTERING:
674 		id = 1;
675 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
676 			break;
677 		wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data,
678 						    false, false);
679 
680 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
681 			break;
682 		wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data,
683 						    false, false);
684 
685 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
686 			break;
687 		wlan_ser_utf_add_vdev_stop_bss_cmd(vdev, id, data,
688 						   false, false);
689 
690 		wlan_ser_utf_remove_start_bss_cmd(vdev, id);
691 		wlan_ser_utf_remove_stop_bss_cmd(vdev, id);
692 		break;
693 	case SER_UTF_TC_ADD_BLOCKING_NONSCAN_AC_1:
694 		id = 1;
695 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
696 			break;
697 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
698 		wlan_ser_utf_remove_nonscan_cmd(vdev, id);
699 		break;
700 	case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_1:
701 		id = 1;
702 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
703 			break;
704 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
705 
706 		id = 2;
707 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
708 			break;
709 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
710 
711 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
712 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
713 		break;
714 	case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_2:
715 		id = 1;
716 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
717 			break;
718 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
719 
720 		id = 2;
721 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
722 			break;
723 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
724 
725 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
726 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
727 		break;
728 	case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_3:
729 		id = 1;
730 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
731 			break;
732 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
733 
734 		id = 2;
735 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
736 			break;
737 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
738 
739 		id = 3;
740 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
741 			break;
742 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
743 
744 		id = 4;
745 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
746 			break;
747 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
748 
749 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
750 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
751 		wlan_ser_utf_remove_nonscan_cmd(vdev, 3);
752 		wlan_ser_utf_remove_nonscan_cmd(vdev, 4);
753 		break;
754 	case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_4:
755 		id = 1;
756 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
757 			break;
758 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
759 
760 		id = 2;
761 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
762 			break;
763 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
764 
765 		id = 3;
766 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
767 			break;
768 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
769 
770 		id = 4;
771 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
772 			break;
773 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
774 
775 		id = 5;
776 		if (!wlan_ser_utf_data_alloc(&data, vdev, id))
777 			break;
778 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
779 
780 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
781 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
782 		wlan_ser_utf_remove_nonscan_cmd(vdev, 3);
783 		wlan_ser_utf_remove_nonscan_cmd(vdev, 4);
784 		wlan_ser_utf_remove_nonscan_cmd(vdev, 5);
785 		break;
786 	case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_1:
787 		if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) {
788 			ser_err("Requires atleast %d vdevs for the given pdev",
789 				WLAN_SER_UTF_MAX_VDEVS);
790 			break;
791 		}
792 		is_blocking = true;
793 		if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) ==
794 				QDF_STATUS_SUCCESS) {
795 			wlan_objmgr_pdev_iterate_obj_list(
796 					pdev, WLAN_VDEV_OP,
797 					wlan_ser_utf_vdev_iter_op,
798 					&is_blocking, 0, WLAN_SERIALIZATION_ID);
799 			wlan_objmgr_pdev_release_ref(pdev,
800 						     WLAN_SERIALIZATION_ID);
801 		}
802 		break;
803 	case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_2:
804 		if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) {
805 			ser_err("Requires atleast %d vdevs for the given pdev",
806 				WLAN_SER_UTF_MAX_VDEVS);
807 			break;
808 		}
809 		id = 1;
810 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id);
811 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id,
812 					     data, false, false);
813 
814 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[1].vdev, id);
815 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[1].vdev, id,
816 					     data, false, false);
817 
818 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id);
819 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id,
820 					     data, false, false);
821 
822 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id);
823 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id,
824 					     data, false, true);
825 
826 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id);
827 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[1].vdev, id);
828 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id);
829 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id);
830 		break;
831 	case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_3:
832 		if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) {
833 			ser_err("Requires atleast %d vdevs for the given pdev",
834 				WLAN_SER_UTF_MAX_VDEVS);
835 			break;
836 		}
837 		id = 1;
838 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id);
839 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id,
840 					     data, false, true);
841 
842 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id);
843 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id,
844 					     data, false, false);
845 
846 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[1].vdev, id);
847 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[1].vdev, id,
848 					     data, false, false);
849 
850 		wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id);
851 		wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id,
852 					     data, false, false);
853 
854 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id);
855 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id);
856 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[1].vdev, id);
857 		wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id);
858 		break;
859 	case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_4:
860 		if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) {
861 			ser_err("Requires atleast %d vdevs for the given pdev",
862 				WLAN_SER_UTF_MAX_VDEVS);
863 			break;
864 		}
865 		for (id = 1; id <= 2; id++) {
866 			for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
867 					vdev_id++) {
868 				wlan_ser_utf_data_alloc(
869 						&data,
870 						ser_utf_vdev[vdev_id].vdev, id);
871 				wlan_ser_utf_add_nonscan_cmd(
872 						ser_utf_vdev[vdev_id].vdev,
873 						id, data, false, false);
874 			}
875 		}
876 
877 		id = 3;
878 		for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; vdev_id++) {
879 			wlan_ser_utf_data_alloc(
880 					&data, ser_utf_vdev[vdev_id].vdev, id);
881 			wlan_ser_utf_add_nonscan_cmd(
882 					ser_utf_vdev[vdev_id].vdev, id,
883 					data, false, true);
884 		}
885 
886 		for (id = 1; id <= 3; id++) {
887 			for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
888 					vdev_id++)
889 				wlan_ser_utf_remove_nonscan_cmd(
890 						ser_utf_vdev[vdev_id].vdev, id);
891 		}
892 		break;
893 	case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_5:
894 		if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) {
895 			ser_err("Requires atleast %d vdevs for the given pdev",
896 				WLAN_SER_UTF_MAX_VDEVS);
897 			break;
898 		}
899 		id = 1;
900 		for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
901 					vdev_id++) {
902 			wlan_ser_utf_data_alloc(
903 					&data,
904 					ser_utf_vdev[vdev_id].vdev, id);
905 			wlan_ser_utf_add_nonscan_cmd(
906 					ser_utf_vdev[vdev_id].vdev,
907 					id, data, false, false);
908 		}
909 		id = 2;
910 		for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
911 					vdev_id++) {
912 			wlan_ser_utf_data_alloc(
913 					&data,
914 					ser_utf_vdev[vdev_id].vdev, id);
915 			wlan_ser_utf_add_nonscan_cmd(
916 					ser_utf_vdev[vdev_id].vdev,
917 					id, data, false, true);
918 		}
919 		id = 3;
920 		for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
921 					vdev_id++) {
922 			wlan_ser_utf_data_alloc(
923 					&data,
924 					ser_utf_vdev[vdev_id].vdev, id);
925 			wlan_ser_utf_add_nonscan_cmd(
926 					ser_utf_vdev[vdev_id].vdev,
927 					id, data, false, false);
928 		}
929 
930 		for (id = 1; id <= 3; id++) {
931 			for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS;
932 					vdev_id++)
933 				wlan_ser_utf_remove_nonscan_cmd(
934 						ser_utf_vdev[vdev_id].vdev, id);
935 		}
936 		break;
937 	case SER_UTF_TC_HIGH_PRIO_NONSCAN_WO_BL:
938 		id = 1;
939 		wlan_ser_utf_data_alloc(&data, vdev, id);
940 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
941 
942 		id = 2;
943 		wlan_ser_utf_data_alloc(&data, vdev, id);
944 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
945 
946 		id = 3;
947 		wlan_ser_utf_data_alloc(&data, vdev, id);
948 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
949 
950 		id = 4;
951 		wlan_ser_utf_data_alloc(&data, vdev, id);
952 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, false);
953 
954 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
955 		wlan_ser_utf_remove_nonscan_cmd(vdev, 4);
956 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
957 		wlan_ser_utf_remove_nonscan_cmd(vdev, 3);
958 		break;
959 	case SER_UTF_TC_HIGH_PRIO_NONSCAN_W_BL:
960 		id = 1;
961 		wlan_ser_utf_data_alloc(&data, vdev, id);
962 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
963 
964 		id = 2;
965 		wlan_ser_utf_data_alloc(&data, vdev, id);
966 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true);
967 
968 		id = 3;
969 		wlan_ser_utf_data_alloc(&data, vdev, id);
970 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, false);
971 
972 		id = 4;
973 		wlan_ser_utf_data_alloc(&data, vdev, id);
974 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
975 
976 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
977 		wlan_ser_utf_remove_nonscan_cmd(vdev, 3);
978 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
979 		wlan_ser_utf_remove_nonscan_cmd(vdev, 4);
980 		break;
981 	case SER_UTF_TC_HIGH_PRIO_BL_NONSCAN:
982 		id = 1;
983 		wlan_ser_utf_data_alloc(&data, vdev, id);
984 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
985 
986 		id = 2;
987 		wlan_ser_utf_data_alloc(&data, vdev, id);
988 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
989 
990 		id = 3;
991 		wlan_ser_utf_data_alloc(&data, vdev, id);
992 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false);
993 
994 		id = 4;
995 		wlan_ser_utf_data_alloc(&data, vdev, id);
996 		wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, true);
997 
998 		wlan_ser_utf_remove_nonscan_cmd(vdev, 1);
999 		wlan_ser_utf_remove_nonscan_cmd(vdev, 4);
1000 		wlan_ser_utf_remove_nonscan_cmd(vdev, 2);
1001 		wlan_ser_utf_remove_nonscan_cmd(vdev, 3);
1002 		break;
1003 	default:
1004 		ser_err("Error: Unknown val");
1005 		break;
1006 	}
1007 
1008 	return 0;
1009 }
1010