Migrated utils and trace to FVID2
authorSivaraj R <sivaraj@ti.com>
Sun, 8 Apr 2018 15:24:47 +0000 (20:54 +0530)
committerSivaraj R <sivaraj@ti.com>
Sun, 8 Apr 2018 15:29:11 +0000 (20:59 +0530)
Signed-off-by: Sivaraj R <sivaraj@ti.com>
fvid2.h
fvid2_component.mk
include/fvid2_drvMgr.h
include/fvid2_utils.h [new file with mode: 0644]
include/trace.h [new file with mode: 0644]
src/fvid2_drvMgr.c
src/fvid2_utils.c [new file with mode: 0644]
src/makefile

diff --git a/fvid2.h b/fvid2.h
index 37c1017911855b9c3d86dae5ee918f5230b01a4f..1cbe34abf69a0d34afc9f0368998b0cdf2c177cc 100644 (file)
--- a/fvid2.h
+++ b/fvid2.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Texas Instruments Incorporated 2012-2018
+ *  Copyright (c) Texas Instruments Incorporated 2018
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
 /* ========================================================================== */
 
 #include <ti/csl/csl_fvid2_dataTypes.h>
+#include <ti/drv/fvid2/include/trace.h>
+#include <ti/drv/fvid2/include/fvid2_utils.h>
 
 #ifdef __cplusplus
 extern "C" {
index a3fc99fd0fea8374d64784b8e9f3884eef7aa024..32c0d49984fb337dd79262e7622d0e192bc40980 100644 (file)
@@ -34,9 +34,9 @@
 #
 ifeq ($(fvid2_component_make_include), )
 
-fvid2_default_SOCLIST       = j7 am6x
-fvid2_default_j7_CORELIST   = mcu1_0 mcu1_1
-fvid2_default_am6x_CORELIST = mcu1_0 mcu1_1 mpu1_0
+fvid2_default_SOCLIST           = j7 am65x
+fvid2_default_j7_CORELIST       = mcu1_0 mcu1_1
+fvid2_default_am65x_CORELIST    = mcu1_0 mcu1_1 mpu1_0
 
 ############################
 # fvid2 package
index 6c8b29435b3cccf5d6aadfa8d35ac9849490f125..3d28c0dfc4e7bf723338f2682f3289f76b356392 100644 (file)
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) Texas Instruments Incorporated 2012-2018
+ *  Copyright (c) Texas Instruments Incorporated 2018
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
@@ -59,16 +59,16 @@ extern "C" {
 /* ========================================================================== */
 
 /** \brief Number of driver object to allocate in FVID2 library. */
-#define FVID2_CFG_FDM_NUM_DRV_OBJS          (40U)
+#define FVID2_CFG_FDM_NUM_DRV_OBJS      (40U)
 
 /** \brief Number of channel object to allocate in FVID2 library. */
-#define FVID2_CFG_FDM_NUM_CH_OBJS           (80U)
+#define FVID2_CFG_FDM_NUM_CH_OBJS       (80U)
 
 /** \brief FVID2 driver handle returned by individual drivers. */
 typedef void *Fdrv_Handle;
 
 /** \brief Typedef for callback function parameters. */
-typedef struct Fvid2_DrvCbParams_t Fvid2_DrvCbParams;
+typedef struct Fvid2_DrvCbParams_t      Fvid2_DrvCbParams;
 
 /**
  *  \brief Typedef for FVID2 driver callback function prototype. This will be
diff --git a/include/fvid2_utils.h b/include/fvid2_utils.h
new file mode 100644 (file)
index 0000000..5f0b3f7
--- /dev/null
@@ -0,0 +1,832 @@
+/*
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  \file fvid2_utils.h
+ *
+ *  \brief FVID2 Utility functions header file
+ *  This file declares the functions required to create, add and remove nodes.
+ *  Also provides various memset functions.
+ *
+ */
+
+#ifndef FVID2_UTILS_H_
+#define FVID2_UTILS_H_
+
+/* ========================================================================== */
+/*                             Include Files                                  */
+/* ========================================================================== */
+
+#include <ti/osal/osal.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ========================================================================== */
+/*                           Macros & Typedefs                                */
+/* ========================================================================== */
+
+/** \brief Log enable for FVID2 Utils. */
+#define Fvid2Trace                      (GT_DEFAULT_MASK)
+
+/**< \brief Number of timestamp log entries. */
+#define FVID2UTILS_NUM_TIMESTAMP_LOG    (100U)
+
+/**
+ *  struct Fvid2Utils_LinkListType
+ *  \brief Enums for the type of link list to be created.
+ */
+typedef enum
+{
+    FVID2UTILS_LLT_DOUBLE,
+    /**< Double link list. */
+    FVID2UTILS_LLT_CIRCULAR
+    /**< Circular link list using double link list. */
+} Fvid2Utils_LinkListType;
+
+/**
+ *  struct Fvid2Utils_LinkAddMode
+ *  \brief Enums for the different modes of adding a node to a link list.
+ */
+typedef enum
+{
+    FVID2UTILS_LAM_TOP,
+    /**< Add nodes to the top of the list. */
+    FVID2UTILS_LAM_BOTTOM,
+    /**< Add nodes to the bottom of the list. */
+    FVID2UTILS_LAM_PRIORITY
+    /**< Add nodes to the list based on ascending order of priority.
+     *   Nodes with the same priority are always added to the bottom of the
+     *   existing nodes with same priority. */
+} Fvid2Utils_LinkAddMode;
+
+/**
+ *  struct Fvid2Utils_LinkAddMode
+ *  \brief Enums for the different modes of adding a node to a link list.
+ */
+typedef enum
+{
+    FVID2UTILS_NODE_DIR_HEAD,
+    /**< Add nodes to the top of the list. */
+    FVID2UTILS_NODE_DIR_TAIL
+    /**< Add nodes to the bottom of the list. */
+} Fvid2Utils_NodDir;
+
+/* ========================================================================== */
+/*                         Structure Declarations                             */
+/* ========================================================================== */
+
+/**< \brief Typedef for Node structure. */
+typedef struct Fvid2Utils_Node_t Fvid2Utils_Node;
+
+/**
+ *  struct Fvid2Utils_Node_t
+ *  \brief Self referential structure for double link list.
+ */
+struct Fvid2Utils_Node_t
+{
+    Fvid2Utils_Node *next;
+    /**< Pointer to the next node. */
+    Fvid2Utils_Node *prev;
+    /**< Pointer to the previous node. */
+    void            *data;
+    /**< Node data pointer. */
+    uint32_t         priority;
+    /**< Priority of the node. Used for priority based linked list. */
+};
+
+/**
+ *  struct Fvid2Utils_QElem
+ *  \brief Typedef for Queue Node element.
+ */
+typedef Fvid2Utils_Node Fvid2Utils_QElem;
+
+/**
+ *  struct Fvid2Utils_PoolParams
+ *  \brief Create parameters for the fixed size pool.
+ */
+typedef struct
+{
+    void       *mem;
+    /**< Pointer to the pool memory. */
+    uint32_t    numElem;
+    /**< Number of elements in the pool. */
+    uint32_t    elemSize;
+    /**< Size of each element in bytes. */
+    uint32_t   *flag;
+    /**< Array of flag variable used by pool manager to indicate whether a pool
+     *   element is allocated or not. The size of this array should be
+     *   equal to the number of elements in this pool. */
+    uint32_t    numFreeElem;
+    /**< Count to keep track of the number of free elements in the pool. */
+} Fvid2Utils_PoolParams;
+
+/**
+ *  struct Fvid2Utils_TsPrfLog
+ *  \brief Timestamp Performance log structure in OSAL timestamp ticks.
+ */
+typedef struct
+{
+    uint64_t startTime;
+    /**< Start time - updated in start function. */
+    uint64_t total;
+    /**< Total duration of all log entires.
+     *   To get average divide by totalCnt. */
+    uint32_t totalCnt;
+    /**< Total number of log entires. */
+    uint64_t min;
+    /**< Minimum duration. */
+    uint64_t max;
+    /**< Maximum duration. */
+    uint32_t prfLogIndex;
+    /**< Current index. This will wrap around every FVID2UTILS_NUM_TIMESTAMP_LOG
+     *   count. */
+    uint64_t prfLog[FVID2UTILS_NUM_TIMESTAMP_LOG];
+    /**< History of the past FVID2UTILS_NUM_TIMESTAMP_LOG entires. */
+} Fvid2Utils_TsPrfLog;
+
+/**
+ *  struct Fvid2UtilsLinkListObj
+ *  \brief Structure to the link list object information.
+ */
+typedef struct
+{
+    Fvid2Utils_LinkListType listType;
+    /**< Type of linked list. */
+    Fvid2Utils_LinkAddMode  addMode;
+    /**< Mode of adding a node to a link list. */
+    Fvid2Utils_Node        *headNode;
+    /**< Head Node. */
+    Fvid2Utils_Node        *tailNode;
+    /**< Tail Node Node. */
+    uint32_t                numElements;
+    /**< Number of elements in the linked list. */
+    uint32_t                priorityCnt;
+    /**< Priority count of the linked list. */
+} Fvid2UtilsLinkListObj;
+
+/**
+ *  struct Fvid2Utils_Handle
+ *  \brief Typedef for FVID2 Utils handle.
+ */
+typedef Fvid2UtilsLinkListObj *Fvid2Utils_Handle;
+
+/**
+ *  struct Fvid2Utils_QHandle
+ *  \brief Typedef for FVID2 Utils Queue Handle.
+ */
+typedef Fvid2Utils_Handle Fvid2Utils_QHandle;
+
+/* ========================================================================== */
+/*                          Function Declarations                             */
+/* ========================================================================== */
+
+/**
+ *  Fvid2Utils_memset
+ *  \brief Sets the memory with the given value. Access memory as byte.
+ *  Returns the memory pointer.
+ *
+ *  \param mem              Destination memory pointer.
+ *  \param ch               Byte value to fill with.
+ *  \param byteCount        Number of bytes to fill.
+ *
+ *  \return                 The destination memory pointer.
+ */
+void *Fvid2Utils_memset(void *mem, uint8_t ch, uint32_t byteCount);
+
+/**
+ *  Fvid2Utils_memsetw
+ *  \brief Sets the memory with the given value. Access memory as word.
+ *  Hence memory pointer should be aligned to 4 byte boundary
+ *  Returns the memory pointer.
+ *
+ *  \param mem              Destination memory pointer.
+ *  \param word             Word value to fill with.
+ *  \param wordCount        Number of words to fill.
+ *
+ *  \return                 The destination memory pointer.
+ */
+void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount);
+
+/**
+ *  Fvid2Utils_memcpy
+ *  \brief Copies source memory into destination memory. Access memory as byte.
+ *  Returns the destination memory pointer.
+ *
+ *  \param dest             Destination memory pointer.
+ *  \param src              Source memory pointer.
+ *  \param byteCount        Number of bytes to copy.
+ *
+ *  \return                 The destination memory pointer.
+ */
+void *Fvid2Utils_memcpy(void *dest, const void *src, uint32_t byteCount);
+
+/**
+ *  Fvid2Utils_memcmp
+ *  \brief Compare memory block 1 with memory block 2. Access memory as byte.
+ *  Returns 0 if two memories are  identical.
+ *
+ *  \param mem1             memory block 1
+ *  \param mem2              memory block 2
+ *  \param byteCount        Number of bytes to compare
+ *
+ *  \return                 0 if two memory are identical other return 1
+ */
+int32_t Fvid2Utils_memcmp(const void *mem1,
+                          const void *mem2,
+                          uint32_t byteCount);
+
+/**
+ *  Fvid2Utils_constructLinkList
+ *  \brief Constructs a link list object with the provided properties.
+ *
+ *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *  \param listType         List type - circular/double link list.
+ *  \param addMode          Node addition mode - Top/Bottom/Priority based.
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error
+ *                          value.
+ */
+int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
+                                     Fvid2Utils_LinkListType listType,
+                                     Fvid2Utils_LinkAddMode  addMode);
+
+/**
+ *  Fvid2Utils_destructLinkList
+ *  \brief Destructs a link list object.
+ *
+ *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj);
+
+/**
+ *  Fvid2Utils_linkNodePri
+ *  \brief Links a node to the linked list according to the list type
+ *  The memory to the node object should be allocated by the caller. This
+ *  is used for link list with priority.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param priority         Priority of the node used for priority based
+ *                          addition of nodes. Priority is in descending order
+ *                          the value. So 0 is the highest priority and is
+ *                          added to the top of the node.
+ *                          Nodes with the same priority are always added to
+ *                          the bottom of the existing nodes with same
+ *                          priority.
+ *                          For non-priority based modes, this parameter
+ *                          is ignored and could be set to 0.
+ */
+void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
+                            Fvid2Utils_Node  *node,
+                            uint32_t          priority);
+
+/**
+ *  Fvid2Utils_linkUniqePriNode
+ *  \brief Very similar to Fvid2Utils_linkNode, except that on equal priority
+ *          nodes will not be inserted. An error (FVID2_EBADARGS) would be
+ *          returned.
+ *          Applicable for double linked list only.
+ *  ToDo Update to handle circular list also.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param priority         Priority of the node used for priority based
+ *                          addition of nodes. Priority is in descending order
+ *                          the value. So 0 is the highest priority and is
+ *                          added to the top of the node.
+ *                          Nodes with the same priority are always added to
+ *                          the bottom of the existing nodes with same
+ *                          priority.
+ *                          For non-priority based modes, this parameter
+ *                          is ignored and could be set to 0.
+ */
+int32_t Fvid2Utils_linkUniqePriNode(Fvid2Utils_Handle handle,
+                                    Fvid2Utils_Node  *node,
+                                    uint32_t          priority);
+
+/**
+ *  Fvid2Utils_unLinkAllNodes
+ *  \brief Releases all nodes without modifying any of the property.
+ *         CAUTION - Memory is NOT de-allocated, its the responsibility of the
+ *                   caller to ensure de-allocation of memory.
+ *
+ *  \param handle           Link list handle.
+ *
+ *  \return                 Returns 0 on success else returns error value.
+ */
+int32_t Fvid2Utils_unLinkAllNodes(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_unLinkNodePri
+ *  \brief Unlinks the node from the list. Used for the Priority linklists.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node pointer to be unlinked from the list.
+ */
+void Fvid2Utils_unLinkNodePri(Fvid2Utils_Handle handle, Fvid2Utils_Node *node);
+
+/**
+ *  Fvid2Utils_unLinkNode
+ *  \brief Unlinks the node from the list. Used for Non-priority linked lists
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node pointer to be unlinked from the list.
+ */
+void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle,
+                           const Fvid2Utils_Node *node);
+
+/**
+ *  Fvid2Utils_linkNodeToHead
+ *  \brief                  Link the node to the head of the double linked list.
+ *                          No priority
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *
+ */
+void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle,
+                               Fvid2Utils_Node  *node);
+
+/**
+ *  Fvid2Utils_linkNodeToTail
+ *  \brief                  Link the node to the tail of the double linked list.
+ *                          No priority
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ */
+void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle,
+                             Fvid2Utils_Node  *node);
+
+/**
+ *  Fvid2Utils_unLinkNodeFromHead
+ *  \brief                  Returns the node from head. Removes the  node from
+ *                          the list.
+ *
+ *  \param handle           Link list handle.
+ *  \return                 Pointer to unlinked node.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromHead(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_unLinkNodeFromTail
+ *  \brief                  Returns the node from tail. Removes the  node from
+ *                          the list.
+ *
+ *  \param handle           Link list handle.
+ *  \return                 Pointer to unlinked node.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromTail(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_getHeadNode
+ *  \brief                  Returns the reference to the headNode. Does
+ *                          not remove the node from the head.
+ *
+ *  \param handle           Link list handle.
+ */
+Fvid2Utils_Node *Fvid2Utils_getHeadNode(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_getTailNode
+ *  \brief                  Returns the reference to the TailNode. Does
+ *                          not remove the node from the head.
+ *
+ *  \param handle           Link list handle.
+ *  \return                 Reference  to tail node.  Acutally  node is not
+ *                          unlinked from list.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_getTailNode(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_isListEmpty
+ *  \brief Checks whether a list is empty or not.
+ *
+ *  \param handle           List handle.
+ *
+ *  \return                 TRUE if List is empty else returns FALSE.
+ */
+uint32_t Fvid2Utils_isListEmpty(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_getNumNodes
+ *  \brief Returns the number of nodes present in a list.
+ *
+ *  \param handle           List handle.
+ *
+ *  \return                 Number of nodes present in a list.
+ */
+uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_getNodeCnt
+ *  \brief Returns the number of nodes in the link list
+ *
+ *  \param handle           Link list handle.
+ *
+ *
+ *  \return                 Returns the number of nodes in the list.
+ */
+uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle);
+
+/**
+ *  Fvid2Utils_constructQ
+ *  \brief Constructs a Queue object.
+ *
+ * \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_constructQ(Fvid2UtilsLinkListObj *llobj);
+
+/**
+ *  Fvid2Utils_destructQ
+ *  \brief Destructs a Queue object.
+ *
+ * \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_destructQ(Fvid2UtilsLinkListObj *llobj);
+
+/**
+ *  Fvid2Utils_queue
+ *  \brief Adds the data to the queue.
+ *  The memory to the node object should be allocated by the caller.
+ *
+ *  \param handle           Queue handle.
+ *  \param qElem            Queue Element object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ */
+void Fvid2Utils_queue(Fvid2Utils_QHandle handle,
+                      Fvid2Utils_QElem  *qElem,
+                      void              *data);
+
+/**
+ *  Fvid2Utils_dequeue
+ *  \brief Removes a element from the queue.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the removed data pointer.
+ */
+void *Fvid2Utils_dequeue(Fvid2Utils_QHandle handle);
+
+/**
+ *  Fvid2Utils_peakHead
+ *  \brief Returns the reference of the first queued element.
+ *
+ *  This doesn't remove the element from the queue.
+ *  If the queue is empty, then this returns NULL.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the reference of the first element.
+ */
+void *Fvid2Utils_peakHead(Fvid2Utils_QHandle handle);
+
+/**
+ *  Fvid2Utils_peakTail
+ *  \brief Returns the reference of the last queued element.
+ *
+ *  This doesn't remove the element from the queue.
+ *  If the queue is empty, then this returns NULL.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the reference of the last queued element.
+ */
+void *Fvid2Utils_peakTail(Fvid2Utils_QHandle handle);
+
+/**
+ *  Fvid2Utils_queueBack
+ *  \brief Adds the data to start of the queue.
+ *  The memory to the node object should be allocated by the caller.
+ *
+ *  \param handle           Queue handle.
+ *  \param qElem            Queue Element object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ */
+void Fvid2Utils_queueBack(Fvid2Utils_QHandle handle,
+                          Fvid2Utils_QElem  *qElem,
+                          void              *data);
+
+/**
+ *  Fvid2Utils_isQEmpty
+ *  \brief Checks whether a queue is empty or not.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 TRUE if queue is empty else returns FALSE.
+ */
+uint32_t Fvid2Utils_isQEmpty(Fvid2Utils_QHandle handle);
+
+/**
+ *  Fvid2Utils_getNumQElem
+ *  \brief Returns the number of Queue Elements present in a Queue.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Number of Queue Elements present in a Queue.
+ */
+uint32_t Fvid2Utils_getNumQElem(Fvid2Utils_QHandle handle);
+
+/**
+ *  Fvid2Utils_initPool
+ *  \brief Initializes the pool object structure.
+ *
+ *  \param params           Pool parameters to be initialized.
+ *  \param mem              Pointer to the pool memory.
+ *  \param numElem          Number of elements in the pool.
+ *  \param elemSize         Size of each element in bytes.
+ *  \param flag             Array of flag variable used by pool manager to
+ *                          indicate whether a pool element is allocated
+ *                          or not. The size of this array should be
+ *                          equal to the number of elements in this pool.
+ *  \param traceMask        Trace mask used in trace prints.
+ */
+static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
+                                       void                  *mem,
+                                       uint32_t               numElem,
+                                       uint32_t               elemSize,
+                                       uint32_t              *flag,
+                                       uint32_t               traceMask);
+
+/**
+ *  Fvid2Utils_alloc
+ *  \brief Allocates one element from the pool.
+ *
+ *  \param params           Pool parameters.
+ *  \param size             Size in bytes to allocate.
+ *  \param traceMask        Trace mask used in trace prints.
+ *
+ *  \return                 Returns memory pointer on success else returns
+ *                          NULL.
+ */
+static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
+                                   uint32_t               size,
+                                   uint32_t               traceMask);
+
+/**
+ *  Fvid2Utils_free
+ *  \brief Frees the element and returns to the pool.
+ *
+ *  \param params           Pool parameters.
+ *  \param mem              Memory pointer to deallocate.
+ *  \param traceMask        Trace mask used in trace prints.
+ *
+ *  \return                 Returns 0 on success else returns error value.
+ */
+static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
+                                      const void            *mem,
+                                      uint32_t               traceMask);
+
+/**
+ *  Fvid2Utils_initTsPrfLog
+ *  \brief Initializes the structure. This should be called once before
+ *  calling any other performance functions.
+ *
+ *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
+ *
+ */
+static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
+
+/**
+ *  Fvid2Utils_startTsPrfLog
+ *  \brief Log the start entry to the performance structure.
+ *
+ *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
+ */
+static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
+
+/**
+ *  Fvid2Utils_endTsPrfLog
+ *  \brief Log the entry to the performance structure. This uses the previous
+ *  startTime stored when calling Fvid2Utils_startTsPrfLog() to calculate the
+ *  difference.
+ *
+ *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
+ */
+static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
+
+//TODO
+static inline uint64_t Osal_getTimestamp64(void);
+
+/* ========================================================================== */
+/*                       Static Function Definitions                          */
+/* ========================================================================== */
+
+static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
+                                       void                  *mem,
+                                       uint32_t               numElem,
+                                       uint32_t               elemSize,
+                                       uint32_t              *flag,
+                                       uint32_t               traceMask)
+{
+    uint32_t cnt;
+
+    /* NULL pointer check */
+    GT_assert(traceMask, (NULL != params));
+    GT_assert(traceMask, (NULL != mem));
+    GT_assert(traceMask, (NULL != flag));
+
+    /* Init pool parameters */
+    params->mem         = mem;
+    params->numElem     = numElem;
+    params->elemSize    = elemSize;
+    params->flag        = flag;
+    params->numFreeElem = numElem;
+
+    /* Set pool flags as free */
+    for (cnt = 0U; cnt < params->numElem; cnt++)
+    {
+        params->flag[cnt] = (uint32_t) FALSE;
+    }
+
+    return;
+}
+
+static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
+                                     uint32_t               size,
+                                     uint32_t               traceMask)
+{
+    uint32_t cnt;
+    uintptr_t cookie;
+    uint32_t tempVal;
+    void  *allocMem = NULL;
+
+    /* NULL pointer check */
+    GT_assert(traceMask, (NULL != params));
+    /* Check if the requested size if within each fixed size element */
+    GT_assert(traceMask, (size <= params->elemSize));
+    GT_assert(traceMask, (0U != size));
+
+    /* Disable global interrupts */
+    cookie = HwiP_disable();
+
+    for (cnt = 0U; cnt < params->numElem; cnt++)
+    {
+        if ((uint32_t) FALSE == params->flag[cnt])
+        {
+            tempVal = ((uint32_t) params->mem) + (params->elemSize * cnt);
+            allocMem          = (void *) (tempVal);
+            params->flag[cnt] = (uint32_t) TRUE;
+
+            /* Decrement free count.
+             * Assert if it is zero as it can never happen. */
+            GT_assert(traceMask, (0U != params->numFreeElem));
+            params->numFreeElem--;
+            break;
+        }
+    }
+
+    /* Restore global interrupts */
+    HwiP_restore(cookie);
+
+    return (allocMem);
+}
+
+static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
+                                      const void            *mem,
+                                      uint32_t               traceMask)
+{
+    uint32_t cnt;
+    uint32_t tempVal;
+    int32_t  retVal = FVID2_EFAIL;
+    uintptr_t cookie;
+
+    /* NULL pointer check */
+    GT_assert(traceMask, (NULL != params));
+    GT_assert(traceMask, (NULL != mem));
+
+    /* Disable global interrupts */
+    cookie = HwiP_disable();
+
+    for (cnt = 0U; cnt < params->numElem; cnt++)
+    {
+        tempVal = ((uint32_t) params->mem) + (params->elemSize * cnt);
+        if ((void *) (tempVal) == mem)
+        {
+            /* Check if the memory is already allocated */
+            GT_assert(traceMask, ((uint32_t) TRUE == params->flag[cnt]));
+            params->flag[cnt] = (uint32_t) FALSE;
+
+            /* Increment free count.
+             * Assert if it is more than num elements as it can never happen. */
+            params->numFreeElem++;
+            GT_assert(traceMask, (params->numFreeElem <= params->numElem));
+
+            retVal = FVID2_SOK;
+            break;
+        }
+    }
+
+    /* Restore global interrupts */
+    HwiP_restore(cookie);
+
+    return (retVal);
+}
+
+static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
+{
+    /* NULL pointer check */
+    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+
+    Fvid2Utils_memset(tsPrf, 0, sizeof (Fvid2Utils_TsPrfLog));
+    /* Min can't be init to 0, set a higher value so that actual min gets
+     * registered */
+    tsPrf->min = 0xFFFFFFFFU;
+
+    return;
+}
+
+static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
+{
+    /* NULL pointer check */
+    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+
+    tsPrf->startTime = Osal_getTimestamp64();
+
+    return;
+}
+
+static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
+{
+    uint64_t endTime, diff;
+
+    /* NULL pointer check */
+    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+
+    endTime = Osal_getTimestamp64();
+    diff    = endTime - tsPrf->startTime;
+
+    /* Log the difference */
+    tsPrf->total += diff;
+    tsPrf->totalCnt++;
+    if (diff < tsPrf->min)
+    {
+        tsPrf->min = diff;
+    }
+    if (diff > tsPrf->max)
+    {
+        tsPrf->max = diff;
+    }
+    if (tsPrf->prfLogIndex >= FVID2UTILS_NUM_TIMESTAMP_LOG)
+    {
+        tsPrf->prfLogIndex = 0U;
+    }
+    tsPrf->prfLog[tsPrf->prfLogIndex] = diff;
+    tsPrf->prfLogIndex++;
+
+    return;
+}
+
+static inline uint64_t Osal_getTimestamp64(void)
+{
+    //TODO: Call OSAL API once implementation is done
+    return (0U);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef FVID2_UTILS_H_ */
diff --git a/include/trace.h b/include/trace.h
new file mode 100644 (file)
index 0000000..c44da6d
--- /dev/null
@@ -0,0 +1,550 @@
+/*
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  \file       trace.h
+ *
+ *  \brief      Kernel Trace enabling/disabling/application interface.
+ *
+ *              This will have the definitions for kernel side traces
+ *              statements and also details of variable traces
+ *              supported in existing implementation.
+ */
+
+#ifndef FVID2TRACE_H_
+#define FVID2TRACE_H_
+
+#include <ti/csl/tistdtypes.h>
+
+ #if defined (USE_STD_ASSERT)
+#include <assert.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \brief The global trace variable containing current trace configuration. */
+extern int32_t curTrace;
+
+/*!
+ *  @def    GT_TRACESTATE_MASK
+ *  @brief  Trace state mask
+ */
+#define GT_TRACESTATE_MASK                 0x0000000FU
+
+/*!
+ *  @def    GT_TRACESTATE_SHIFT
+ *  @brief  Bit shift for trace state
+ */
+#define GT_TRACESTATE_SHIFT                0U
+
+/*!
+ *  @def    GT_TRACEENTER_MASK
+ *  @brief  Trace enter mask
+ */
+#define GT_TRACEENTER_MASK                 0x000000F0U
+
+/*!
+ *  @def    GT_TRACEENTER_SHIFT
+ *  @brief  Bit shift for trace enter
+ */
+#define GT_TRACEENTER_SHIFT                4U
+
+/*!
+ *  @def    GT_TRACESETFAILURE_MASK
+ *  @brief  Trace Set Failure Reason mask
+ */
+#define GT_TRACESETFAILURE_MASK            0x00000F00U
+
+/*!
+ *  @def    GT_TRACESETFAILURE_SHIFT
+ *  @brief  Bit shift for trace Set Failure Reason
+ */
+#define GT_TRACESETFAILURE_SHIFT           8U
+
+/*!
+ *  @def    GT_TRACECLASS_MASK
+ *  @brief  GT class mask
+ */
+#define GT_TRACECLASS_MASK                 0x000F0000U
+
+/*!
+ *  @def    GT_TRACECLASS_SHIFT
+ *  @brief  Bit shift for GT class mask
+ */
+#define GT_TRACECLASS_SHIFT                16U
+
+/*!
+ *  @brief  Default Mask to use with GT_assert
+ */
+#define GT_DEFAULT_MASK                    (GT_ERR | GT_TraceState_Enable)
+
+/*!
+ *  @brief   Enumerates the types of states of trace (enable/disable)
+ */
+typedef enum {
+    GT_TraceState_Disable = 0x00000000U,
+    /*!< Disable trace */
+    GT_TraceState_Enable = 0x00000001U,
+    /*!< Enable trace */
+    GT_TraceState_EndValue = 0x00000002U
+                             /*!< End delimiter indicating start of invalid
+                              *values for this enum */
+} GT_TraceState;
+
+/*!
+ *  @brief   Enumerates the states of enter/leave trace (enable/disable)
+ */
+typedef enum {
+    GT_TraceEnter_Disable = 0x00000000U,
+    /*!< Disable GT_ENTER trace prints */
+    GT_TraceEnter_Enable = 0x00000010U,
+    /*!< Enable GT_ENTER trace prints */
+    GT_TraceEnter_EndValue = 0x00000020U
+                             /*!< End delimiter indicating start of invalid
+                              *values for this enum */
+} GT_TraceEnter;
+
+/*!
+ *  @brief   Enumerates the states of SetFailureReason trace (enable/disable)
+ */
+typedef enum {
+    GT_TraceSetFailure_Disable = 0x00000000U,
+    /*!< Disable Set Failure trace prints */
+    GT_TraceSetFailure_Enable = 0x00000100U,
+    /*!< Enable Set Failure trace prints */
+    GT_TraceSetFailure_EndValue = 0x00000200U
+                                  /*!< End delimiter indicating start of invalid
+                                   *values for this enum */
+} GT_TraceSetFailure;
+
+/*!
+ *  @brief   Enumerates the types of trace classes
+ */
+typedef enum {
+    GT_ERR = 0x00010000U,
+    /*!< Class 1 trace: Used for errors/warnings */
+    GT_CRIT = 0x00020000U,
+    /*!< Class 2 trace: Used for critical information */
+    GT_INFO = 0x00030000U,
+    /*!< Class 3 trace: Used for additional information */
+    GT_INFO1 = 0x00040000U,
+    /*!< Class 4 trace: Used for additional information (sub level 1) */
+    GT_DEBUG = 0x00050000U,
+    /*!< Class 5 trace: Used for block level information */
+    GT_ENTER = 0x00060000U,
+    /*!< Indicates a function entry class of trace */
+    GT_LEAVE = 0x00070000U
+               /*!< Indicates a function leave class of trace */
+} GT_TraceClass;
+
+/**
+ *  \brief Prints to Shared memory and CCS console
+ *
+ *  This function prints the provided formatted string to shared memory and CCS
+ *  console
+ *
+ *  \param format       [IN] Formatted string followed by variable arguments
+ *
+ */
+void Fvid2_printf(const char *format, ...);
+
+/**
+ *  \brief Prints to Shared memory only
+ *
+ *  This function prints the provided formatted string to shared memory only
+ *
+ *  \param format       [IN] Formatted string followed by variable arguments
+ *
+ */
+void Fvid2_rprintf(const char *format, ...);
+
+/** \brief assert function. */
+static inline void GT_assertLocal(uint32_t    enableMask,
+                                  uint32_t    condition,
+                                  const char *str,
+                                  const char *fileName,
+                                  int32_t     lineNum);
+
+/** \brief GT_assert */
+#define GT_assert(x, y)                                           \
+    (GT_assertLocal((uint32_t) (x), (uint32_t) (y), (const char *) # y, \
+                    (const char *) __FILE__, (int32_t) __LINE__))
+
+static inline void GT_assertLocal(uint32_t    enableMask,
+                                  uint32_t    condition,
+                                  const char *str,
+                                  const char *fileName,
+                                  int32_t     lineNum)
+{
+#if defined (ASSERT_ENABLE)
+    if ((!(condition)) != 0)
+    {
+        Fvid2_printf(" Assertion @ Line: %d in %s: %s : failed !!!\n",
+                   lineNum, fileName, str);
+ #if defined (USE_STD_ASSERT)
+        assert((!(condition)) != 0);
+ #else
+        while (TRUE)
+        {
+            ;
+        }
+ #endif /* #if defined(USE_STD_ASSERT) */
+    }
+#endif  /* if defined(ASSERT_ENABLE) */
+
+    return;
+}
+
+#if defined (TRACE_ENABLE)
+/** \brief Function to report the FVID2 failure and log the trace. */
+void GT_failureReasonSet(int32_t      enableMask,
+                         const char  *func,
+                         const char  *fileName,
+                         int32_t      lineNum,
+                         uint32_t     status,
+                         const char  *msg);
+/** \brief Function to report the FVID2 failure and log the trace. */
+#define GT_setFailureReason(maskType, classType, func, status, msg) \
+    (GT_failureReasonSet((maskType), (const char *) (func),         \
+                         (const char *) __FILE__, (int32_t) __LINE__, \
+                         (status), (const char *) (msg)))
+
+#else /* if defined (TRACE_ENABLE) */
+
+/** \brief Function to report the FVID2 failure and log the trace. */
+#define GT_setFailureReason(maskType, classType, func, status, msg) \
+    do {                                                            \
+        if (maskType) {                                             \
+        }                                                           \
+        if (classType) {                                            \
+        }                                                           \
+        if (status) {                                               \
+        }                                                           \
+        if ((uint32_t) (msg)) {                                     \
+        }                                                           \
+    } while (FALSE)
+
+#endif /* if defined (TRACE_ENABLE) */
+
+/**
+ *  \brief Log the trace with zero parameters and information string.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *
+ */
+void GT_trace0(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString);
+/**
+ *  \brief Function to log the trace with one additional parameter.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *
+ */
+void GT_trace1(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0);
+
+/**
+ *  \brief Function to log the trace with two additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *
+ */
+void GT_trace2(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1);
+
+/**
+ *  \brief Function to log the trace with three additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *  \param  param2     [IN] Parameter 2
+ *
+ */
+void GT_trace3(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1,
+               uint32_t      param2);
+
+/**
+ *  \brief Function to log the trace with four additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *  \param  param2     [IN] Parameter 2
+ *  \param  param3     [IN] Parameter 3
+ *
+ */
+void GT_trace4(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1,
+               uint32_t      param2,
+               uint32_t      param3);
+
+/**
+ *  \brief Function to log the trace with five additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *  \param  param2     [IN] Parameter 2
+ *  \param  param3     [IN] Parameter 3
+ *  \param  param4     [IN] Parameter 4
+ *
+ */
+void GT_trace5(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1,
+               uint32_t      param2,
+               uint32_t      param3,
+               uint32_t      param4);
+
+/**
+ *  \brief Function to log the trace with six additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *  \param  param2     [IN] Parameter 2
+ *  \param  param3     [IN] Parameter 3
+ *  \param  param4     [IN] Parameter 4
+ *  \param  param5     [IN] Parameter 5
+ *
+ */
+void GT_trace6(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1,
+               uint32_t      param2,
+               uint32_t      param3,
+               uint32_t      param4,
+               uint32_t      param5);
+
+/**
+ *  \brief Function to log the trace with seven additional parameters.
+ *
+ *  \param  maskType   [IN] Trace mask
+ *  \param  classType  [IN] Trace class type
+ *  \param  fileName   [IN] File Name
+ *  \param  lineNum    [IN] Line Number
+ *  \param  infoString [IN] Print string
+ *  \param  param0     [IN] Parameter 0
+ *  \param  param1     [IN] Parameter 1
+ *  \param  param2     [IN] Parameter 2
+ *  \param  param3     [IN] Parameter 3
+ *  \param  param4     [IN] Parameter 4
+ *  \param  param5     [IN] Parameter 5
+ *  \param  param6     [IN] Parameter 6
+ *
+ */
+void GT_trace7(uint32_t      maskType,
+               GT_TraceClass classType,
+               const char   *fileName,
+               int32_t       lineNum,
+               const char   *infoString,
+               uint32_t      param0,
+               uint32_t      param1,
+               uint32_t      param2,
+               uint32_t      param3,
+               uint32_t      param4,
+               uint32_t      param5,
+               uint32_t      param6);
+
+#if defined (TRACE_ENABLE)
+/** \brief Log the trace with zero parameters and information string. */
+#define GT_0trace(maskType, classType, infoString)        \
+    (GT_trace0((maskType), (classType),                   \
+               (const char *) __FILE__, (int32_t) __LINE__, \
+               (const char *) (infoString)))
+
+/** \brief Function to log the trace with one additional parameters. */
+#define GT_1trace(maskType, classType, infoString, param0) \
+    (GT_trace1((maskType), (classType),                    \
+               (const char *) __FILE__, (int32_t) __LINE__,  \
+               (const char *) (infoString), (uint32_t) (param0)))
+
+/** \brief Function to log the trace with two additional parameters. */
+#define GT_2trace(maskType, classType, infoString, param0, param1) \
+    (GT_trace2((maskType), (classType),                            \
+               (const char *) __FILE__, (int32_t) __LINE__,          \
+               (const char *) (infoString), (uint32_t) (param0), (uint32_t) (param1)))
+
+/** \brief Function to log the trace with three additional parameters. */
+#define GT_3trace(maskType, classType, infoString, param0, param1, param2) \
+    (GT_trace3((maskType), (classType),                                    \
+               (const char *) __FILE__, (int32_t) __LINE__,                  \
+               (const char *) (infoString),                                \
+               (uint32_t) (param0),                                          \
+               (uint32_t) (param1),                                          \
+               (uint32_t) (param2)))
+
+/** \brief Function to log the trace with four additional parameters. */
+#define GT_4trace(maskType, classType, infoString,        \
+                  param0, param1, param2, param3)         \
+    (GT_trace4((maskType), (classType),                   \
+               (const char *) __FILE__, (int32_t) __LINE__, \
+               (const char *) (infoString),               \
+               (uint32_t) (param0),                         \
+               (uint32_t) (param1),                         \
+               (uint32_t) (param2),                         \
+               (uint32_t) (param3)))
+
+/** \brief Function to log the trace with five additional parameters. */
+#define GT_5trace(maskType, classType, infoString,        \
+                  param0, param1, param2, param3, param4) \
+    (GT_trace5((maskType), (classType),                   \
+               (const char *) __FILE__, (int32_t) __LINE__, \
+               (const char *) (infoString),               \
+               (uint32_t) (param0),                         \
+               (uint32_t) (param1),                         \
+               (uint32_t) (param2),                         \
+               (uint32_t) (param3),                         \
+               (uint32_t) (param4)))
+
+/** \brief Function to log the trace with six additional parameters. */
+#define GT_6trace(maskType, classType, infoString,                \
+                  param0, param1, param2, param3, param4, param5) \
+    (GT_trace6((maskType), (classType),                           \
+               (const char *) __FILE__, (int32_t) __LINE__,         \
+               (const char *) (infoString),                       \
+               (uint32_t) (param0),                                 \
+               (uint32_t) (param1),                                 \
+               (uint32_t) (param2),                                 \
+               (uint32_t) (param3),                                 \
+               (uint32_t) (param4),                                 \
+               (uint32_t) (param5)))
+
+/** \brief Function to log the trace with seven additional parameters. */
+#define GT_7trace(maskType, classType, infoString,                        \
+                  param0, param1, param2, param3, param4, param5, param6) \
+    (GT_trace7((maskType), (classType),                                   \
+               (const char *) __FILE__, (int32_t) __LINE__,                 \
+               (const char *) (infoString),                               \
+               (uint32_t) (param0),                                         \
+               (uint32_t) (param1),                                         \
+               (uint32_t) (param2),                                         \
+               (uint32_t) (param3),                                         \
+               (uint32_t) (param4),                                         \
+               (uint32_t) (param5),                                         \
+               (uint32_t) (param6)))
+
+#else   /* if defined (TRACE_ENABLE) */
+
+/** \brief Log the trace with zero parameters and information string. */
+#define GT_0trace(maskType, classType, infoString)
+/** \brief Function to log the trace with one additional parameter. */
+#define GT_1trace(maskType, classType, infoString, param0)
+/** \brief Function to log the trace with two additional parameters. */
+#define GT_2trace(maskType, classType, infoString, param0, param1)
+/** \brief Function to log the trace with three additional parameters. */
+#define GT_3trace(maskType, classType, infoString, param0, param1, param2)
+/** \brief Function to log the trace with four additional parameters. */
+#define GT_4trace(maskType, classType, infoString, param0, param1, param2, \
+                  param3)
+/** \brief Function to log the trace with five additional parameters. */
+#define GT_5trace(maskType, classType, infoString, param0, param1, param2, \
+                  param3, param4)
+/** \brief Function to log the trace with six additional parameters. */
+#define GT_6trace(maskType, classType, infoString, param0, param1, param2, \
+                  param3, param4, param5)
+/** \brief Function to log the trace with seven additional parameters. */
+#define GT_7trace(maskType, classType, infoString, param0, param1, param2, \
+                  param3, param4, param5, param6)
+
+#endif  /* if defined (TRACE_ENABLE) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef FVID2TRACE_H_ */
index 39017ecd64b3e7cd0a7bbc7b6a0496fef01be54c..76fcc9818b4bdef0411dcf162778a02bcff6d33b 100644 (file)
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) Texas Instruments Incorporated 2012-2018
+ *  Copyright (c) Texas Instruments Incorporated 2018
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
 /*                             Include Files                                  */
 /* ========================================================================== */
 
