xref: /wlan-driver/qca-wifi-host-cmn/umac/cmn_services/serialization/src/wlan_serialization_utils_i.h

/*
 * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. 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: wlan_serialization_utils_i.h
 * This file defines the prototypes for the utility helper functions
 * for the serialization component.
 */
#ifndef __WLAN_SERIALIZATION_UTILS_I_H
#define __WLAN_SERIALIZATION_UTILS_I_H

#include <qdf_status.h>
#include <qdf_list.h>
#include <qdf_mc_timer.h>
#include <wlan_objmgr_cmn.h>
#include <wlan_objmgr_global_obj.h>
#include <wlan_objmgr_psoc_obj.h>
#include <wlan_scan_ucfg_api.h>
#include "wlan_serialization_rules_i.h"
#ifdef WLAN_SER_DEBUG
#include "wlan_serialization_debug_i.h"
#endif

/*
 * Below bit positions are used to identify if a
 * serialization command is in use or marked for
 * deletion.
 * CMD_MARKED_FOR_ACTIVATION - The command is about to be activated
 * CMD_IS_ACTIVE - The command is active and currently in use
 */
#define CMD_MARKED_FOR_ACTIVATION     1
#define CMD_IS_ACTIVE                 2
#define CMD_ACTIVE_MARKED_FOR_CANCEL  3
#define CMD_ACTIVE_MARKED_FOR_REMOVAL 4
#define CMD_MARKED_FOR_MOVEMENT       5
/**
 * struct wlan_serialization_timer - Timer used for serialization
 * @cmd:      Cmd to which the timer is linked
 * @timer:    Timer associated with the command
 *
 * Timers are allocated statically during init, one each for the
 * maximum active commands permitted in the system. Once a cmd is
 * moved from pending list to active list, the timer is activated
 * and once the cmd is completed, the timer is cancelled. Timer is
 * also cancelled if the command is aborted
 *
 * The timers are maintained per psoc. A timer is associated to
 * unique combination of pdev, cmd_type and cmd_id.
 */
struct wlan_serialization_timer {
	struct wlan_serialization_command *cmd;
	qdf_timer_t timer;
};

/**
 * enum wlan_serialization_node - Types of available nodes in serialization list
 * @WLAN_SER_PDEV_NODE: pdev node from the pdev queue
 * @WLAN_SER_VDEV_NODE: vdev node from the vdev queue
 */
enum wlan_serialization_node {
	WLAN_SER_PDEV_NODE,
	WLAN_SER_VDEV_NODE,
};

/**
 * struct wlan_serialization_command_list - List of commands to be serialized
 * @pdev_node: PDEV node identifier in the list
 * @vdev_node: VDEV node identifier in the list
 * @cmd: Command to be serialized
 * @cmd_in_use: flag to check if the node/entry is logically active
 */
struct wlan_serialization_command_list {
	qdf_list_node_t pdev_node;
	qdf_list_node_t vdev_node;
	struct wlan_serialization_command cmd;
	unsigned long cmd_in_use;
};

/**
 * struct wlan_serialization_pdev_queue - queue data related to pdev
 * @active_list: list to hold the commands currently being executed
 * @pending_list: list to hold the commands currently pending
 * @cmd_pool_list: list to hold the global command pool
 * @vdev_active_cmd_bitmap: Active cmd bitmap of vdev for the given pdev
 * @blocking_cmd_active: Indicate if a blocking cmd is in active execution
 * @blocking_cmd_waiting: Indicate if a blocking cmd is in pending queue
 * @pdev_queue_lock: pdev lock to protect concurrent operations on the queues
 * @history: serialization history
 */
struct wlan_serialization_pdev_queue {
	qdf_list_t active_list;
	qdf_list_t pending_list;
	qdf_list_t cmd_pool_list;
	qdf_bitmap(vdev_active_cmd_bitmap, WLAN_UMAC_PSOC_MAX_VDEVS);
	bool blocking_cmd_active;
	uint16_t blocking_cmd_waiting;
	qdf_spinlock_t pdev_queue_lock;
#ifdef WLAN_SER_DEBUG
	struct ser_history history;
#endif
};

