Added floor and align function to FVID2 Utils
[keystone-rtos/fvid2.git] / include / fvid2_utils.h
1 /*
2  *  Copyright (c) Texas Instruments Incorporated 2018
3  *
4  *  Redistribution and use in source and binary forms, with or without
5  *  modification, are permitted provided that the following conditions
6  *  are met:
7  *
8  *    Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  *    Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the
14  *    distribution.
15  *
16  *    Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /**
34  *  \file fvid2_utils.h
35  *
36  *  \brief FVID2 Utility functions header file
37  *  This file declares the functions required to create, add and remove nodes.
38  *  Also provides various memset functions.
39  *
40  */
42 #ifndef FVID2_UTILS_H_
43 #define FVID2_UTILS_H_
45 /* ========================================================================== */
46 /*                             Include Files                                  */
47 /* ========================================================================== */
49 #include <ti/osal/osal.h>
51 #ifdef __cplusplus
52 extern "C" {
53 #endif
55 /* ========================================================================== */
56 /*                           Macros & Typedefs                                */
57 /* ========================================================================== */
59 /** \brief Log enable for FVID2 Utils. */
60 #define Fvid2Trace                      (GT_DEFAULT_MASK)
62 /**< \brief Number of timestamp log entries. */
63 #define FVID2UTILS_NUM_TIMESTAMP_LOG    (100U)
65 /**
66  *  struct Fvid2Utils_LinkListType
67  *  \brief Enums for the type of link list to be created.
68  */
69 typedef enum
70 {
71     FVID2UTILS_LLT_DOUBLE,
72     /**< Double link list. */
73     FVID2UTILS_LLT_CIRCULAR
74     /**< Circular link list using double link list. */
75 } Fvid2Utils_LinkListType;
77 /**
78  *  struct Fvid2Utils_LinkAddMode
79  *  \brief Enums for the different modes of adding a node to a link list.
80  */
81 typedef enum
82 {
83     FVID2UTILS_LAM_TOP,
84     /**< Add nodes to the top of the list. */
85     FVID2UTILS_LAM_BOTTOM,
86     /**< Add nodes to the bottom of the list. */
87     FVID2UTILS_LAM_PRIORITY
88     /**< Add nodes to the list based on ascending order of priority.
89      *   Nodes with the same priority are always added to the bottom of the
90      *   existing nodes with same priority. */
91 } Fvid2Utils_LinkAddMode;
93 /**
94  *  struct Fvid2Utils_LinkAddMode
95  *  \brief Enums for the different modes of adding a node to a link list.
96  */
97 typedef enum
98 {
99     FVID2UTILS_NODE_DIR_HEAD,
100     /**< Add nodes to the top of the list. */
101     FVID2UTILS_NODE_DIR_TAIL
102     /**< Add nodes to the bottom of the list. */
103 } Fvid2Utils_NodDir;
105 /* ========================================================================== */
106 /*                         Structure Declarations                             */
107 /* ========================================================================== */
109 /**< \brief Typedef for Node structure. */
110 typedef struct Fvid2Utils_Node_t Fvid2Utils_Node;
112 /**
113  *  struct Fvid2Utils_Node_t
114  *  \brief Self referential structure for double link list.
115  */
116 struct Fvid2Utils_Node_t
118     Fvid2Utils_Node *next;
119     /**< Pointer to the next node. */
120     Fvid2Utils_Node *prev;
121     /**< Pointer to the previous node. */
122     void            *data;
123     /**< Node data pointer. */
124     uint32_t         priority;
125     /**< Priority of the node. Used for priority based linked list. */
126 };
128 /**
129  *  struct Fvid2Utils_QElem
130  *  \brief Typedef for Queue Node element.
131  */
132 typedef Fvid2Utils_Node Fvid2Utils_QElem;
134 /**
135  *  struct Fvid2Utils_PoolParams
136  *  \brief Create parameters for the fixed size pool.
137  */
138 typedef struct
140     void       *mem;
141     /**< Pointer to the pool memory. */
142     uint32_t    numElem;
143     /**< Number of elements in the pool. */
144     uint32_t    elemSize;
145     /**< Size of each element in bytes. */
146     uint32_t   *flag;
147     /**< Array of flag variable used by pool manager to indicate whether a pool
148      *   element is allocated or not. The size of this array should be
149      *   equal to the number of elements in this pool. */
150     uint32_t    numFreeElem;
151     /**< Count to keep track of the number of free elements in the pool. */
152 } Fvid2Utils_PoolParams;
154 /**
155  *  struct Fvid2Utils_TsPrfLog
156  *  \brief Timestamp Performance log structure in OSAL timestamp ticks.
157  */
158 typedef struct
160     uint64_t startTime;
161     /**< Start time - updated in start function. */
162     uint64_t total;
163     /**< Total duration of all log entires.
164      *   To get average divide by totalCnt. */
165     uint32_t totalCnt;
166     /**< Total number of log entires. */
167     uint64_t min;
168     /**< Minimum duration. */
169     uint64_t max;
170     /**< Maximum duration. */
171     uint32_t prfLogIndex;
172     /**< Current index. This will wrap around every FVID2UTILS_NUM_TIMESTAMP_LOG
173      *   count. */
174     uint64_t prfLog[FVID2UTILS_NUM_TIMESTAMP_LOG];
175     /**< History of the past FVID2UTILS_NUM_TIMESTAMP_LOG entires. */
176 } Fvid2Utils_TsPrfLog;
178 /**
179  *  struct Fvid2UtilsLinkListObj
180  *  \brief Structure to the link list object information.
181  */
182 typedef struct
184     Fvid2Utils_LinkListType listType;
185     /**< Type of linked list. */
186     Fvid2Utils_LinkAddMode  addMode;
187     /**< Mode of adding a node to a link list. */
188     Fvid2Utils_Node        *headNode;
189     /**< Head Node. */
190     Fvid2Utils_Node        *tailNode;
191     /**< Tail Node Node. */
192     uint32_t                numElements;
193     /**< Number of elements in the linked list. */
194     uint32_t                priorityCnt;
195     /**< Priority count of the linked list. */
196 } Fvid2UtilsLinkListObj;
198 /**
199  *  struct Fvid2Utils_Handle
200  *  \brief Typedef for FVID2 Utils handle.
201  */
202 typedef Fvid2UtilsLinkListObj *Fvid2Utils_Handle;
204 /**
205  *  struct Fvid2Utils_QHandle
206  *  \brief Typedef for FVID2 Utils Queue Handle.
207  */
208 typedef Fvid2Utils_Handle Fvid2Utils_QHandle;
210 /* ========================================================================== */
211 /*                          Function Declarations                             */
212 /* ========================================================================== */
214 /**
215  *  Fvid2Utils_memset
216  *  \brief Sets the memory with the given value. Access memory as byte.
217  *  Returns the memory pointer.
218  *
219  *  \param mem              Destination memory pointer.
220  *  \param ch               Byte value to fill with.
221  *  \param byteCount        Number of bytes to fill.
222  *
223  *  \return                 The destination memory pointer.
224  */
225 void *Fvid2Utils_memset(void *mem, uint8_t ch, uint32_t byteCount);
227 /**
228  *  Fvid2Utils_memsetw
229  *  \brief Sets the memory with the given value. Access memory as word.
230  *  Hence memory pointer should be aligned to 4 byte boundary
231  *  Returns the memory pointer.
232  *
233  *  \param mem              Destination memory pointer.
234  *  \param word             Word value to fill with.
235  *  \param wordCount        Number of words to fill.
236  *
237  *  \return                 The destination memory pointer.
238  */
239 void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount);
241 /**
242  *  Fvid2Utils_memcpy
243  *  \brief Copies source memory into destination memory. Access memory as byte.
244  *  Returns the destination memory pointer.
245  *
246  *  \param dest             Destination memory pointer.
247  *  \param src              Source memory pointer.
248  *  \param byteCount        Number of bytes to copy.
249  *
250  *  \return                 The destination memory pointer.
251  */
252 void *Fvid2Utils_memcpy(void *dest, const void *src, uint32_t byteCount);
254 /**
255  *  Fvid2Utils_memcmp
256  *  \brief Compare memory block 1 with memory block 2. Access memory as byte.
257  *  Returns 0 if two memories are  identical.
258  *
259  *  \param mem1             memory block 1
260  *  \param mem2              memory block 2
261  *  \param byteCount        Number of bytes to compare
262  *
263  *  \return                 0 if two memory are identical other return 1
264  */
265 int32_t Fvid2Utils_memcmp(const void *mem1,
266                           const void *mem2,
267                           uint32_t byteCount);
269 /**
270  *  Fvid2Utils_constructLinkList
271  *  \brief Constructs a link list object with the provided properties.
272  *
273  *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
274  *  \param listType         List type - circular/double link list.
275  *  \param addMode          Node addition mode - Top/Bottom/Priority based.
276  *
277  *  \return                 Returns FVID2_SOK on success else returns error
278  *                          value.
279  */
280 int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
281                                      Fvid2Utils_LinkListType listType,
282                                      Fvid2Utils_LinkAddMode  addMode);
284 /**
285  *  Fvid2Utils_destructLinkList
286  *  \brief Destructs a link list object.
287  *
288  *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
289  *
290  *  \return                 Returns FVID2_SOK on success else returns error value.
291  */
292 int32_t Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj);
294 /**
295  *  Fvid2Utils_linkNodePri
296  *  \brief Links a node to the linked list according to the list type
297  *  The memory to the node object should be allocated by the caller. This
298  *  is used for link list with priority.
299  *
300  *  \param handle           Link list handle.
301  *  \param node             Node object pointer used for linking.
302  *  \param priority         Priority of the node used for priority based
303  *                          addition of nodes. Priority is in descending order
304  *                          the value. So 0 is the highest priority and is
305  *                          added to the top of the node.
306  *                          Nodes with the same priority are always added to
307  *                          the bottom of the existing nodes with same
308  *                          priority.
309  *                          For non-priority based modes, this parameter
310  *                          is ignored and could be set to 0.
311  */
312 void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
313                             Fvid2Utils_Node  *node,
314                             uint32_t          priority);
316 /**
317  *  Fvid2Utils_linkUniqePriNode
318  *  \brief Very similar to Fvid2Utils_linkNode, except that on equal priority
319  *          nodes will not be inserted. An error (FVID2_EBADARGS) would be
320  *          returned.
321  *          Applicable for double linked list only.
322  *  ToDo Update to handle circular list also.
323  *
324  *  \param handle           Link list handle.
325  *  \param node             Node object pointer used for linking.
326  *  \param priority         Priority of the node used for priority based
327  *                          addition of nodes. Priority is in descending order
328  *                          the value. So 0 is the highest priority and is
329  *                          added to the top of the node.
330  *                          Nodes with the same priority are always added to
331  *                          the bottom of the existing nodes with same
332  *                          priority.
333  *                          For non-priority based modes, this parameter
334  *                          is ignored and could be set to 0.
335  */
336 int32_t Fvid2Utils_linkUniqePriNode(Fvid2Utils_Handle handle,
337                                     Fvid2Utils_Node  *node,
338                                     uint32_t          priority);
340 /**
341  *  Fvid2Utils_unLinkAllNodes
342  *  \brief Releases all nodes without modifying any of the property.
343  *         CAUTION - Memory is NOT de-allocated, its the responsibility of the
344  *                   caller to ensure de-allocation of memory.
345  *
346  *  \param handle           Link list handle.
347  *
348  *  \return                 Returns 0 on success else returns error value.
349  */
350 int32_t Fvid2Utils_unLinkAllNodes(Fvid2Utils_Handle handle);
352 /**
353  *  Fvid2Utils_unLinkNodePri
354  *  \brief Unlinks the node from the list. Used for the Priority linklists.
355  *
356  *  \param handle           Link list handle.
357  *  \param node             Node pointer to be unlinked from the list.
358  */
359 void Fvid2Utils_unLinkNodePri(Fvid2Utils_Handle handle, Fvid2Utils_Node *node);
361 /**
362  *  Fvid2Utils_unLinkNode
363  *  \brief Unlinks the node from the list. Used for Non-priority linked lists
364  *
365  *  \param handle           Link list handle.
366  *  \param node             Node pointer to be unlinked from the list.
367  */
368 void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle,
369                            const Fvid2Utils_Node *node);
371 /**
372  *  Fvid2Utils_linkNodeToHead
373  *  \brief                  Link the node to the head of the double linked list.
374  *                          No priority
375  *
376  *  \param handle           Link list handle.
377  *  \param node             Node object pointer used for linking.
378  *
379  */
380 void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle,
381                                Fvid2Utils_Node  *node);
383 /**
384  *  Fvid2Utils_linkNodeToTail
385  *  \brief                  Link the node to the tail of the double linked list.
386  *                          No priority
387  *
388  *  \param handle           Link list handle.
389  *  \param node             Node object pointer used for linking.
390  */
391 void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle,
392                              Fvid2Utils_Node  *node);
394 /**
395  *  Fvid2Utils_unLinkNodeFromHead
396  *  \brief                  Returns the node from head. Removes the  node from
397  *                          the list.
398  *
399  *  \param handle           Link list handle.
400  *  \return                 Pointer to unlinked node.
401  *
402  */
403 Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromHead(Fvid2Utils_Handle handle);
405 /**
406  *  Fvid2Utils_unLinkNodeFromTail
407  *  \brief                  Returns the node from tail. Removes the  node from
408  *                          the list.
409  *
410  *  \param handle           Link list handle.
411  *  \return                 Pointer to unlinked node.
412  *
413  */
414 Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromTail(Fvid2Utils_Handle handle);
416 /**
417  *  Fvid2Utils_getHeadNode
418  *  \brief                  Returns the reference to the headNode. Does
419  *                          not remove the node from the head.
420  *
421  *  \param handle           Link list handle.
422  */
423 Fvid2Utils_Node *Fvid2Utils_getHeadNode(Fvid2Utils_Handle handle);
425 /**
426  *  Fvid2Utils_getTailNode
427  *  \brief                  Returns the reference to the TailNode. Does
428  *                          not remove the node from the head.
429  *
430  *  \param handle           Link list handle.
431  *  \return                 Reference  to tail node.  Acutally  node is not
432  *                          unlinked from list.
433  *
434  */
435 Fvid2Utils_Node *Fvid2Utils_getTailNode(Fvid2Utils_Handle handle);
437 /**
438  *  Fvid2Utils_isListEmpty
439  *  \brief Checks whether a list is empty or not.
440  *
441  *  \param handle           List handle.
442  *
443  *  \return                 TRUE if List is empty else returns FALSE.
444  */
445 uint32_t Fvid2Utils_isListEmpty(Fvid2Utils_Handle handle);
447 /**
448  *  Fvid2Utils_getNumNodes
449  *  \brief Returns the number of nodes present in a list.
450  *
451  *  \param handle           List handle.
452  *
453  *  \return                 Number of nodes present in a list.
454  */
455 uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle);
457 /**
458  *  Fvid2Utils_getNodeCnt
459  *  \brief Returns the number of nodes in the link list
460  *
461  *  \param handle           Link list handle.
462  *
463  *
464  *  \return                 Returns the number of nodes in the list.
465  */
466 uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle);
468 /**
469  *  Fvid2Utils_constructQ
470  *  \brief Constructs a Queue object.
471  *
472  * \param llobj pointer to object of type Fvid2UtilsLinkListObj
473  *
474  *  \return                 Returns FVID2_SOK on success else returns error value.
475  */
476 int32_t Fvid2Utils_constructQ(Fvid2UtilsLinkListObj *llobj);
478 /**
479  *  Fvid2Utils_destructQ
480  *  \brief Destructs a Queue object.
481  *
482  * \param llobj pointer to object of type Fvid2UtilsLinkListObj
483  *
484  *  \return                 Returns FVID2_SOK on success else returns error value.
485  */
486 int32_t Fvid2Utils_destructQ(Fvid2UtilsLinkListObj *llobj);
488 /**
489  *  Fvid2Utils_queue
490  *  \brief Adds the data to the queue.
491  *  The memory to the node object should be allocated by the caller.
492  *
493  *  \param handle           Queue handle.
494  *  \param qElem            Queue Element object pointer used for linking.
495  *  \param data             Data pointer to be added to the list.
496  *                          This should be unique.
497  */
498 void Fvid2Utils_queue(Fvid2Utils_QHandle handle,
499                       Fvid2Utils_QElem  *qElem,
500                       void              *data);
502 /**
503  *  Fvid2Utils_dequeue
504  *  \brief Removes a element from the queue.
505  *
506  *  \param handle           Queue handle.
507  *
508  *  \return                 Returns the removed data pointer.
509  */
510 void *Fvid2Utils_dequeue(Fvid2Utils_QHandle handle);
512 /**
513  *  Fvid2Utils_peakHead
514  *  \brief Returns the reference of the first queued element.
515  *
516  *  This doesn't remove the element from the queue.
517  *  If the queue is empty, then this returns NULL.
518  *
519  *  \param handle           Queue handle.
520  *
521  *  \return                 Returns the reference of the first element.
522  */
523 void *Fvid2Utils_peakHead(Fvid2Utils_QHandle handle);
525 /**
526  *  Fvid2Utils_peakTail
527  *  \brief Returns the reference of the last queued element.
528  *
529  *  This doesn't remove the element from the queue.
530  *  If the queue is empty, then this returns NULL.
531  *
532  *  \param handle           Queue handle.
533  *
534  *  \return                 Returns the reference of the last queued element.
535  */
536 void *Fvid2Utils_peakTail(Fvid2Utils_QHandle handle);
538 /**
539  *  Fvid2Utils_queueBack
540  *  \brief Adds the data to start of the queue.
541  *  The memory to the node object should be allocated by the caller.
542  *
543  *  \param handle           Queue handle.
544  *  \param qElem            Queue Element object pointer used for linking.
545  *  \param data             Data pointer to be added to the list.
546  *                          This should be unique.
547  */
548 void Fvid2Utils_queueBack(Fvid2Utils_QHandle handle,
549                           Fvid2Utils_QElem  *qElem,
550                           void              *data);
552 /**
553  *  Fvid2Utils_isQEmpty
554  *  \brief Checks whether a queue is empty or not.
555  *
556  *  \param handle           Queue handle.
557  *
558  *  \return                 TRUE if queue is empty else returns FALSE.
559  */
560 uint32_t Fvid2Utils_isQEmpty(Fvid2Utils_QHandle handle);
562 /**
563  *  Fvid2Utils_getNumQElem
564  *  \brief Returns the number of Queue Elements present in a Queue.
565  *
566  *  \param handle           Queue handle.
567  *
568  *  \return                 Number of Queue Elements present in a Queue.
569  */
570 uint32_t Fvid2Utils_getNumQElem(Fvid2Utils_QHandle handle);
572 /**
573  *  Fvid2Utils_floor
574  *  \brief Floor a integer value.
575  *
576  *  \param val          [IN] Integer to floor.
577  *  \param align        [IN] Alignment.
578  *
579  *  \return Returns the floored integer.
580  */
581 static inline uint32_t Fvid2Utils_floor(uint32_t val, uint32_t align);
583 /**
584  *  Fvid2Utils_align
585  *  \brief Align a integer value.
586  *
587  *  \param val          [IN] Integer to align.
588  *  \param align        [IN] Alignment.
589  *
590  *  \return Returns the aligned integer.
591  */
592 static inline uint32_t Fvid2Utils_align(uint32_t val, uint32_t align);
594 /**
595  *  Fvid2Utils_initPool
596  *  \brief Initializes the pool object structure.
597  *
598  *  \param params           Pool parameters to be initialized.
599  *  \param mem              Pointer to the pool memory.
600  *  \param numElem          Number of elements in the pool.
601  *  \param elemSize         Size of each element in bytes.
602  *  \param flag             Array of flag variable used by pool manager to
603  *                          indicate whether a pool element is allocated
604  *                          or not. The size of this array should be
605  *                          equal to the number of elements in this pool.
606  *  \param traceMask        Trace mask used in trace prints.
607  */
608 static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
609                                        void                  *mem,
610                                        uint32_t               numElem,
611                                        uint32_t               elemSize,
612                                        uint32_t              *flag,
613                                        uint32_t               traceMask);
615 /**
616  *  Fvid2Utils_alloc
617  *  \brief Allocates one element from the pool.
618  *
619  *  \param params           Pool parameters.
620  *  \param size             Size in bytes to allocate.
621  *  \param traceMask        Trace mask used in trace prints.
622  *
623  *  \return                 Returns memory pointer on success else returns
624  *                          NULL.
625  */
626 static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
627                                    uint32_t               size,
628                                    uint32_t               traceMask);
630 /**
631  *  Fvid2Utils_free
632  *  \brief Frees the element and returns to the pool.
633  *
634  *  \param params           Pool parameters.
635  *  \param mem              Memory pointer to deallocate.
636  *  \param traceMask        Trace mask used in trace prints.
637  *
638  *  \return                 Returns 0 on success else returns error value.
639  */
640 static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
641                                       const void            *mem,
642                                       uint32_t               traceMask);
644 /**
645  *  Fvid2Utils_initTsPrfLog
646  *  \brief Initializes the structure. This should be called once before
647  *  calling any other performance functions.
648  *
649  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
650  *
651  */
652 static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
654 /**
655  *  Fvid2Utils_startTsPrfLog
656  *  \brief Log the start entry to the performance structure.
657  *
658  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
659  */
660 static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
662 /**
663  *  Fvid2Utils_endTsPrfLog
664  *  \brief Log the entry to the performance structure. This uses the previous
665  *  startTime stored when calling Fvid2Utils_startTsPrfLog() to calculate the
666  *  difference.
667  *
668  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
669  */
670 static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
672 //TODO
673 static inline uint64_t Osal_getTimestamp64(void);
675 /* ========================================================================== */
676 /*                       Static Function Definitions                          */
677 /* ========================================================================== */
679 static inline uint32_t Fvid2Utils_floor(uint32_t val, uint32_t align)
681     return ((uint32_t) ((val / align) * align));
684 static inline uint32_t Fvid2Utils_align(uint32_t val, uint32_t align)
686     return (Fvid2Utils_floor((uint32_t) (val + (align - 1U)), align));
689 static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
690                                        void                  *mem,
691                                        uint32_t               numElem,
692                                        uint32_t               elemSize,
693                                        uint32_t              *flag,
694                                        uint32_t               traceMask)
696     uint32_t cnt;
698     /* NULL pointer check */
699     GT_assert(traceMask, (NULL != params));
700     GT_assert(traceMask, (NULL != mem));
701     GT_assert(traceMask, (NULL != flag));
703     /* Init pool parameters */
704     params->mem         = mem;
705     params->numElem     = numElem;
706     params->elemSize    = elemSize;
707     params->flag        = flag;
708     params->numFreeElem = numElem;
710     /* Set pool flags as free */
711     for (cnt = 0U; cnt < params->numElem; cnt++)
712     {
713         params->flag[cnt] = (uint32_t) FALSE;
714     }
716     return;
719 static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
720                                      uint32_t               size,
721                                      uint32_t               traceMask)
723     uint32_t cnt;
724     uintptr_t cookie;
725     uint32_t tempVal;
726     void  *allocMem = NULL;
728     /* NULL pointer check */
729     GT_assert(traceMask, (NULL != params));
730     /* Check if the requested size if within each fixed size element */
731     GT_assert(traceMask, (size <= params->elemSize));
732     GT_assert(traceMask, (0U != size));
734     /* Disable global interrupts */
735     cookie = HwiP_disable();
737     for (cnt = 0U; cnt < params->numElem; cnt++)
738     {
739         if ((uint32_t) FALSE == params->flag[cnt])
740         {
741             tempVal = ((uint32_t) params->mem) + (params->elemSize * cnt);
742             allocMem          = (void *) (tempVal);
743             params->flag[cnt] = (uint32_t) TRUE;
745             /* Decrement free count.
746              * Assert if it is zero as it can never happen. */
747             GT_assert(traceMask, (0U != params->numFreeElem));
748             params->numFreeElem--;
749             break;
750         }
751     }
753     /* Restore global interrupts */
754     HwiP_restore(cookie);
756     return (allocMem);
759 static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
760                                       const void            *mem,
761                                       uint32_t               traceMask)
763     uint32_t cnt;
764     uint32_t tempVal;
765     int32_t  retVal = FVID2_EFAIL;
766     uintptr_t cookie;
768     /* NULL pointer check */
769     GT_assert(traceMask, (NULL != params));
770     GT_assert(traceMask, (NULL != mem));
772     /* Disable global interrupts */
773     cookie = HwiP_disable();
775     for (cnt = 0U; cnt < params->numElem; cnt++)
776     {
777         tempVal = ((uint32_t) params->mem) + (params->elemSize * cnt);
778         if ((void *) (tempVal) == mem)
779         {
780             /* Check if the memory is already allocated */
781             GT_assert(traceMask, ((uint32_t) TRUE == params->flag[cnt]));
782             params->flag[cnt] = (uint32_t) FALSE;
784             /* Increment free count.
785              * Assert if it is more than num elements as it can never happen. */
786             params->numFreeElem++;
787             GT_assert(traceMask, (params->numFreeElem <= params->numElem));
789             retVal = FVID2_SOK;
790             break;
791         }
792     }
794     /* Restore global interrupts */
795     HwiP_restore(cookie);
797     return (retVal);
800 static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
802     /* NULL pointer check */
803     GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
805     Fvid2Utils_memset(tsPrf, 0, sizeof (Fvid2Utils_TsPrfLog));
806     /* Min can't be init to 0, set a higher value so that actual min gets
807      * registered */
808     tsPrf->min = 0xFFFFFFFFU;
810     return;
813 static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
815     /* NULL pointer check */
816     GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
818     tsPrf->startTime = Osal_getTimestamp64();
820     return;
823 static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
825     uint64_t endTime, diff;
827     /* NULL pointer check */
828     GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
830     endTime = Osal_getTimestamp64();
831     diff    = endTime - tsPrf->startTime;
833     /* Log the difference */
834     tsPrf->total += diff;
835     tsPrf->totalCnt++;
836     if (diff < tsPrf->min)
837     {
838         tsPrf->min = diff;
839     }
840     if (diff > tsPrf->max)
841     {
842         tsPrf->max = diff;
843     }
844     if (tsPrf->prfLogIndex >= FVID2UTILS_NUM_TIMESTAMP_LOG)
845     {
846         tsPrf->prfLogIndex = 0U;
847     }
848     tsPrf->prfLog[tsPrf->prfLogIndex] = diff;
849     tsPrf->prfLogIndex++;
851     return;
854 static inline uint64_t Osal_getTimestamp64(void)
856     //TODO: Call OSAL API once implementation is done
857     return (0U);
860 #ifdef __cplusplus
862 #endif
864 #endif /* #ifndef FVID2_UTILS_H_ */