-#include <fvid2_drvMgr.h>
-#include <ti/osal/osal.h>
-/* This is needed for memset/memcpy */
-#include <string.h>
+#include <ti/drv/fvid2/include/fvid2_drvMgr.h>
 
 /* ========================================================================== */
 /*                           Macros & Typedefs                                */
@@ -157,9 +154,6 @@ static Fdm_Driver *fdmAllocDriverObject(void);
 static int32_t fdmFreeDriverObject(const Fvid2_DrvOps *drvOps);
 static Fdm_Channel *fdmAllocChannelObject(void);
 static int32_t fdmFreeChannelObject(Fdm_Channel *channel);
-static void Fvid2_printf(const char *format, ...);
-static void Fvid2_memset(void *mem, int32_t ch, uint32_t byteCount);
-static void Fvid2_memcpy(void *dest, const void *src, uint32_t byteCount);
 #ifdef __cplusplus
 }
 #endif
@@ -461,7 +455,7 @@ int32_t Fvid2_init(void *args)
     SemaphoreP_Params params;
 
     /* Init all global variables to zero */
-    Fvid2_memset(&gFdmObj, 0U, sizeof (gFdmObj));
+    Fvid2Utils_memset(&gFdmObj, 0U, sizeof (gFdmObj));
 
     /* Mark pool flags as free */
     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