/**
 * struct wlan_serialization_vdev_queue - queue data related to vdev
 * @active_list: list to hold the commands currently being executed
 * @pending_list: list: to hold the commands currently pending
 * @queue_disable: is the queue disabled
 */
struct wlan_serialization_vdev_queue {
	qdf_list_t active_list;
	qdf_list_t pending_list;
	bool queue_disable;
};

/**
 * enum serialization_pdev_queue_type - Types of available pdev queues
 * @SER_PDEV_QUEUE_COMP_SCAN: Scan queue
 * @SER_PDEV_QUEUE_COMP_NON_SCAN: Non Scan queue
 * @SER_PDEV_QUEUE_COMP_MAX: Max enumeration
 */
enum serialization_pdev_queue_type {
	SER_PDEV_QUEUE_COMP_SCAN,
	SER_PDEV_QUEUE_COMP_NON_SCAN,
	SER_PDEV_QUEUE_COMP_MAX,
};

/**
 * enum serialization_vdev_queue_type - Types of available vdev queues
 * @SER_VDEV_QUEUE_COMP_NON_SCAN: Non Scan queue
 * @SER_VDEV_QUEUE_COMP_MAX: Max enumeration
 */
enum serialization_vdev_queue_type {
	SER_VDEV_QUEUE_COMP_NON_SCAN,
	SER_VDEV_QUEUE_COMP_MAX,
};

/**
 * enum wlan_serialization_match_type - Comparison options for a command
 * @WLAN_SER_MATCH_VDEV: Compare vdev
 * @WLAN_SER_MATCH_PDEV: Compare pdev
 * @WLAN_SER_MATCH_CMD_TYPE_VDEV: Compare command type and vdev
 * @WLAN_SER_MATCH_CMD_ID_VDEV: Compare command id and vdev
 * @WLAN_SER_MATCH_MAX: Max enumeration
 */
enum wlan_serialization_match_type {
	WLAN_SER_MATCH_VDEV,
	WLAN_SER_MATCH_PDEV,
	WLAN_SER_MATCH_CMD_TYPE_VDEV,
	WLAN_SER_MATCH_CMD_ID_VDEV,
	WLAN_SER_MATCH_MAX,
};

/**
 * struct wlan_ser_pdev_obj - pdev obj data for serialization
 * @pdev_q: Array of pdev queues
 */
struct wlan_ser_pdev_obj {
	struct wlan_serialization_pdev_queue pdev_q[SER_PDEV_QUEUE_COMP_MAX];
};

/**
 * struct wlan_ser_vdev_obj - Serialization private object of vdev
 * @vdev_q: Array of vdev queues
 */
struct wlan_ser_vdev_obj {
	struct wlan_serialization_vdev_queue vdev_q[SER_VDEV_QUEUE_COMP_MAX];
};

/**
 * struct wlan_ser_psoc_obj - psoc obj data for serialization
 * @comp_info_cb: module level callback
 * @apply_rules_cb: pointer to apply rules on the cmd
 * @timers: Timers associated with the active commands
 * @max_active_cmds: Maximum active commands allowed
 * @timer_lock: lock for @timers
 *
 * Serialization component takes a command as input and checks whether to
 * allow/deny the command. It will use the module level callback registered
 * by each component to fetch the information needed to apply the rules.
 * Once the information is available, the rules callback registered for each
 * command internally by serialization will be applied to determine the
 * checkpoint for the command. If allowed, command will be put into active/
 * pending list and each active command is associated with a timer.
 */
struct wlan_ser_psoc_obj {
	wlan_serialization_comp_info_cb comp_info_cb[WLAN_SER_CMD_MAX][WLAN_UMAC_COMP_ID_MAX];
	wlan_serialization_apply_rules_cb apply_rules_cb[WLAN_SER_CMD_MAX];
	struct wlan_serialization_timer *timers;
	uint8_t max_active_cmds;
	qdf_spinlock_t timer_lock;
};

/**
 * wlan_serialization_remove_cmd_from_queue() - to remove command from
 *							given queue
 * @queue: queue from which command needs to be removed
 * @cmd: command to match in the queue
 * @pcmd_list: Pointer to command list containing the command
 * @ser_pdev_obj: pointer to private pdev serialization object
 * @node_type: Pdev node or vdev node
 *
 * This API takes the queue, it matches the provided command from this queue
 * and removes it. Before removing the command, it will notify the caller
 * that if it needs to remove any memory allocated by caller.
 *
 * Return: QDF_STATUS_SUCCESS on success, error code on failure
 */
QDF_STATUS
wlan_serialization_remove_cmd_from_queue(
		qdf_list_t *queue,
		struct wlan_serialization_command *cmd,
		struct wlan_serialization_command_list **pcmd_list,
		struct wlan_ser_pdev_obj *ser_pdev_obj,
		enum wlan_serialization_node node_type);

/**
 * wlan_serialization_add_cmd_to_queue() - Add a cmd to given queue
 * @queue: queue to which command needs to be added
 * @cmd_list: Pointer to command list containing the command
 * @ser_pdev_obj: pointer to private pdev serialization object
 * @is_cmd_for_active_queue: Add cmd to active or pending queue
 * @node_type: Pdev node or vdev node
 *
 * Return: Status of the serialization request
 */
enum wlan_serialization_status
wlan_serialization_add_cmd_to_queue(
		qdf_list_t *queue,
		struct wlan_serialization_command_list *cmd_list,
		struct wlan_ser_pdev_obj *ser_pdev_obj,
		uint8_t is_cmd_for_active_queue,
		enum wlan_serialization_node node_type);

/**
 * wlan_serialization_get_psoc_from_cmd() - get psoc from provided cmd
 * @cmd: pointer to actual command
 *
 * This API will get the pointer to psoc through checking type of cmd
 *
 * Return: pointer to psoc
 */
struct wlan_objmgr_psoc*
wlan_serialization_get_psoc_from_cmd(struct wlan_serialization_command *cmd);

/**
 * wlan_serialization_get_pdev_from_cmd() - get pdev from provided cmd
 * @cmd: pointer to actual command
 *
 * This API will get the pointer to pdev through checking type of cmd
 *
 * Return: pointer to pdev
 */
struct wlan_objmgr_pdev*
wlan_serialization_get_pdev_from_cmd(struct wlan_serialization_command *cmd);

/**
 * wlan_serialization_get_vdev_from_cmd() - get vdev from provided cmd
 * @cmd: pointer to actual command
 *
 * This API will get the pointer to vdev through checking type of cmd
 *
 * Return: pointer to vdev
 */
struct wlan_objmgr_vdev*
wlan_serialization_get_vdev_from_cmd(struct wlan_serialization_command *cmd);

/**
 * wlan_serialization_get_cmd_from_queue() - to extract command from given queue
 * @queue: pointer to queue
 * @nnode: next node to extract
 *
 * This API will try to extract node from queue which is next to prev node. If
 * no previous node is given then take out the front node of the queue.
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_get_cmd_from_queue(
		qdf_list_t *queue, qdf_list_node_t **nnode);

/**
 * wlan_serialization_stop_timer() - to stop particular timer
 * @ser_timer: pointer to serialization timer
 *
 * This API stops the particular timer
 *
 * Return: QDF_STATUS
 */
QDF_STATUS
wlan_serialization_stop_timer(struct wlan_serialization_timer *ser_timer);

/**
 * wlan_serialization_cleanup_vdev_timers() - clean-up all timers for a vdev
 *
 * @vdev: pointer to vdev object
 *
 * This API is to cleanup all the timers for a vdev.
 * It can be used when serialization vdev destroy is called.
 * It will make sure that if timer is running then it will
 * stop and destroys the timer
 *
 * Return: QDF_STATUS
 */

QDF_STATUS wlan_serialization_cleanup_vdev_timers(
			struct wlan_objmgr_vdev *vdev);

/**
 * wlan_serialization_cleanup_all_timers() - to clean-up all timers
 *
 * @psoc_ser_ob: pointer to serialization psoc private object
 *
 * This API is to cleanup all the timers. it can be used when serialization
 * module is exiting. it will make sure that if timer is running then it will
 * stop and destroys the timer
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_cleanup_all_timers(
	struct wlan_ser_psoc_obj *psoc_ser_ob);

/**
 * wlan_serialization_validate_cmd() - Validate the command
 * @comp_id: Component ID
 * @cmd_type: Command Type
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_validate_cmd(
		 enum wlan_umac_comp_id comp_id,
		 enum wlan_serialization_cmd_type cmd_type);

/**
 * wlan_serialization_validate_cmd_list() - Validate the command list
 * @cmd_list: Serialization command list
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_validate_cmd_list(
		struct wlan_serialization_command_list *cmd_list);

/**
 * wlan_serialization_validate_cmdtype() - Validate the command type
 * @cmd_type: Command Type
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_validate_cmdtype(
		 enum wlan_serialization_cmd_type cmd_type);

/**
 * wlan_serialization_destroy_pdev_list() - Release the pdev cmds and
 * destroy list
 * @pdev_queue: Pointer to the pdev queue
 *
 * Return: None
 */
void wlan_serialization_destroy_pdev_list(
		struct wlan_serialization_pdev_queue *pdev_queue);

/**
 * wlan_serialization_destroy_vdev_list() - Release the vdev cmds and
 * destroy list
 * @list: List to be destroyed
 *
 * Return: None
 */
void wlan_serialization_destroy_vdev_list(qdf_list_t *list);

/**
 * wlan_serialization_get_psoc_obj() - Return the component private obj
 * @psoc: Pointer to the PSOC object
 *
 * Return: Serialization component's PSOC level private data object
 */
struct wlan_ser_psoc_obj *wlan_serialization_get_psoc_obj(
		struct wlan_objmgr_psoc *psoc);

/**
 * wlan_serialization_get_pdev_obj() - Return the component private obj
 * @pdev: Pointer to the PDEV object
 *
 * Return: Serialization component's PDEV level private data object
 */
struct wlan_ser_pdev_obj *wlan_serialization_get_pdev_obj(
		struct wlan_objmgr_pdev *pdev);

/**
 * wlan_serialization_get_vdev_obj() - Return the component private obj
 * @vdev: Pointer to the VDEV object
 *
 * Return: Serialization component's VDEV level private data object
 */
struct wlan_ser_vdev_obj *wlan_serialization_get_vdev_obj(
		struct wlan_objmgr_vdev *vdev);

/**
 * wlan_serialization_is_cmd_in_vdev_list() - Check Node present in VDEV list
 * @vdev: Pointer to the VDEV object
 * @queue: Pointer to the qdf_list_t
 * @node_type: Pdev node or vdev node
 *
 * Return: Boolean true or false
 */
bool
wlan_serialization_is_cmd_in_vdev_list(
		struct wlan_objmgr_vdev *vdev, qdf_list_t *queue,
		enum wlan_serialization_node node_type);

/**
 * wlan_serialization_is_cmd_in_pdev_list() - Check Node present in PDEV list
 * @pdev: Pointer to the PDEV object
 * @queue: Pointer to the qdf_list_t
 *
 * Return: Boolean true or false
 */
bool
wlan_serialization_is_cmd_in_pdev_list(
		struct wlan_objmgr_pdev *pdev, qdf_list_t *queue);

/**
 * wlan_serialization_is_cmd_in_active_pending() - return cmd status
 *						active/pending queue
 * @cmd_in_active: CMD in active list
 * @cmd_in_pending: CMD in pending list
 *
 * Return: enum wlan_serialization_cmd_status
 */
enum wlan_serialization_cmd_status
wlan_serialization_is_cmd_in_active_pending(
		bool cmd_in_active, bool cmd_in_pending);

/**
 * wlan_serialization_is_cmd_present_in_given_queue() - Check if the cmd is
 * present in the given queue
 * @queue: List of commands which has to be searched
 * @cmd: Serialization command information
 * @node_type: Pdev node or vdev node
 *
 * Return: Boolean true or false
 */
bool wlan_serialization_is_cmd_present_in_given_queue(
		qdf_list_t *queue,
		struct wlan_serialization_command *cmd,
		enum wlan_serialization_node node_type);

/**
 * wlan_serialization_timer_destroy() - destroys the timer
 * @ser_timer: pointer to particular timer
 *
 * This API destroys the memory allocated by timer and assigns cmd member of
 * that timer structure to NULL
 *
 * Return: QDF_STATUS
 */
QDF_STATUS wlan_serialization_timer_destroy(
		struct wlan_serialization_timer *ser_timer);

/**
 * wlan_serialization_list_empty() - check if the list is empty
 * @queue: Queue/List that needs to be checked for emptiness
 *
 * Return: true if list is empty and false otherwise
 */
bool wlan_serialization_list_empty(qdf_list_t *queue);

/**
 * wlan_serialization_list_size() - Find the size of the provided queue
 * @queue: Queue/List for which the size/length is to be returned
 *
 * Return: size/length of the queue/list
 */
uint32_t wlan_serialization_list_size(qdf_list_t *queue);

/**
 * wlan_serialization_match_cmd_type() - Check for a match on given nnode
 * @nnode: The node on which the matching has to be done
 * @cmd_type: Command type that needs to be matched
 * @node_type: Pdev node or vdev node
 *
 * This API will check if the cmd ID and cmd type of the given nnode are
 * matching with the one's that are being passed to this function.
 *
 * Return: True if matched,false otherwise.
 */
bool wlan_serialization_match_cmd_type(
			qdf_list_node_t *nnode,
			enum wlan_serialization_cmd_type cmd_type,
			enum wlan_serialization_node node_type);

/**
 * wlan_serialization_match_cmd_id_type() - Check for a match on given nnode
 * @nnode: The node on which the matching has to be done
 * @cmd: Command that needs to be matched
 * @node_type: Pdev node or vdev node
 *
 * This API will check if the cmd ID and cmd type of the given nnode are
 * matching with the one's that are being passed to this function.
 *
 * Return: True if matched,false otherwise.
 */
bool wlan_serialization_match_cmd_id_type(
			qdf_list_node_t *nnode,
			struct wlan_serialization_command *cmd,
			enum wlan_serialization_node node_type);

/**
 * wlan_serialization_match_cmd_vdev() - Check for a match on given nnode
 * @nnode: The node on which the matching has to be done
 * @vdev: VDEV object that needs to be matched
 * @node_type: Pdev node or vdev node
 *
 * This API will check if the VDEV object of the given nnode are
 * matching with the one's that are being passed to this function.
 *
 * Return: True if matched,false otherwise.
 */
bool wlan_serialization_match_cmd_vdev(qdf_list_node_t *nnode,
				       struct wlan_objmgr_vdev *vdev,
				       enum wlan_serialization_node node_type);

/**
 * wlan_serialization_match_cmd_pdev() - Check for a match on given nnode
 * @nnode: The node on which the matching has to be done
 * @pdev: pdev object that needs to be matched
 * @node_type: Node type. Pdev node or vdev node
 *
 * This API will check if the PDEV object of the given nnode are
 * matching with the one's that are being passed to this function.
 *
 * Return: True if matched,false otherwise.
 */
bool wlan_serialization_match_cmd_pdev(qdf_list_node_t *nnode,
				       struct wlan_objmgr_pdev *pdev,
				       enum wlan_serialization_node node_type);

/**
 * wlan_serialization_match_cmd_blocking() - Check for a blocking cmd
 * @nnode: The node on which the matching has to be done
 * @node_type: Pdev node or vdev node
 *
 * This API will check if the give command of nnode is a blocking command.
 *
 * Return: True if blocking command, false otherwise.
 */
bool wlan_serialization_match_cmd_blocking(
		qdf_list_node_t *nnode,
		enum wlan_serialization_node node_type);

/**
 * wlan_serialization_find_cmd() - Find the cmd matching the given criteria
 * @queue: Queue to search
 * @match_type: Match criteria
 * @cmd: Serialization command information
 * @cmd_type: Command type to be matched
 * @pdev: pdev object that needs to be matched
 * @vdev: vdev object that needs to be matched
 * @node_type: Node type. Pdev node or vdev node
 *
 * Return: Pointer to the node member in the list
 */
qdf_list_node_t *
wlan_serialization_find_cmd(qdf_list_t *queue, uint32_t match_type,
			    struct wlan_serialization_command *cmd,
			    enum wlan_serialization_cmd_type cmd_type,
			    struct wlan_objmgr_pdev *pdev,
			    struct wlan_objmgr_vdev *vdev,
			    enum wlan_serialization_node node_type);

/**
 * wlan_serialization_remove_front() - Remove the front node of the list
 * @list: List from which the node is to be removed
 * @node: Pointer to store the node that is removed
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_remove_front(
			qdf_list_t *list,
			qdf_list_node_t **node);

/**
 * wlan_serialization_remove_node() - Remove the given node from the list
 * @list: List from which the node is to be removed
 * @node: Pointer to the node that is to be removed
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_remove_node(
			qdf_list_t *list,
			qdf_list_node_t *node);

/**
 * wlan_serialization_insert_front() - Insert a node into the front of the list
 * @list: List to which the node is to be inserted
 * @node: Pointer to the node that is to be inserted
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_insert_front(
			qdf_list_t *list,
			qdf_list_node_t *node);

/**
 * wlan_serialization_insert_back() - Insert a node into the back of the list
 * @list: List to which the node is to be inserted
 * @node: Pointer to the node that is to be inserted
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_insert_back(
			qdf_list_t *list,
			qdf_list_node_t *node);

/**
 * wlan_serialization_peek_front() - Peek the front node of the list
 * @list: List on which the node is to be peeked
 * @node: Pointer to the store the node that is being peeked
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_peek_front(
			qdf_list_t *list,
			qdf_list_node_t **node);

/**
 * wlan_serialization_peek_next() - Peek the next node of the list
 * @list: List on which the node is to be peeked
 * @node1: Pointer to the node1 from where the next node has to be peeked
 * @node2: Pointer to the store the node that is being peeked
 *
 * Return: QDF_STATUS Success or Failure
 */
QDF_STATUS wlan_serialization_peek_next(
			qdf_list_t *list,
			qdf_list_node_t *node1,
			qdf_list_node_t **node2);

/**
 * wlan_serialization_acquire_lock() - Acquire lock to the given queue
 * @lock: Pointer to the lock
 *
 * Return: QDF_STATUS success or failure
 */
QDF_STATUS
wlan_serialization_acquire_lock(qdf_spinlock_t *lock);

/**
 * wlan_serialization_release_lock() - Release lock to the given queue
 * @lock: Pointer to the lock
 *
 * Return: QDF_STATUS success or failure
 */
QDF_STATUS
wlan_serialization_release_lock(qdf_spinlock_t *lock);

/**
 * wlan_serialization_create_lock() - Init the lock to the given queue
 * @lock: Pointer to the lock
 *
 * Return: QDF_STATUS success or failure
 */
QDF_STATUS
wlan_serialization_create_lock(qdf_spinlock_t *lock);

/**
 * wlan_serialization_destroy_lock() - Deinit the lock to the given queue
 * @lock: Pointer to the lock
 *
 * Return: QDF_STATUS success or failure
 */
QDF_STATUS
wlan_serialization_destroy_lock(qdf_spinlock_t *lock);

/**
 * wlan_serialization_any_vdev_cmd_active() - Check any vdev cmd active for pdev
 * @pdev_queue: serialization pdev queue object
 *
 * Return: true or false
 */
bool wlan_serialization_any_vdev_cmd_active(
		struct wlan_serialization_pdev_queue *pdev_queue);

/**
 * wlan_ser_update_cmd_history() - Update serialization queue history
 * @pdev_queue:serialization pdev queue
 * @cmd: cmd to be added/remeoved
 * @ser_reason: serialization action that resulted in addition/removal
 * @add_remove: added or removed from queue
 * @active_queue:for active queue
 *
 * Return: QDF_STATUS success or failure
 */

void wlan_ser_update_cmd_history(
		struct wlan_serialization_pdev_queue *pdev_queue,
		struct wlan_serialization_command *cmd,
		enum ser_queue_reason ser_reason,
		bool add_remove,
		bool active_queue);

#endif