From 4059554db08382ff08461247cb019534af7930d0 Mon Sep 17 00:00:00 2001 From: Santosh Anbu Date: Wed, 8 Aug 2018 12:38:51 +0530 Subject: [PATCH] qcacmn: Add unit test framework for serialization module This change provides support for unit testing the serialization module using the test framework. Change-Id: I62bc2e20120d5fa73b147aef84ad22c64c100706 CRs-Fixed: 2308317 --- .../src/wlan_serialization_utf.c | 1009 +++++++++++++++++ .../src/wlan_serialization_utf_i.h | 179 +++ 2 files changed, 1188 insertions(+) create mode 100644 umac/cmn_services/serialization/src/wlan_serialization_utf.c create mode 100644 umac/cmn_services/serialization/src/wlan_serialization_utf_i.h diff --git a/umac/cmn_services/serialization/src/wlan_serialization_utf.c b/umac/cmn_services/serialization/src/wlan_serialization_utf.c new file mode 100644 index 000000000000..b97388b8b7bc --- /dev/null +++ b/umac/cmn_services/serialization/src/wlan_serialization_utf.c @@ -0,0 +1,1009 @@ +/* + * Copyright (c) 2018 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all + * copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * DOC: Implements the unit test framework for serialization module + */ + +#include +#include +#include +#include +#include +#include "wlan_serialization_main_i.h" +#include "wlan_serialization_utf_i.h" + +struct wlan_ser_utf_vdev_info ser_utf_vdev[WLAN_SER_UTF_MAX_VDEVS]; + +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) +{ + struct wlan_ser_utf_data *data; + + data = qdf_mem_malloc(sizeof(*data)); + + if (!data) { + QDF_ASSERT(0); + return data; + } + + data->id = cmd_id; + WLAN_SER_DATA_STR(data->str, wlan_vdev_get_id(vdev), cmd_id); + + *ser_data = data; + return data; +} + +enum wlan_serialization_status +wlan_ser_utf_add_cmd(struct wlan_serialization_command *cmd) +{ + enum wlan_serialization_status status; + struct wlan_ser_utf_data *data = cmd->umac_cmd; + + cmd->cmd_timeout_duration = WLAN_SER_UTF_TEST_CMD_TIMEOUT_MS; + cmd->source = WLAN_UMAC_COMP_SERIALIZATION; + cmd->cmd_cb = (wlan_serialization_cmd_callback)wlan_ser_utf_cb; + + status = wlan_serialization_request(cmd); + ser_debug("ADD : cmd_type:%d %9s %s status: %s", + cmd->cmd_type, SER_UTF_BLOCK_STR(cmd->is_blocking), data->str, + wlan_serialization_status_strings[status]); + + return status; +} + +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) +{ + struct wlan_serialization_command cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.umac_cmd = umac_cmd; + cmd.is_high_priority = is_high_priority; + cmd.is_blocking = false; + cmd.cmd_type = WLAN_SER_CMD_SCAN; + + return wlan_ser_utf_add_cmd(&cmd); +} + +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) +{ + struct wlan_serialization_command cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.umac_cmd = umac_cmd; + cmd.is_blocking = is_blocking; + cmd.is_high_priority = is_high_priority; + cmd.cmd_type = WLAN_SER_CMD_NONSCAN; + + return wlan_ser_utf_add_cmd(&cmd); +} + +void wlan_ser_utf_remove_scan_cmd(struct wlan_objmgr_vdev *vdev, + uint32_t cmd_id) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.cmd_type = WLAN_SER_CMD_SCAN; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + wlan_serialization_remove_cmd(&cmd); +} + +void wlan_ser_utf_remove_nonscan_cmd(struct wlan_objmgr_vdev *vdev, + uint32_t cmd_id) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.cmd_type = WLAN_SER_CMD_NONSCAN; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + wlan_serialization_remove_cmd(&cmd); +} + +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) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.queue_type = queue_type; + cmd.req_type = req_type; + cmd.cmd_type = WLAN_SER_CMD_SCAN; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + return wlan_serialization_cancel_request(&cmd); +} + +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) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.queue_type = queue_type; + cmd.req_type = req_type; + cmd.cmd_type = WLAN_SER_CMD_NONSCAN; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + return wlan_serialization_cancel_request(&cmd); +} + +void wlan_ser_utf_remove_start_bss_cmd(struct wlan_objmgr_vdev *vdev, + uint32_t cmd_id) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + wlan_serialization_remove_cmd(&cmd); +} + +void wlan_ser_utf_remove_stop_bss_cmd(struct wlan_objmgr_vdev *vdev, + uint32_t cmd_id) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + wlan_serialization_remove_cmd(&cmd); +} + +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) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.queue_type = queue_type; + cmd.req_type = req_type; + cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + return wlan_serialization_cancel_request(&cmd); +} + +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) +{ + struct wlan_serialization_queued_cmd_info cmd; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.queue_type = queue_type; + cmd.req_type = req_type; + cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS; + cmd.requestor = WLAN_UMAC_COMP_SERIALIZATION; + + return wlan_serialization_cancel_request(&cmd); +} + +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) +{ + struct wlan_serialization_command cmd; + uint8_t queue_type; + enum wlan_serialization_cancel_type req_type; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.umac_cmd = umac_cmd; + cmd.is_blocking = is_blocking; + cmd.is_high_priority = is_high_priority; + cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS; + + /* Command filtering logic */ + req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_start_bss_cmd(vdev, cmd_id, + queue_type, req_type); + + wlan_ser_utf_cancel_stop_bss_cmd(vdev, cmd_id, + queue_type, req_type); + + if (wlan_serialization_is_cmd_present_in_active_queue(NULL, &cmd)) + return WLAN_SER_CMD_ACTIVE; + + return wlan_ser_utf_add_cmd(&cmd); +} + +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) +{ + struct wlan_serialization_command cmd; + uint8_t queue_type; + enum wlan_serialization_cancel_type req_type; + struct wlan_ser_utf_data *data; + + cmd.vdev = vdev; + cmd.cmd_id = cmd_id; + cmd.umac_cmd = umac_cmd; + cmd.is_blocking = is_blocking; + cmd.is_high_priority = is_high_priority; + cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS; + + /* Command filtering logic */ + req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_start_bss_cmd(vdev, cmd_id, + queue_type, req_type); + + if (wlan_serialization_is_cmd_present_in_active_queue(NULL, &cmd)) { + cmd.cmd_type = WLAN_SER_CMD_VDEV_STOP_BSS; + if (!wlan_serialization_is_cmd_present_in_pending_queue( + NULL, &cmd)) { + if (!wlan_ser_utf_data_alloc(&data, vdev, cmd_id)) + return WLAN_SER_CMD_DENIED_UNSPECIFIED; + wlan_ser_utf_add_vdev_stop_bss_cmd( + vdev, cmd_id, (void *)data, + is_high_priority, is_blocking); + } + } + + cmd.cmd_type = WLAN_SER_CMD_VDEV_START_BSS; + return wlan_ser_utf_add_cmd(&cmd); +} + +QDF_STATUS wlan_ser_utf_cb(struct wlan_serialization_command *cmd, + enum wlan_serialization_cb_reason reason) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + uint8_t vdev_id; + struct wlan_ser_utf_data *data; + + if (!cmd) { + ser_err("Error: reason:%d", reason); + QDF_ASSERT(0); + return QDF_STATUS_E_NULL_VALUE; + } + + vdev_id = wlan_vdev_get_id(cmd->vdev); + data = cmd->umac_cmd; + if (!data) { + ser_err("Error: reason:%d", reason); + QDF_ASSERT(0); + return QDF_STATUS_E_NULL_VALUE; + } + + switch (reason) { + case WLAN_SER_CB_ACTIVATE_CMD: + ser_debug("ACTIVATE: cmd_type:%d %9s %s\n", cmd->cmd_type, + SER_UTF_BLOCK_STR(cmd->is_blocking), data->str); + break; + + case WLAN_SER_CB_CANCEL_CMD: + ser_debug("CANCEL : cmd_type:%d %9s %s", cmd->cmd_type, + SER_UTF_BLOCK_STR(cmd->is_blocking), data->str); + break; + + case WLAN_SER_CB_ACTIVE_CMD_TIMEOUT: + ser_debug("TIMEOUT : cmd_type:%d %9s %s", cmd->cmd_type, + SER_UTF_BLOCK_STR(cmd->is_blocking), data->str); + qdf_mem_free(data); + QDF_ASSERT(0); + status = QDF_STATUS_E_INVAL; + break; + + case WLAN_SER_CB_RELEASE_MEM_CMD: + ser_debug("RELEASE : cmd_type:%d %9s %s", cmd->cmd_type, + SER_UTF_BLOCK_STR(cmd->is_blocking), data->str); + qdf_mem_free(data); + break; + + default: + status = QDF_STATUS_E_INVAL; + break; + } + + return status; +} + +static void wlan_ser_utf_scan_timer_cb(void *arg) +{ + struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)arg; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + + wlan_ser_utf_remove_scan_cmd(vdev, ser_utf_vdev[vdev_id].ser_count++); +} + +static void wlan_ser_utf_nonscan_timer_cb(void *arg) +{ + struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)arg; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + + wlan_ser_utf_remove_nonscan_cmd(vdev, + ser_utf_vdev[vdev_id].ser_count++); +} + +void wlan_ser_utf_run(struct wlan_objmgr_vdev *vdev, uint8_t scan_cmd, + uint8_t max_cmds, + bool is_high_priority, bool is_blocking) +{ + struct wlan_ser_utf_data *data; + uint8_t id; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + enum wlan_serialization_status ret; + + if (!max_cmds) + max_cmds = WLAN_SER_UTF_SCAN_CMD_TESTS; + + ser_utf_vdev[vdev_id].ser_count = 0; + for (id = 0; id < max_cmds; id++) { + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + return; + + if (scan_cmd) + ret = wlan_ser_utf_add_scan_cmd(vdev, id, data, + is_high_priority); + else + ret = wlan_ser_utf_add_nonscan_cmd(vdev, id, + data, + is_high_priority, + is_blocking); + } + + for (id = 0; id < max_cmds; id++) { + if (scan_cmd) + qdf_timer_mod( + &ser_utf_vdev[vdev_id].utf_scan_timer[id], + WLAN_SER_UTF_TIMER_TIMEOUT_MS); + else + qdf_timer_mod( + &ser_utf_vdev[vdev_id].utf_nonscan_timer[id], + WLAN_SER_UTF_TIMER_TIMEOUT_MS); + } +} + +static void wlan_ser_utf_init_iter_op(struct wlan_objmgr_pdev *pdev, + void *obj, void *args) +{ + struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + uint8_t id; + + ser_utf_vdev[vdev_id].vdev = vdev; + for (id = 0; id < WLAN_SER_UTF_SCAN_CMD_TESTS; id++) { + qdf_timer_init(NULL, + &ser_utf_vdev[vdev_id].utf_scan_timer[id], + wlan_ser_utf_scan_timer_cb, + (void *)vdev, QDF_TIMER_TYPE_WAKE_APPS); + qdf_timer_init(NULL, + &ser_utf_vdev[vdev_id].utf_nonscan_timer[id], + wlan_ser_utf_nonscan_timer_cb, + (void *)vdev, QDF_TIMER_TYPE_WAKE_APPS); + } +} + +static void wlan_ser_utf_deinit_iter_op(struct wlan_objmgr_pdev *pdev, + void *obj, void *args) +{ + struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + uint8_t id; + + for (id = 0; id < WLAN_SER_UTF_SCAN_CMD_TESTS; id++) { + qdf_timer_free( + &ser_utf_vdev[vdev_id].utf_nonscan_timer[id]); + qdf_timer_free( + &ser_utf_vdev[vdev_id].utf_scan_timer[id]); + } +} + +static void wlan_ser_utf_vdev_iter_op(struct wlan_objmgr_pdev *pdev, + void *obj, void *args) +{ + struct wlan_objmgr_vdev *vdev = (struct wlan_objmgr_vdev *)obj; + uint8_t is_blocking = *(uint8_t *)args; + + wlan_ser_utf_run(vdev, false, 2, false, is_blocking); +} + +/* + * List of available APIs + * 1. wlan_serialization_request( + * struct wlan_serialization_command *cmd) + * 2. wlan_serialization_remove_cmd( + * struct wlan_serialization_queued_cmd_info *cmd_info) + * 3. wlan_serialization_cancel_request( + * struct wlan_serialization_queued_cmd_info *cmd_info) + * sub_val: + * 1st byte : cmd_id + * 2nd byte : scan_cmd + * 3rd byte : queue_type + * 4th byte : req_type + */ +int wlan_ser_utf_main(struct wlan_objmgr_vdev *vdev, uint8_t val, + uint32_t sub_val) +{ + uint8_t id; + uint8_t vdev_id; + static uint8_t wlan_ser_utf_init; + struct wlan_ser_utf_data *data; + bool is_blocking; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + uint8_t cmd_id = (uint8_t)sub_val; + uint8_t scan_cmd = (uint8_t)(sub_val >> 8); + uint8_t queue_type = (uint8_t)(sub_val >> 16); + enum wlan_serialization_cancel_type req_type = (uint8_t)(sub_val >> 24); + + if (wlan_ser_utf_init == 0 && val != 1) { + ser_err("Init UTF before running test cases"); + return 0; + } + + switch (val) { + case SER_UTF_TC_DEINIT: + if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) == + QDF_STATUS_SUCCESS) { + wlan_objmgr_pdev_iterate_obj_list( + pdev, WLAN_VDEV_OP, + wlan_ser_utf_deinit_iter_op, + NULL, 0, WLAN_SERIALIZATION_ID); + wlan_objmgr_pdev_release_ref(pdev, + WLAN_SERIALIZATION_ID); + ser_err("Serialization Timer Deinit Done"); + } + break; + case SER_UTF_TC_INIT: + if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) == + QDF_STATUS_SUCCESS) { + wlan_objmgr_pdev_iterate_obj_list( + pdev, WLAN_VDEV_OP, + wlan_ser_utf_init_iter_op, + NULL, 0, WLAN_SERIALIZATION_ID); + wlan_objmgr_pdev_release_ref(pdev, + WLAN_SERIALIZATION_ID); + wlan_ser_utf_init = 1; + ser_err("Serialization Timer Init Done"); + } + break; + case SER_UTF_TC_ADD: + ser_err("Add:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN", cmd_id); + if (!wlan_ser_utf_data_alloc(&data, vdev, cmd_id)) + break; + + if (scan_cmd) + wlan_ser_utf_add_scan_cmd(vdev, cmd_id, data, false); + else + wlan_ser_utf_add_nonscan_cmd(vdev, cmd_id, data, + false, false); + break; + case SER_UTF_TC_REMOVE: + ser_err("Remove:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN", + cmd_id); + if (scan_cmd) + wlan_ser_utf_remove_scan_cmd(vdev, cmd_id); + else + wlan_ser_utf_remove_nonscan_cmd(vdev, cmd_id); + break; + case SER_UTF_TC_CANCEL: + ser_err("Cancel:%s, id:%d", scan_cmd ? "SCAN" : "NONSCAN", + cmd_id); + if (scan_cmd) + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + else + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, + queue_type, req_type); + break; + case SER_UTF_TC_SINGLE_SCAN: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_scan_cmd(vdev, id, data, false); + wlan_ser_utf_remove_scan_cmd(vdev, id); + break; + case SER_UTF_TC_MULTI_SCAN: + wlan_ser_utf_run(vdev, true, 10, false, false); + break; + case SER_UTF_TC_MAX_SCAN: + wlan_ser_utf_run(vdev, true, 0, false, false); + break; + case SER_UTF_TC_SINGLE_NONSCAN: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + wlan_ser_utf_remove_nonscan_cmd(vdev, id); + break; + case SER_UTF_TC_MULTI_NONSCAN: + wlan_ser_utf_run(vdev, false, 10, false, false); + break; + case SER_UTF_TC_MAX_NONSCAN: + wlan_ser_utf_run(vdev, false, 0, false, false); + break; + case SER_UTF_TC_MULTI_VDEV_NONSCAN: + is_blocking = false; + if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) == + QDF_STATUS_SUCCESS) { + wlan_objmgr_pdev_iterate_obj_list( + pdev, WLAN_VDEV_OP, + wlan_ser_utf_vdev_iter_op, + &is_blocking, 0, WLAN_SERIALIZATION_ID); + wlan_objmgr_pdev_release_ref(pdev, + WLAN_SERIALIZATION_ID); + } + break; + case SER_UTF_TC_CANCEL_SCAN_AC_SINGLE: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_scan_cmd(vdev, id, data, false); + req_type = WLAN_SER_CANCEL_SINGLE_SCAN; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_SCAN_AC_PDEV: + wlan_ser_utf_run(vdev, true, 15, false, false); + req_type = WLAN_SER_CANCEL_PDEV_SCANS; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_SCAN_AC_VDEV: + wlan_ser_utf_run(vdev, true, 15, false, false); + req_type = WLAN_SER_CANCEL_VDEV_SCANS; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_SCAN_PD_SINGLE: + wlan_ser_utf_run(vdev, true, 15, false, false); + req_type = WLAN_SER_CANCEL_SINGLE_SCAN; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_SCAN_PD_PDEV: + wlan_ser_utf_run(vdev, true, 15, false, false); + req_type = WLAN_SER_CANCEL_PDEV_SCANS; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_SCAN_PD_VDEV: + wlan_ser_utf_run(vdev, true, 15, false, false); + req_type = WLAN_SER_CANCEL_VDEV_SCANS; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_scan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_AC_SINGLE: + req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_AC_PDEV: + req_type = WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_AC_VDEV: + req_type = WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_PD_SINGLE: + req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_PD_PDEV: + req_type = WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_CANCEL_NONSCAN_PD_VDEV: + req_type = WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD; + queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; + wlan_ser_utf_cancel_nonscan_cmd(vdev, cmd_id, queue_type, + req_type); + break; + case SER_UTF_TC_START_BSS_FILTERING: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data, + false, false); + + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data, + false, false); + + wlan_ser_utf_remove_start_bss_cmd(vdev, id); + wlan_ser_utf_remove_stop_bss_cmd(vdev, id); + wlan_ser_utf_remove_start_bss_cmd(vdev, id); + break; + case SER_UTF_TC_STOP_BSS_FILTERING: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data, + false, false); + + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_vdev_start_bss_cmd(vdev, id, data, + false, false); + + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_vdev_stop_bss_cmd(vdev, id, data, + false, false); + + wlan_ser_utf_remove_start_bss_cmd(vdev, id); + wlan_ser_utf_remove_stop_bss_cmd(vdev, id); + break; + case SER_UTF_TC_ADD_BLOCKING_NONSCAN_AC_1: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + wlan_ser_utf_remove_nonscan_cmd(vdev, id); + break; + case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_1: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + id = 2; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + break; + case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_2: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + break; + case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_3: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 3; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 4; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + wlan_ser_utf_remove_nonscan_cmd(vdev, 3); + wlan_ser_utf_remove_nonscan_cmd(vdev, 4); + break; + case SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_4: + id = 1; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 3; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 4; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + id = 5; + if (!wlan_ser_utf_data_alloc(&data, vdev, id)) + break; + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + wlan_ser_utf_remove_nonscan_cmd(vdev, 3); + wlan_ser_utf_remove_nonscan_cmd(vdev, 4); + wlan_ser_utf_remove_nonscan_cmd(vdev, 5); + break; + case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_1: + if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) { + ser_err("Requires atleast %d vdevs for the given pdev", + WLAN_SER_UTF_MAX_VDEVS); + break; + } + is_blocking = true; + if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_SERIALIZATION_ID) == + QDF_STATUS_SUCCESS) { + wlan_objmgr_pdev_iterate_obj_list( + pdev, WLAN_VDEV_OP, + wlan_ser_utf_vdev_iter_op, + &is_blocking, 0, WLAN_SERIALIZATION_ID); + wlan_objmgr_pdev_release_ref(pdev, + WLAN_SERIALIZATION_ID); + } + break; + case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_2: + if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) { + ser_err("Requires atleast %d vdevs for the given pdev", + WLAN_SER_UTF_MAX_VDEVS); + break; + } + id = 1; + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id, + data, false, false); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[1].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[1].vdev, id, + data, false, false); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id, + data, false, false); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id, + data, false, true); + + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[1].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id); + break; + case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_3: + if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) { + ser_err("Requires atleast %d vdevs for the given pdev", + WLAN_SER_UTF_MAX_VDEVS); + break; + } + id = 1; + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id, + data, false, true); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[0].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[0].vdev, id, + data, false, false); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[1].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[1].vdev, id, + data, false, false); + + wlan_ser_utf_data_alloc(&data, ser_utf_vdev[2].vdev, id); + wlan_ser_utf_add_nonscan_cmd(ser_utf_vdev[2].vdev, id, + data, false, false); + + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[0].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[1].vdev, id); + wlan_ser_utf_remove_nonscan_cmd(ser_utf_vdev[2].vdev, id); + break; + case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_4: + if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) { + ser_err("Requires atleast %d vdevs for the given pdev", + WLAN_SER_UTF_MAX_VDEVS); + break; + } + for (id = 1; id <= 2; id++) { + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) { + wlan_ser_utf_data_alloc( + &data, + ser_utf_vdev[vdev_id].vdev, id); + wlan_ser_utf_add_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, + id, data, false, false); + } + } + + id = 3; + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; vdev_id++) { + wlan_ser_utf_data_alloc( + &data, ser_utf_vdev[vdev_id].vdev, id); + wlan_ser_utf_add_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, id, + data, false, true); + } + + for (id = 1; id <= 3; id++) { + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) + wlan_ser_utf_remove_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, id); + } + break; + case SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_5: + if (wlan_pdev_get_vdev_count(pdev) < WLAN_SER_UTF_MAX_VDEVS) { + ser_err("Requires atleast %d vdevs for the given pdev", + WLAN_SER_UTF_MAX_VDEVS); + break; + } + id = 1; + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) { + wlan_ser_utf_data_alloc( + &data, + ser_utf_vdev[vdev_id].vdev, id); + wlan_ser_utf_add_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, + id, data, false, false); + } + id = 2; + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) { + wlan_ser_utf_data_alloc( + &data, + ser_utf_vdev[vdev_id].vdev, id); + wlan_ser_utf_add_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, + id, data, false, true); + } + id = 3; + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) { + wlan_ser_utf_data_alloc( + &data, + ser_utf_vdev[vdev_id].vdev, id); + wlan_ser_utf_add_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, + id, data, false, false); + } + + for (id = 1; id <= 3; id++) { + for (vdev_id = 0; vdev_id < WLAN_SER_UTF_MAX_VDEVS; + vdev_id++) + wlan_ser_utf_remove_nonscan_cmd( + ser_utf_vdev[vdev_id].vdev, id); + } + break; + case SER_UTF_TC_HIGH_PRIO_NONSCAN_WO_BL: + id = 1; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 3; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 4; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, false); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 4); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + wlan_ser_utf_remove_nonscan_cmd(vdev, 3); + break; + case SER_UTF_TC_HIGH_PRIO_NONSCAN_W_BL: + id = 1; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, true); + + id = 3; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, false); + + id = 4; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 3); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + wlan_ser_utf_remove_nonscan_cmd(vdev, 4); + break; + case SER_UTF_TC_HIGH_PRIO_BL_NONSCAN: + id = 1; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 2; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 3; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, false, false); + + id = 4; + wlan_ser_utf_data_alloc(&data, vdev, id); + wlan_ser_utf_add_nonscan_cmd(vdev, id, data, true, true); + + wlan_ser_utf_remove_nonscan_cmd(vdev, 1); + wlan_ser_utf_remove_nonscan_cmd(vdev, 4); + wlan_ser_utf_remove_nonscan_cmd(vdev, 2); + wlan_ser_utf_remove_nonscan_cmd(vdev, 3); + break; + default: + ser_err("Error: Unknown val"); + break; + } + + return 0; +} diff --git a/umac/cmn_services/serialization/src/wlan_serialization_utf_i.h b/umac/cmn_services/serialization/src/wlan_serialization_utf_i.h new file mode 100644 index 000000000000..0ccac18abf23 --- /dev/null +++ b/umac/cmn_services/serialization/src/wlan_serialization_utf_i.h @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2018 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all + * copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * DOC: Defines the data structures used by the unit test framework for + * serialization module + */ + +#ifndef _WLAN_SERIALIZATION_UTF_I_H_ +#define _WLAN_SERIALIZATION_UTF_I_H_ + +#define WLAN_SER_UTF_MAX_VDEVS 4 +#define WLAN_SER_UTF_SCAN_CMD_TESTS 33 +#define WLAN_SER_UTF_TIMER_TIMEOUT_MS 5000 +#define WLAN_SER_UTF_TEST_CMD_TIMEOUT_MS 30000 + +/* Sample string: SER_Vxx_Cxx */ +#define WLAN_SER_UTF_STR_SIZE 15 +#define WLAN_SER_DATA_STR(_s, _v, _i) \ + scnprintf(_s, WLAN_SER_UTF_STR_SIZE, "SER_V%u_C%u", _v, _i) + +#define SER_UTF_BLOCK_STR(_x) (_x ? "BLOCK" : "NON-BLOCK") + +char *wlan_serialization_status_strings[] = { + "WLAN_SER_CMD_PENDING", + "WLAN_SER_CMD_ACTIVE", + "WLAN_SER_CMD_DENIED_RULES_FAILED", + "WLAN_SER_CMD_DENIED_LIST_FULL", + "WLAN_SER_CMD_DENIED_UNSPECIFIED", +}; + +/** + * enum wlan_ser_utf_tc_id - Test case id + * @SER_UTF_TC_DEINIT: Deinit UTF + * @SER_UTF_TC_INIT: Init UTF + * @SER_UTF_TC_ADD: Add a custom cmd to queue + * @SER_UTF_TC_REMOVE: Remove a custom cmd from queue + * @SER_UTF_TC_CANCEL: Cancel a custom cmd from queue + * @SER_UTF_TC_SINGLE_SCAN: Add and remove a single scan cmd + * @SER_UTF_TC_MULTI_SCAN: Add and remove a multiple scan cmd + * @SER_UTF_TC_MAX_SCAN: Add and remove a maximum scan cmd + * @SER_UTF_TC_SINGLE_NONSCAN: Add and remove a single nonscan cmd + * @SER_UTF_TC_MULTI_NONSCAN: Add and remove a multiple nonscan cmd + * @SER_UTF_TC_MAX_NONSCAN: Add and remove a maximum nonscan cmd + * @SER_UTF_TC_MULTI_VDEV_NONSCAN: Add nonscan cmd across multiple vdev + * @SER_UTF_TC_CANCEL_SCAN_AC_SINGLE: Cancel single scan from active queue + * @SER_UTF_TC_CANCEL_SCAN_AC_PDEV: Cancel pdev scan from active queue + * @SER_UTF_TC_CANCEL_SCAN_AC_VDEV: Cancel vdev scan from active queue + * @SER_UTF_TC_CANCEL_SCAN_PD_SINGLE: Cancel single scan from pending queue + * @SER_UTF_TC_CANCEL_SCAN_PD_PDEV: Cancel pdev scan from pending queue + * @SER_UTF_TC_CANCEL_SCAN_PD_VDEV: Cancel vdev scan from pending queue + * @SER_UTF_TC_CANCEL_NONSCAN_AC_SINGLE: Cancel single nonscan from active queue + * @SER_UTF_TC_CANCEL_NONSCAN_AC_PDEV: Cancel pdev nonscan from active queue + * @SER_UTF_TC_CANCEL_NONSCAN_AC_VDEV: Cancel vdev nonscan from active queue + * @SER_UTF_TC_CANCEL_NONSCAN_PD_SINGLE: Cancel nonscan from pending queue + * @SER_UTF_TC_CANCEL_NONSCAN_PD_PDEV: Cancel pdev nonscan from pending queue + * @SER_UTF_TC_CANCEL_NONSCAN_PD_VDEV: Cancel vdev nonscan from pending queue + * @SER_UTF_TC_START_BSS_FILTERING: Test start_bss filtering logic + * @SER_UTF_TC_STOP_BSS_FILTERING: Test stop_bss filtering logic + * @SER_UTF_TC_ADD_BLOCKING_NONSCAN_AC_1: Add blocking cmd to active queue + * @SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_1: Add blocking cmd to pending queue with + * blocking cmd in active queue + * @SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_2: Add blocking cmd to pending queue with + * non-blocking cmd in active queue + * @SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_3: Add blocking cmd to tail of + * pending queue with non-blocking cmd in active queue + * @SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_4: Add blocking cmd to pending between + * non-blocking cmd in pending and active queue + * @SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_1: Add blocking nonscan cmd + * across multiple vdev + * @SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_2: Add blocking nonscan cmd + * to a pending queue of vdev with non-blocking across multi vdev + * @SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_3: Add blocking nonscan cmd + * to a active queue of vdev with non-blocking across multiple vdev + * @SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_4: Add blocking nonscan cmd to the + * pending queue of multi vdev with non-blocking across multi vdev + * @SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_5: Add blocking nonscan cmd to the + * pending queue of multi vdev with non-blocking across multi vdev + * in pending and active queue + * @SER_UTF_TC_HIGH_PRIO_NONSCAN_WO_BL: Add high priority nonscan cmd + * to the tail of pending queue + * @SER_UTF_TC_HIGH_PRIO_NONSCAN_W_BL: Add high priority nonscan cmd + * to the pending queue between normal priority command + * @SER_UTF_TC_HIGH_PRIO_BL_NONSCAN: Add high priority blocking + * nonscan cmd to the tail of pending queue + */ +enum wlan_ser_utf_tc_id { + SER_UTF_TC_DEINIT, + SER_UTF_TC_INIT, + SER_UTF_TC_ADD, + SER_UTF_TC_REMOVE, + SER_UTF_TC_CANCEL, + SER_UTF_TC_SINGLE_SCAN, + SER_UTF_TC_MULTI_SCAN, + SER_UTF_TC_MAX_SCAN, + SER_UTF_TC_SINGLE_NONSCAN, + SER_UTF_TC_MULTI_NONSCAN, + SER_UTF_TC_MAX_NONSCAN, + SER_UTF_TC_MULTI_VDEV_NONSCAN, + SER_UTF_TC_CANCEL_SCAN_AC_SINGLE, + SER_UTF_TC_CANCEL_SCAN_AC_PDEV, + SER_UTF_TC_CANCEL_SCAN_AC_VDEV, + SER_UTF_TC_CANCEL_SCAN_PD_SINGLE, + SER_UTF_TC_CANCEL_SCAN_PD_PDEV, + SER_UTF_TC_CANCEL_SCAN_PD_VDEV, + SER_UTF_TC_CANCEL_NONSCAN_AC_SINGLE, + SER_UTF_TC_CANCEL_NONSCAN_AC_PDEV, + SER_UTF_TC_CANCEL_NONSCAN_AC_VDEV, + SER_UTF_TC_CANCEL_NONSCAN_PD_SINGLE, + SER_UTF_TC_CANCEL_NONSCAN_PD_PDEV, + SER_UTF_TC_CANCEL_NONSCAN_PD_VDEV, + SER_UTF_TC_START_BSS_FILTERING, + SER_UTF_TC_STOP_BSS_FILTERING, + SER_UTF_TC_ADD_BLOCKING_NONSCAN_AC_1, + SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_1, + SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_2, + SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_3, + SER_UTF_TC_ADD_BLOCKING_NONSCAN_PD_4, + SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_1, + SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_2, + SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_3, + SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_4, + SER_UTF_TC_MULTI_VDEV_BL_NONSCAN_5, + SER_UTF_TC_HIGH_PRIO_NONSCAN_WO_BL, + SER_UTF_TC_HIGH_PRIO_NONSCAN_W_BL, + SER_UTF_TC_HIGH_PRIO_BL_NONSCAN, +}; + +/** + * struct wlan_ser_utf_data - Test data + * @id - Test variable + * @str - String tag associated with the command + */ +struct wlan_ser_utf_data { + uint8_t id; + char str[WLAN_SER_UTF_STR_SIZE + 1]; +}; + +/** + * struct wlan_ser_utf_vdev_info - Information used by the vdevs + * @vdev: Vdev object manager information + * @ser_count: Serialization command count for the vdev + * @utf_scan_timer: Timer for scan commands + * @utf_nonscan_timer: Timer for non-scan commands + */ +struct wlan_ser_utf_vdev_info { + struct wlan_objmgr_vdev *vdev; + uint8_t ser_count; + qdf_timer_t utf_scan_timer[WLAN_SER_UTF_SCAN_CMD_TESTS]; + qdf_timer_t utf_nonscan_timer[WLAN_SER_UTF_SCAN_CMD_TESTS]; +}; + +/** + * wlan_ser_utf_cb() - Serialization callback function + * @cmd: Serialization command info + * @reason: Serialization reason for callback execution + * + * Return: Status of callback execution + */ +QDF_STATUS wlan_ser_utf_cb(struct wlan_serialization_command *cmd, + enum wlan_serialization_cb_reason reason); + +#endif /* _WLAN_SERIALIZATION_UTF_I_H_ */ +