@@ -709,7 +703,7 @@ Fvid2_Handle Fvid2_create(uint32_t              drvId,
             Fvid2CbParams_init(&channel->cbParams);
             if (NULL != cbParams)
             {
-                Fvid2_memcpy(
+                Fvid2Utils_memcpy(
                     &channel->cbParams,
                     cbParams,
                     sizeof (Fvid2_CbParams));
@@ -1038,7 +1032,7 @@ int32_t Fvid2_getModeInfo(Fvid2_ModeInfo *modeInfo)
         }
         else
         {
-            Fvid2_memcpy(modeInfo, matchedEntry, sizeof (Fvid2_ModeInfo));
+            Fvid2Utils_memcpy(modeInfo, matchedEntry, sizeof (Fvid2_ModeInfo));
         }
     }
     else
@@ -1419,19 +1413,7 @@ static int32_t fdmFreeChannelObject(Fdm_Channel *channel)
     return (retVal);
 }
 
-static void Fvid2_printf(const char *format, ...)
+void Fvid2_printf(const char *format, ...)
 {
     return;
 }
-
-static void Fvid2_memset(void *mem, int32_t ch, uint32_t byteCount)
-{
-    memset(mem, ch, byteCount);
-    return;
-}
-
-static void Fvid2_memcpy(void *dest, const void *src, uint32_t byteCount)
-{
-    memcpy(dest, src, byteCount);
-    return;
-}
diff --git a/src/fvid2_utils.c b/src/fvid2_utils.c
new file mode 100644 (file)
index 0000000..07d01ed
--- /dev/null
@@ -0,0 +1,1320 @@
+/*
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  \file fvid2_utils.c
+ *
+ *  \brief Utility functions implementation file.
+ *  This file defines the helper functions like create, add and remove nodes
+ *
+ */
+
+/* ========================================================================== */
+/*                             Include Files                                  */
+/* ========================================================================== */
+
+#include <string.h>
+#include <ti/drv/fvid2/fvid2.h>
+
+/* ========================================================================== */
+/*                           Macros & Typedefs                                */
+/* ========================================================================== */
+
+/* None */
+
+/* ========================================================================== */
+/*                         Structure Declarations                             */
+/* ========================================================================== */
+
+/* None */
+
+/* ========================================================================== */
+/*                          Function Declarations                             */
+/* ========================================================================== */
+
+static Fvid2Utils_Node *dutilsLinkCircularPri(Fvid2Utils_Node *headNode,
+                                              Fvid2Utils_Node *node,
+                                              void            *data,
+                                              uint32_t         priority);
+static int32_t dutilsLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
+                                   Fvid2Utils_Node       *node,
+                                   void                  *data,
+                                   uint32_t               priority,
+                                   uint32_t               linkUniqePriNodes);
+static Fvid2Utils_Node *dutilsUnLinkCircularPri(Fvid2Utils_Node *headNode,
+                                                Fvid2Utils_Node *node);
+static void dutilsUnLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
+                                  Fvid2Utils_Node       *node);
+static Fvid2Utils_Node *dutilsUnLinkDouble(Fvid2UtilsLinkListObj *llobj,
+                                           Fvid2Utils_NodDir      dir,
+                                           const Fvid2Utils_Node *nodeToBeRem);
+static Fvid2Utils_Node *dutilsLinkDouble(Fvid2UtilsLinkListObj *llobj,
+                                         Fvid2Utils_Node       *node,
+                                         void                  *data,
+                                         Fvid2Utils_NodDir      dir);
+
+/* ========================================================================== */
+/*                            Global Variables                                */
+/* ========================================================================== */
+
+/* None */
+
+/* ========================================================================== */
+/*                          Function Definitions                              */
+/* ========================================================================== */
+
+/**
+ *  Fvid2Utils_init
+ *  \brief Initializes the Util objects and create pool semaphore
+ *
+ *  \returns                Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_init(void)
+{
+    return (FVID2_SOK);
+}
+
+/**
+ *  Fvid2Utils_deInit
+ *  \brief De-Initializes the Util objects by removing pool semaphore
+ *
+ *  \param arg              Not used currently. Meant for future purpose
+ *
+ *  \return                 Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_deInit(void *arg)
+{
+    return (FVID2_SOK);
+}
+
+/**
+ *  Fvid2Utils_memset
+ *  \brief Sets the memory with the given value. Access memory as byte.
+ *  Returns the memory pointer.
+ *
+ *  \param mem              Destination memory pointer
+ *  \param ch               Byte value to fill with
+ *  \param byteCount        Number of bytes to fill
+ *
+ *  \return                 The destination memory pointer
+ */
+void *Fvid2Utils_memset(void *mem, uint8_t ch, uint32_t byteCount)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != mem));
+
+    return memset(mem, (int32_t) ch, byteCount);
+}
+
+/**
+ *  Fvid2Utils_memsetw
+ *  \brief Sets the memory with the given value. Access memory as word.
+ *  Hence memory pointer should be aligned to 4 byte boundary
+ *  Returns the memory pointer.
+ *
+ *  \param mem              Destination memory pointer
+ *  \param word             Word value to fill with
+ *  \param wordCount        Number of words to fill
+ *
+ *  \return                 The destination memory pointer
+ */
+void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount)
+{
+    uint32_t  count;
+    uint32_t *memPtr = NULL;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != mem));
+
+    memPtr = (uint32_t *) mem;
+    for (count = 0; count < wordCount; count++)
+    {
+        memPtr[count] = word;
+    }
+
+    return (mem);
+}
+
+/**
+ *  Fvid2Utils_memcpy
+ *  \brief Copies source memory into destination memory. Access memory as byte.
+ *  Returns the destination memory pointer.
+ *
+ *  \param dest             Destination memory pointer
+ *  \param src              Source memory pointer
+ *  \param byteCount        Number of bytes to copy
+ *
+ *  \return                 The destination memory pointer
+ */
+void *Fvid2Utils_memcpy(void *dest, const void *src, uint32_t byteCount)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != dest));
+    GT_assert(Fvid2Trace, (NULL != src));
+
+    return memcpy(dest, src, byteCount);
+}
+
+/**
+ *  Fvid2Utils_memcmp
+ *  \brief Compare memory block 1 with memory block 2. Access memory as byte.
+ *  Returns 0 if two memories are  identical.
+ *
+ *  \param mem1             memory block 1
+ *  \param mem2              memory block 2
+ *  \param byteCount        Number of bytes to compare
+ *
+ *  \return                 0 if two memory are identical other return 1
+ */
+int32_t Fvid2Utils_memcmp(const void *mem1,
+                          const void *mem2,
+                          uint32_t byteCount)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != mem1));
+    GT_assert(Fvid2Trace, (NULL != mem2));
+
+    return memcmp(mem1, mem2, byteCount);
+}
+
+/**
+ *  Fvid2Utils_constructLinkList
+ *  \brief Constructs a link list object with the provided properties.
+ *
+ *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *  \param listType         List type - circular/double link list.
+ *  \param addMode          Node addition mode - Top/Bottom/Priority based.
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error
+ *                          value.
+ */
+int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
+                                     Fvid2Utils_LinkListType listType,
+                                     Fvid2Utils_LinkAddMode  addMode)
+{
+    int32_t retVal = FVID2_SOK;
+    if ((FVID2UTILS_LLT_CIRCULAR == listType) &&
+        (FVID2UTILS_LAM_PRIORITY != addMode))
+    {
+        GT_0trace(Fvid2Trace, GT_DEBUG,
+                  "Non-Priority circular link list not Supported\r\n");
+        retVal = FVID2_EBADARGS;
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, (NULL != llobj));
+        /* Initialize the variables */
+        llobj->listType    = listType;
+        llobj->addMode     = addMode;
+        llobj->headNode    = NULL;
+        llobj->tailNode    = NULL;
+        llobj->numElements = 0U;
+        llobj->priorityCnt = 0;
+    }
+
+    return retVal;
+}
+
+/**
+ *  Fvid2Utils_destructLinkList
+ *  \brief Destructs a link list object.
+ *
+ *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != llobj));
+    GT_assert(Fvid2Trace, (NULL == llobj->headNode));
+    GT_assert(Fvid2Trace, (NULL == llobj->tailNode));
+
+    /* Free link list object */
+    Fvid2Utils_memset(llobj, 0, sizeof (Fvid2UtilsLinkListObj));
+
+    return (FVID2_SOK);
+}
+
+/**
+ *  Fvid2Utils_unLinkAllNodes
+ *  \brief Releases all nodes without modifying any of the property.
+ *         CAUTION - Memory is NOT de-allocated, its the responsibility of the
+ *                   caller to ensure de-allocation of memory.
+ *
+ *  \param handle           Link list handle.
+ *
+ *  \return                 Returns 0 on success else returns error value.
+ */
+int32_t Fvid2Utils_unLinkAllNodes(Fvid2Utils_Handle handle)
+{
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj              = (Fvid2UtilsLinkListObj *) handle;
+    llobj->headNode    = NULL;
+    llobj->tailNode    = NULL;
+    llobj->numElements = 0U;
+    llobj->priorityCnt = 0;
+
+    return (0);
+}
+
+/**
+ *  Fvid2Utils_linkNodePri
+ *  \brief Links a node to the linked list according to the list type
+ *  The memory to the node object should be allocated by the caller. This
+ *  is used for link list with priority.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param priority         Priority of the node used for priority based
+ *                          addition of nodes. Priority is in descending order
+ *                          the value. So 0 is the highest priority and is
+ *                          added to the top of the node.
+ *                          Nodes with the same priority are always added to
+ *                          the bottom of the existing nodes with same
+ *                          priority.
+ *                          For non-priority based modes, this parameter
+ *                          is ignored and could be set to 0.
+ */
+void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
+                            Fvid2Utils_Node  *node,
+                            uint32_t          priority)
+{
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+
+    if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
+    {
+        llobj->headNode = dutilsLinkCircularPri(
+            llobj->headNode,
+            node,
+            node->data,
+            priority);
+    }
+    else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
+    {
+        dutilsLinkDoublePri(llobj, node, node->data, priority, (uint32_t) FALSE);
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, FALSE);
+    }
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_linkUniqePriNode
+ *  \brief Very similar to Fvid2Utils_linkNodePri, except that on equal priority
+ *          nodes will not be inserted. An error (FVID2_EBADARGS) would be
+ *          returned.
+ *          Applicable for double linked list only.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param priority         Priority of the node used for priority based
+ *                          addition of nodes. Priority is in descending order
+ *                          the value. So 0 is the highest priority and is
+ *                          added to the top of the node.
+ *                          Nodes with the same priority are always added to
+ *                          the bottom of the existing nodes with same
+ *                          priority.
+ *                          For non-priority based modes, this parameter
+ *                          is ignored and could be set to 0.
+ */
+int32_t Fvid2Utils_linkUniqePriNode(Fvid2Utils_Handle handle,
+                                    Fvid2Utils_Node  *node,
+                                    uint32_t          priority)
+{
+    Fvid2UtilsLinkListObj *llobj;
+    int32_t rtnValue = FVID2_SOK;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+
+    if (FVID2UTILS_LAM_PRIORITY != llobj->addMode)
+    {
+        if (FVID2UTILS_LAM_TOP == llobj->addMode)
+        {
+            llobj->priorityCnt--;
+        }
+        else if (FVID2UTILS_LAM_BOTTOM == llobj->addMode)
+        {
+            llobj->priorityCnt++;
+        }
+        else
+        {
+            GT_assert(Fvid2Trace, FALSE);
+        }
+        priority = llobj->priorityCnt;
+    }
+
+    if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
+    {
+        llobj->headNode = dutilsLinkCircularPri(
+            llobj->headNode,
+            node,
+            node->data,
+            priority);
+    }
+    else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
+    {
+        rtnValue = dutilsLinkDoublePri(
+            llobj,
+            node,
+            node->data,
+            priority,
+            (uint32_t) TRUE);
+        if (rtnValue == FVID2_SOK)
+        {
+            llobj->numElements++;
+        }
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, FALSE);
+    }
+
+    return (rtnValue);
+}
+
+/**
+ *  Fvid2Utils_unLinkNodePri
+ *  \brief Unlinks the node from the list. Used for the Priority linklists.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node pointer to be unlinked from the list.
+ */
+void Fvid2Utils_unLinkNodePri(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
+{
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
+    {
+        llobj->headNode = dutilsUnLinkCircularPri(llobj->headNode, node);
+    }
+    else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
+    {
+        dutilsUnLinkDoublePri(llobj, node);
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, FALSE);
+    }
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_unLinkNode
+ *  \brief Unlinks the node from the list. Used for Non-priority linked lists
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node pointer to be unlinked from the list.
+ */
+void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle, const Fvid2Utils_Node *node)
+{
+    Fvid2UtilsLinkListObj *llobj;
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    dutilsUnLinkDouble(llobj, dir, node);
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_linkNodeToTail
+ *  \brief                  Link the node to the tail of the double linked list.
+ *                          No priority
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
+{
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_TAIL;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    dutilsLinkDouble(llobj, node, node->data, dir);
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_linkNodeToHead
+ *  \brief                  Link the node to the head of the double linked list.
+ *                          No priority
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
+{
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    dutilsLinkDouble(llobj, node, node->data, dir);
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_unLinkNodeFromHead
+ *  \brief                  Returns the node from head. Removes the  node from
+ *                          the list.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromHead(Fvid2Utils_Handle handle)
+{
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    return (dutilsUnLinkDouble(llobj, dir, NULL));
+}
+
+/**
+ *  Fvid2Utils_unLinkNodeFromTail
+ *  \brief                  Returns the node from tail. Removes the  node from
+ *                          the list.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromTail(Fvid2Utils_Handle handle)
+{
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_TAIL;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    return (dutilsUnLinkDouble(llobj, dir, NULL));
+}
+
+/**
+ *  Fvid2Utils_getHeadNode
+ *  \brief                  Returns the reference to the headNode. Does
+ *                          not remove the node from the head.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_getHeadNode(Fvid2Utils_Handle handle)
+{
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+
+    return (llobj->headNode);
+}
+
+/**
+ *  Fvid2Utils_getTailNode
+ *  \brief                  Returns the reference to the TailNode. Does
+ *                          not remove the node from the head.
+ *
+ *  \param handle           Link list handle.
+ *  \param node             Node object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ *
+ */
+Fvid2Utils_Node *Fvid2Utils_getTailNode(Fvid2Utils_Handle handle)
+{
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    return (llobj->tailNode);
+}
+
+/**
+ *  Fvid2Utils_isListEmpty
+ *  \brief Checks whether a list is empty or not.
+ *
+ *  \param handle           List handle.
+ *
+ *  \return                 TRUE if List is empty else returns FALSE.
+ */
+uint32_t Fvid2Utils_isListEmpty(Fvid2Utils_Handle handle)
+{
+    uint32_t isEmpty = FALSE;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    if (NULL == llobj->headNode)
+    {
+        isEmpty = (uint32_t) TRUE;
+    }
+
+    return (isEmpty);
+}
+
+/**
+ *  Fvid2Utils_getNumNodes
+ *  \brief Returns the number of nodes present in a list.
+ *
+ *  \param handle           List handle.
+ *
+ *  \return                 Number of nodes present in a list.
+ */
+uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle)
+{
+    Fvid2Utils_Node       *node = NULL;
+    Fvid2UtilsLinkListObj *llobj;
+    uint32_t numNodes = 0U;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
+    {
+        node = llobj->headNode;
+        while (NULL != node)
+        {
+            numNodes++;
+            node = node->next;
+            /* Not supposed to have NULL in circular list */
+            GT_assert(Fvid2Trace, (NULL != node));
+
+            /* Check if we have come to the end of the list */
+            if (node == llobj->headNode)
+            {
+                break;
+            }
+        }
+    }
+    else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
+    {
+        node = llobj->headNode;
+        while (NULL != node)
+        {
+            numNodes++;
+            node = node->next;
+        }
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, FALSE);
+    }
+
+    return (numNodes);
+}
+
+/**
+ *  Fvid2Utils_constructQ
+ *  \brief Constructs a Queue object.
+ *
+ * \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_constructQ(Fvid2UtilsLinkListObj *llobj)
+{
+    return Fvid2Utils_constructLinkList(llobj, FVID2UTILS_LLT_DOUBLE,
+                                        FVID2UTILS_LAM_BOTTOM);
+}
+
+/**
+ *  Fvid2Utils_destructQ
+ *  \brief Destructs a Queue object.
+ *
+ * \param llobj pointer to object of type Fvid2UtilsLinkListObj
+ *
+ *  \return                 Returns FVID2_SOK on success else returns error value.
+ */
+int32_t Fvid2Utils_destructQ(Fvid2UtilsLinkListObj *llobj)
+{
+    return Fvid2Utils_destructLinkList(llobj);
+}
+
+/**
+ *  Fvid2Utils_queue
+ *  \brief Adds the data to the queue. Add the node to the tail of the queue.
+ *
+ *
+ *  \param handle           Queue handle.
+ *  \param qElem            Queue Element object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ */
+void Fvid2Utils_queue(Fvid2Utils_QHandle handle,
+                      Fvid2Utils_QElem  *qElem,
+                      void              *data)
+{
+    Fvid2UtilsLinkListObj *llobj;
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_TAIL;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    dutilsLinkDouble(llobj, qElem, data, dir);
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_dequeue
+ *  \brief Removes a element from the queue. Removes the element from the head
+ *   of the queue.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the removed data pointer.
+ */
+void *Fvid2Utils_dequeue(Fvid2Utils_QHandle handle)
+{
+    Fvid2Utils_Node       *node;
+    void                  *data = NULL;
+    Fvid2UtilsLinkListObj *llobj;
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    node  = dutilsUnLinkDouble(llobj, dir, NULL);
+    if (NULL != node)
+    {
+        data = node->data;
+    }
+    else
+    {
+        data = NULL;
+    }
+
+    return (data);
+}
+
+/**
+ *  Fvid2Utils_peakHead
+ *  \brief Returns the reference of the first queued element.
+ *
+ *  This doesn't remove the element from the queue.
+ *  If the queue is empty, then this returns NULL.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the reference of the first element.
+ */
+void *Fvid2Utils_peakHead(Fvid2Utils_QHandle handle)
+{
+    void *data = NULL;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    if (llobj->headNode != NULL)
+    {
+        data = llobj->headNode->data;
+    }
+
+    return (data);
+}
+
+/**
+ *  Fvid2Utils_peakTail
+ *  \brief Returns the reference of the last queued element.
+ *
+ *  This doesn't remove the element from the queue.
+ *  If the queue is empty, then this returns NULL.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Returns the reference of the last queued element.
+ */
+void *Fvid2Utils_peakTail(Fvid2Utils_QHandle handle)
+{
+    void *data = NULL;
+    Fvid2UtilsLinkListObj *llobj;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    if (llobj->tailNode != NULL)
+    {
+        data = llobj->tailNode->data;
+    }
+
+    return (data);
+}
+
+/**
+ *  Fvid2Utils_queueBack
+ *  \brief Adds the data to start of the queue. Queue the data back to the
+ *  head of the queue.
+ *
+ *  \param handle           Queue handle.
+ *  \param qElem            Queue Element object pointer used for linking.
+ *  \param data             Data pointer to be added to the list.
+ *                          This should be unique.
+ */
+void Fvid2Utils_queueBack(Fvid2Utils_QHandle handle,
+                          Fvid2Utils_QElem  *qElem,
+                          void              *data)
+{
+    Fvid2UtilsLinkListObj *llobj;
+    Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    llobj = (Fvid2UtilsLinkListObj *) handle;
+    dutilsLinkDouble(llobj, qElem, data, dir);
+
+    return;
+}
+
+/**
+ *  Fvid2Utils_isQEmpty
+ *  \brief Checks whether a queue is empty or not.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 TRUE if queue is empty else returns FALSE.
+ */
+uint32_t Fvid2Utils_isQEmpty(Fvid2Utils_QHandle handle)
+{
+    return Fvid2Utils_isListEmpty(handle);
+}
+
+/**
+ *  Fvid2Utils_getNumQElem
+ *  \brief Returns the number of Queue Elements present in a Queue.
+ *
+ *  \param handle           Queue handle.
+ *
+ *  \return                 Number of Queue Elements present in a Queue.
+ */
+uint32_t Fvid2Utils_getNumQElem(Fvid2Utils_QHandle handle)
+{
+    return Fvid2Utils_getNumNodes(handle);
+}
+
+/**
+ *  dutilsLinkCircularPri
+ *  \brief Links a node to a circular link list based on priority.
+ *  For nodes with same priority, the new node will be added to the last.
+ */
+static Fvid2Utils_Node *dutilsLinkCircularPri(Fvid2Utils_Node *headNode,
+                                              Fvid2Utils_Node *node,
+                                              void            *data,
+                                              uint32_t         priority)
+{
+    Fvid2Utils_Node *curNode;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    node->data     = data;
+    node->priority = priority;
+
+    /* Check if this is the first node. */
+    if (NULL != headNode)
+    {
+        /* Add to the list based on priority */
+        curNode = headNode;
+        do
+        {
+            /* Nodes with the same priority are always added to the bottom
+             * of the existing nodes with same priority. */
+            if (priority < curNode->priority)
+            {
+                if (curNode == headNode)
+                {
+                    /* Adding to the top of the list */
+                    headNode = node;
+                }
+                break;
+            }
+
+            /* Move to next node */
+            curNode = curNode->next;
+            /* Not supposed to have NULL in circular list */
+            GT_assert(Fvid2Trace, (NULL != curNode));
+        } while (curNode != headNode);
+        /* Check if we have come to the end of the list */
+
+        /* Add the node before the current node as we have traversed one
+         * extra node. */
+        node->next = curNode;
+        node->prev = curNode->prev;
+
+        /* Not supposed to have NULL in circular list */
+        GT_assert(Fvid2Trace, (NULL != curNode->prev));
+        GT_assert(Fvid2Trace, (NULL != curNode->prev->next));
+        curNode->prev->next = node;
+        curNode->prev       = node;
+    }
+    else
+    {
+        /* First node. Add to as head node */
+        headNode   = node;
+        node->next = node;
+        node->prev = node;
+    }
+
+    return (headNode);
+}
+
+/**
+ *  dutilsLinkDoublePri
+ *  \brief Links a node to a double link list based on priority.
+ *  For nodes with same priority, the new node will be added to the last.
+ *
+ *  ToDo - Remove multiple return statements - Have one exit point for the
+ *         Function.
+ */
+static int32_t dutilsLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
+                                   Fvid2Utils_Node       *node,
+                                   void                  *data,
+                                   uint32_t               priority,
+                                   uint32_t               linkUniqePriNodes)
+{
+    int32_t          retVal = FVID2_SOK;
+    Fvid2Utils_Node *curNode, *prevNode = NULL;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    node->data     = data;
+    node->priority = priority;
+
+    /* Add to the list based on priority */
+    curNode = llobj->headNode;
+    while (NULL != curNode)
+    {
+        /* Nodes with the same priority are always added to the bottom
+         * of the existing nodes with same priority. */
+        if (priority < curNode->priority)
+        {
+            break;
+        }
+
+        /* Move to next node */
+        prevNode = curNode;
+        curNode  = curNode->next;
+    }
+
+    /* If unique priority check is enabled - check for uniqueness */
+    if (linkUniqePriNodes == (uint32_t) TRUE)
+    {
+        if (prevNode != NULL)
+        {
+            if (priority == prevNode->priority)
+            {
+                retVal = FVID2_EBADARGS;
+            }
+        }
+    }
+
+    if (FVID2_SOK == retVal)
+    {
+        /* Add the node between current and previous nodes */
+        node->next = curNode;
+        node->prev = prevNode;
+        if (NULL != prevNode)
+        {
+            prevNode->next = node;
+        }
+        else
+        {
+            /* Adding to the top of the list */
+            llobj->headNode = node;
+        }
+
+        if (NULL != curNode)
+        {
+            curNode->prev = node;
+        }
+        else
+        {
+            llobj->tailNode = node;
+        }
+        retVal = FVID2_SOK;
+    }
+
+    return (retVal);
+}
+
+/**
+ *  dutilsUnLinkCircularPri
+ *  \brief Unlinks a node from a circular link list.
+ */
+static Fvid2Utils_Node *dutilsUnLinkCircularPri(Fvid2Utils_Node *headNode,
+                                                Fvid2Utils_Node *node)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != headNode));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    /* Not supposed to have NULL in circular list */
+    GT_assert(Fvid2Trace, (NULL != node->next));
+    GT_assert(Fvid2Trace, (NULL != node->prev));
+
+    /* Link the node's previous node to node's next node */
+    node->prev->next = node->next;
+    node->next->prev = node->prev;
+
+    if (node == headNode)
+    {
+        /* Unlinking head node */
+        if ((headNode == headNode->next) || (headNode == headNode->prev))
+        {
+            /* Unlinking last node */
+            GT_assert(Fvid2Trace,
+                      ((headNode == headNode->next) &&
+                       (headNode == headNode->prev)));
+            headNode = NULL;
+        }
+        else
+        {
+            /* Make next node as head node */
+            headNode = node->next;
+        }
+    }
+
+    /* Reset node memory */
+    node->next = NULL;
+    node->prev = NULL;
+
+    return (headNode);
+}
+
+/**
+ *  dutilsUnLinkDoublePri
+ *  \brief Unlinks a node from a double link list.
+ */
+static void dutilsUnLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
+                                  Fvid2Utils_Node       *node)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != llobj));
+    GT_assert(Fvid2Trace, (NULL != node));
+
+    if (NULL == node->prev)
+    {
+        /* Removing head node */
+        llobj->headNode = node->next;
+    }
+    else
+    {
+        /* Removing non-head node */
+        node->prev->next = node->next;
+    }
+
+    if (NULL != node->next)
+    {
+        node->next->prev = node->prev;
+    }
+    else
+    {
+        llobj->tailNode = NULL;
+    }
+
+    /* Reset node memory */
+    node->next = NULL;
+    node->prev = NULL;
+
+    return;
+}
+
+/**
+ *  dutilsUnLinkDouble
+ *  \brief Unlinks a node from a double link list.
+ */
+static Fvid2Utils_Node *dutilsUnLinkDouble(Fvid2UtilsLinkListObj *llobj,
+                                           Fvid2Utils_NodDir      dir,
+                                           const Fvid2Utils_Node *nodeToBeRem)
+{
+    Fvid2Utils_Node *node = NULL, *headNode, *tailNode, *listNode;
+    uint32_t         nodeCnt;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != llobj));
+
+    if (NULL == nodeToBeRem)
+    {
+        if ((NULL == llobj->headNode) && (NULL == llobj->tailNode))
+        {
+            node = NULL;
+        }
+        /* Check for the last node in the list */
+        else if ((NULL != llobj->headNode) &&
+                 (NULL == llobj->headNode->next) &&
+                 (NULL == llobj->headNode->prev))
+        {
+            node = llobj->headNode;
+            llobj->tailNode = NULL;
+            llobj->headNode = NULL;
+        }
+        else if ((NULL != llobj->headNode) &&
+                 (NULL != llobj->tailNode) &&
+                 (FVID2UTILS_NODE_DIR_HEAD == dir))
+        {
+            /* Point headnode to the head of the list */
+            headNode = llobj->headNode;
+            /* headnode points to now next in the list */
+            llobj->headNode = headNode->next;
+            /* prev of the new headnode point to headNode of the list */
+            if (NULL != llobj->headNode)
+            {
+                llobj->headNode->prev = NULL;
+            }
+            else
+            {
+                llobj->tailNode = NULL;
+            }
+            /* return the detached node */
+            node = headNode;
+        }
+        else if ((NULL != llobj->headNode) &&
+                 (NULL != llobj->tailNode) &&
+                 (FVID2UTILS_NODE_DIR_TAIL == dir))
+        {
+            /* point to the tail node. */
+            tailNode = llobj->tailNode;
+            /* tailnode of the list points to the previous node */
+            llobj->tailNode = tailNode->prev;
+            /* next node of the previous node points to the tail node of list */
+            if (NULL != llobj->tailNode)
+            {
+                llobj->tailNode->next = NULL;
+            }
+            else
+            {
+                llobj->headNode = NULL;
+            }
+            /*  return the tail node */
+            node = tailNode;
+        }
+        else
+        {
+            GT_assert(Fvid2Trace, FALSE);
+        }
+    }
+    else
+    {
+        listNode = llobj->headNode;
+        for (nodeCnt = 0; nodeCnt < llobj->numElements; nodeCnt++)
+        {
+            if (listNode == nodeToBeRem)
+            {
+                /* Last node in the list */
+                if ((llobj->headNode == listNode) &&
+                    (llobj->tailNode == listNode))
+                {
+                    llobj->headNode = NULL;
+                    llobj->tailNode = NULL;
+                }
+                else if (llobj->headNode == listNode)
+                {
+                    llobj->headNode       = listNode->next;
+                    llobj->headNode->prev = NULL;
+                }
+                else if (llobj->tailNode == listNode)
+                {
+                    llobj->tailNode       = listNode->prev;
+                    llobj->tailNode->next = NULL;
+                }
+                else
+                {
+                    listNode->prev->next = listNode->next;
+                    listNode->next->prev = listNode->prev;
+                }
+                node = listNode;
+                break;
+            }
+            listNode = listNode->next;
+        }
+    }
+    if (NULL != node)
+    {
+        /* Reset node memory */
+        node->next = NULL;
+        node->prev = NULL;
+        llobj->numElements--;
+    }
+
+    return (node);
+}
+
+/**
+ *  Fvid2Utils_getNumNodes
+ *  \brief Returns the number of nodes present in a list.
+ *
+ *  \param handle           List handle.
+ *
+ *  \return                 Number of nodes present in a list.
+ */
+uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle)
+{
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != handle));
+
+    return (((Fvid2UtilsLinkListObj *) handle)->numElements);
+}
+
+/**
+ *  dutilsLinkDouble
+ *  \brief Links a node to a double link list either at head of the list or
+ *  at tail of the list.
+ *
+ *
+ */
+static Fvid2Utils_Node *dutilsLinkDouble(Fvid2UtilsLinkListObj *llobj,
+                                         Fvid2Utils_Node       *node,
+                                         void                  *data,
+                                         Fvid2Utils_NodDir      dir)
+{
+    Fvid2Utils_Node *headNode, *tailNode = NULL;
+
+    /* NULL pointer check */
+    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL != llobj));
+
+    node->data = data;
+    /* check for the first element in the list */
+    if ((NULL == llobj->headNode) && (NULL == llobj->tailNode))
+    {
+        /* Add the first element in the list */
+        /* head node points to new element */
+        llobj->headNode = node;
+        /* tail node also points to new element */
+        llobj->tailNode = node;
+        /* next of node points to tail */
+        node->next = NULL;
+        /* prev of node points to head */
+        node->prev = NULL;
+    }
+    else if ((NULL != llobj->headNode) &&
+             (NULL != llobj->tailNode) &&
+             (FVID2UTILS_NODE_DIR_HEAD == dir))
+    {
+        headNode = llobj->headNode;
+        /* headNode now points to new node */
+        llobj->headNode = node;
+        /* previous of new node points to headNode */
+        node->prev = NULL;
+        /* next of new points to prev head node */
+        node->next = headNode;
+        /* prev of previous head node head points to new node */
+        headNode->prev = node;
+    }
+    else if ((NULL != llobj->headNode) &&
+             (NULL != llobj->tailNode) &&
+             (FVID2UTILS_NODE_DIR_TAIL == dir))
+    {
+        tailNode = llobj->tailNode;
+        /* next of new node points to tail of list */
+        node->next = NULL;
+        /* tail of list points to new node */
+        llobj->tailNode = node;
+        /* next of previous tial node points to new tail node */
+        tailNode->next = node;
+        /* previous of new tail node points to previous tail node */
+        node->prev = tailNode;
+    }
+    else
+    {
+        GT_assert(Fvid2Trace, FALSE);
+    }
+    llobj->numElements++;
+    return (node);
+}
index 3885147b7b457387fe1548ddd0557f04d0f3a7d1..3d0e8f8a642f09359bb3a9a829a7b840e43559b5 100644 (file)
@@ -15,10 +15,10 @@ INCLUDE_EXTERNAL_INTERFACES = pdk
 # Common source files and CFLAGS across all platforms and cores
 PACKAGE_SRCS_COMMON = .
 
-SRCS_COMMON += fvid2_drvMgr.c
+SRCS_COMMON += fvid2_drvMgr.c fvid2_utils.c
 
 CFLAGS_LOCAL_COMMON = $(PDK_CFLAGS)
-PACKAGE_SRCS_COMMON = . ../fvid2_component.mk ../include ../src ../fvid2
+PACKAGE_SRCS_COMMON = fvid2.h fvid2_component.mk include src
 
 # Core/SoC/platform specific source files and CFLAGS
 # Example: