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  */
  32
  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  */
  41
  42 #ifndef FVID2_UTILS_H_
  43 #define FVID2_UTILS_H_
  44
  45 /* ========================================================================== */
  46 /*                             Include Files                                  */
  47 /* ========================================================================== */
  48
  49 #include <ti/csl/csl_types.h>
  50 #include <ti/osal/osal.h>
  51
  52 #ifdef __cplusplus
  53 extern "C" {
  54 #endif
  55
  56 /* ========================================================================== */
  57 /*                           Macros & Typedefs                                */
  58 /* ========================================================================== */
  59
  60 /** \brief Number of timestamps. */
  61 #define FVID2UTILS_NUM_TIMESTAMP_LOG    (100U)
  62
  63 /**
  64  *  \anchor Fvid2Utils_LinkListType
  65  *  \name Link List Type
  66  *  @{
  67  */
  68 /**
  69  *  \brief Enums for the type of link list to be created.
  70  */
  71 typedef uint32_t Fvid2Utils_LinkListType;
  72 #define FVID2UTILS_LLT_DOUBLE           (0U)
  73 /**< Double link list. */
  74 #define FVID2UTILS_LLT_CIRCULAR         (1U)
  75 /**< Circular link list using double link list. */
  76 /* @} */
  77
  78 /**
  79  *  \anchor Fvid2Utils_LinkAddMode
  80  *  \name Link Add Mode
  81  *  @{
  82  */
  83 /**
  84  *  \brief Enums for the different modes of adding a node to a link list.
  85  */
  86 typedef uint32_t Fvid2Utils_LinkAddMode;
  87 #define FVID2UTILS_LAM_TOP              (0U)
  88 /**< Add nodes to the top of the list. */
  89 #define FVID2UTILS_LAM_BOTTOM           (1U)
  90 /**< Add nodes to the bottom of the list. */
  91 #define FVID2UTILS_LAM_PRIORITY         (2U)
  92 /**< Add nodes to the list based on ascending order of priority.
  93  *   Nodes with the same priority are always added to the bottom of the
  94  *   existing nodes with same priority. */
  95 /* @} */
  96
  97 /**
  98  *  \anchor Fvid2Utils_NodDir
  99  *  \name Node Direction
 100  *  @{
 101  */
 102 /**
 103  *  \brief Enums for the different modes of adding a node to a link list.
 104  */
 105 typedef uint32_t Fvid2Utils_NodDir;
 106 #define FVID2UTILS_NODE_DIR_HEAD        (0U)
 107 /**< Add nodes to the top of the list. */
 108 #define FVID2UTILS_NODE_DIR_TAIL        (1U)
 109 /**< Add nodes to the bottom of the list. */
 110 /* @} */
 111
 112 /* ========================================================================== */
 113 /*                         Structure Declarations                             */
 114 /* ========================================================================== */
 115
 116 /**< \brief Typedef for Node structure. */
 117 typedef struct Fvid2Utils_Node_t Fvid2Utils_Node;
 118
 119 /**
 120  *  struct Fvid2Utils_Node_t
 121  *  \brief Self referential structure for double link list.
 122  */
 123 struct Fvid2Utils_Node_t
 124 {
 125     Fvid2Utils_Node *next;
 126     /**< Pointer to the next node. */
 127     Fvid2Utils_Node *prev;
 128     /**< Pointer to the previous node. */
 129     void            *data;
 130     /**< Node data pointer. */
 131     uint32_t         priority;
 132     /**< Priority of the node. Used for priority based linked list. */
 133 };
 134
 135 /**
 136  *  struct Fvid2Utils_QElem
 137  *  \brief Typedef for Queue Node element.
 138  */
 139 typedef Fvid2Utils_Node Fvid2Utils_QElem;
 140
 141 /**
 142  *  struct Fvid2Utils_PoolParams
 143  *  \brief Create parameters for the fixed size pool.
 144  */
 145 typedef struct
 146 {
 147     void       *mem;
 148     /**< Pointer to the pool memory. */
 149     uint32_t    numElem;
 150     /**< Number of elements in the pool. */
 151     uint32_t    elemSize;
 152     /**< Size of each element in bytes. */
 153     uint32_t   *flag;
 154     /**< Array of flag variable used by pool manager to indicate whether a pool
 155      *   element is allocated or not. The size of this array should be
 156      *   equal to the number of elements in this pool. */
 157     uint32_t    numFreeElem;
 158     /**< Count to keep track of the number of free elements in the pool. */
 159 } Fvid2Utils_PoolParams;
 160
 161 /**
 162  *  struct Fvid2Utils_TsPrfLog
 163  *  \brief Timestamp Performance log structure in OSAL timestamp ticks.
 164  */
 165 typedef struct
 166 {
 167     uint64_t startTime;
 168     /**< Start time - updated in start function. */
 169     uint64_t total;
 170     /**< Total duration of all log entires.
 171      *   To get average divide by totalCnt. */
 172     uint32_t totalCnt;
 173     /**< Total number of log entires. */
 174     uint64_t min;
 175     /**< Minimum duration. */
 176     uint64_t max;
 177     /**< Maximum duration. */
 178     uint32_t prfLogIndex;
 179     /**< Current index. This will wrap around every FVID2UTILS_NUM_TIMESTAMP_LOG
 180      *   count. */
 181     uint64_t prfLog[FVID2UTILS_NUM_TIMESTAMP_LOG];
 182     /**< History of the past FVID2UTILS_NUM_TIMESTAMP_LOG entires. */
 183 } Fvid2Utils_TsPrfLog;
 184
 185 /**
 186  *  struct Fvid2UtilsLinkListObj
 187  *  \brief Structure to the link list object information.
 188  */
 189 typedef struct
 190 {
 191     Fvid2Utils_LinkListType listType;
 192     /**< Type of linked list. */
 193     Fvid2Utils_LinkAddMode  addMode;
 194     /**< Mode of adding a node to a link list. */
 195     Fvid2Utils_Node        *headNode;
 196     /**< Head Node. */
 197     Fvid2Utils_Node        *tailNode;
 198     /**< Tail Node Node. */
 199     uint32_t                numElements;
 200     /**< Number of elements in the linked list. */
 201     uint32_t                priorityCnt;
 202     /**< Priority count of the linked list. */
 203 } Fvid2UtilsLinkListObj;
 204
 205 /**
 206  *  struct Fvid2Utils_Handle
 207  *  \brief Typedef for FVID2 Utils handle.
 208  */
 209 typedef Fvid2UtilsLinkListObj *Fvid2Utils_Handle;
 210
 211 /**
 212  *  struct Fvid2Utils_QHandle
 213  *  \brief Typedef for FVID2 Utils Queue Handle.
 214  */
 215 typedef Fvid2Utils_Handle Fvid2Utils_QHandle;
 216
 217 /* ========================================================================== */
 218 /*                          Function Declarations                             */
 219 /* ========================================================================== */
 220 /**
 221  *  Fvid2Utils_init
 222  *  \brief Initializes the Util objects and create pool semaphore
 223  *
 224  *  \returns                Returns 0 on success else returns error value
 225  */
 226 int32_t Fvid2Utils_init(void);
 227
 228 /**
 229  *  Fvid2Utils_deInit
 230  *  \brief De-Initializes the Util objects by removing pool semaphore
 231  *
 232  *  \param arg              Not used currently. Meant for future purpose
 233  *
 234  *  \return                 Returns 0 on success else returns error value
 235  */
 236 int32_t Fvid2Utils_deInit(void *arg);
 237
 238 /**
 239  *  Fvid2Utils_memset
 240  *  \brief Sets the memory with the given value. Access memory as byte.
 241  *  Returns the memory pointer.
 242  *
 243  *  \param mem              Destination memory pointer.
 244  *  \param ch               Byte value to fill with.
 245  *  \param byteCount        Number of bytes to fill.
 246  *
 247  *  \return                 None.
 248  */
 249 void Fvid2Utils_memset(void *mem, uint8_t ch, size_t byteCount);
 250
 251 /**
 252  *  Fvid2Utils_memsetw
 253  *  \brief Sets the memory with the given value. Access memory as word.
 254  *  Hence memory pointer should be aligned to 4 byte boundary
 255  *  Returns the memory pointer.
 256  *
 257  *  \param mem              Destination memory pointer.
 258  *  \param word             Word value to fill with.
 259  *  \param wordCount        Number of words to fill.
 260  *
 261  *  \return                 The destination memory pointer.
 262  */
 263 void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount);
 264
 265 /**
 266  *  Fvid2Utils_memcpy
 267  *  \brief Copies source memory into destination memory. Access memory as byte.
 268  *  Returns the destination memory pointer.
 269  *
 270  *  \param dest             Destination memory pointer.
 271  *  \param src              Source memory pointer.
 272  *  \param byteCount        Number of bytes to copy.
 273  *
 274  *  \return                 None
 275  */
 276 void Fvid2Utils_memcpy(void *dest, const void *src, size_t byteCount);
 277
 278 /**
 279  *  Fvid2Utils_memcmp
 280  *  \brief Compare memory block 1 with memory block 2. Access memory as byte.
 281  *  Returns 0 if two memories are  identical.
 282  *
 283  *  \param mem1             memory block 1
 284  *  \param mem2              memory block 2
 285  *  \param byteCount        Number of bytes to compare
 286  *
 287  *  \return                 0 if two memory are identical other return 1
 288  */
 289 int32_t Fvid2Utils_memcmp(const void *mem1,
 290                           const void *mem2,
 291                           uint32_t byteCount);
 292
 293 /**
 294  *  Fvid2Utils_constructLinkList
 295  *  \brief Constructs a link list object with the provided properties.
 296  *
 297  *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
 298  *  \param listType         List type - circular/double link list.
 299  *  \param addMode          Node addition mode - Top/Bottom/Priority based.
 300  *
 301  *  \return                 Returns FVID2_SOK on success else returns error
 302  *                          value.
 303  */
 304 int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
 305                                      Fvid2Utils_LinkListType listType,
 306                                      Fvid2Utils_LinkAddMode  addMode);
 307
 308 /**
 309  *  Fvid2Utils_destructLinkList
 310  *  \brief Destructs a link list object.
 311  *
 312  *  \param llobj pointer to object of type Fvid2UtilsLinkListObj
 313  *
 314  *  \return                 None
 315  */
 316 void Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj);
 317
 318 /**
 319  *  Fvid2Utils_linkNodePri
 320  *  \brief Links a node to the linked list according to the list type
 321  *  The memory to the node object should be allocated by the caller. This
 322  *  is used for link list with priority.
 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 void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
 337                             Fvid2Utils_Node  *node,
 338                             uint32_t          priority);
 339
 340 /**
 341  *  Fvid2Utils_linkUniqePriNode
 342  *  \brief Very similar to Fvid2Utils_linkNode, except that on equal priority
 343  *          nodes will not be inserted. An error (FVID2_EBADARGS) would be
 344  *          returned.
 345  *          Applicable for double linked list only.
 346  *  ToDo Update to handle circular list also.
 347  *
 348  *  \param handle           Link list handle.
 349  *  \param node             Node object pointer used for linking.
 350  *  \param priority         Priority of the node used for priority based
 351  *                          addition of nodes. Priority is in descending order
 352  *                          the value. So 0 is the highest priority and is
 353  *                          added to the top of the node.
 354  *                          Nodes with the same priority are always added to
 355  *                          the bottom of the existing nodes with same
 356  *                          priority.
 357  *                          For non-priority based modes, this parameter
 358  *                          is ignored and could be set to 0.
 359  */
 360 int32_t Fvid2Utils_linkUniqePriNode(Fvid2Utils_Handle handle,
 361                                     Fvid2Utils_Node  *node,
 362                                     uint32_t          priority);
 363
 364 /**
 365  *  Fvid2Utils_unLinkAllNodes
 366  *  \brief Releases all nodes without modifying any of the property.
 367  *         CAUTION - Memory is NOT de-allocated, its the responsibility of the
 368  *                   caller to ensure de-allocation of memory.
 369  *
 370  *  \param handle           Link list handle.
 371  *
 372  *  \return                 Returns 0 on success else returns error value.
 373  */
 374 int32_t Fvid2Utils_unLinkAllNodes(Fvid2Utils_Handle handle);
 375
 376 /**
 377  *  Fvid2Utils_unLinkNodePri
 378  *  \brief Unlinks the node from the list. Used for the Priority linklists.
 379  *
 380  *  \param handle           Link list handle.
 381  *  \param node             Node pointer to be unlinked from the list.
 382  */
 383 void Fvid2Utils_unLinkNodePri(Fvid2Utils_Handle handle, Fvid2Utils_Node *node);
 384
 385 /**
 386  *  Fvid2Utils_unLinkNode
 387  *  \brief Unlinks the node from the list. Used for Non-priority linked lists
 388  *
 389  *  \param handle           Link list handle.
 390  *  \param node             Node pointer to be unlinked from the list.
 391  */
 392 void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle,
 393                            const Fvid2Utils_Node *node);
 394
 395 /**
 396  *  Fvid2Utils_linkNodeToHead
 397  *  \brief                  Link the node to the head of the double linked list.
 398  *                          No priority
 399  *
 400  *  \param handle           Link list handle.
 401  *  \param node             Node object pointer used for linking.
 402  *
 403  */
 404 void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle,
 405                                Fvid2Utils_Node  *node);
 406
 407 /**
 408  *  Fvid2Utils_linkNodeToTail
 409  *  \brief                  Link the node to the tail of the double linked list.
 410  *                          No priority
 411  *
 412  *  \param handle           Link list handle.
 413  *  \param node             Node object pointer used for linking.
 414  */
 415 void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle,
 416                              Fvid2Utils_Node  *node);
 417
 418 /**
 419  *  Fvid2Utils_unLinkNodeFromHead
 420  *  \brief                  Returns the node from head. Removes the  node from
 421  *                          the list.
 422  *
 423  *  \param handle           Link list handle.
 424  *  \return                 Pointer to unlinked node.
 425  *
 426  */
 427 Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromHead(Fvid2Utils_Handle handle);
 428
 429 /**
 430  *  Fvid2Utils_unLinkNodeFromTail
 431  *  \brief                  Returns the node from tail. Removes the  node from
 432  *                          the list.
 433  *
 434  *  \param handle           Link list handle.
 435  *  \return                 Pointer to unlinked node.
 436  *
 437  */
 438 Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromTail(Fvid2Utils_Handle handle);
 439
 440 /**
 441  *  Fvid2Utils_getHeadNode
 442  *  \brief                  Returns the reference to the headNode. Does
 443  *                          not remove the node from the head.
 444  *
 445  *  \param handle           Link list handle.
 446  */
 447 Fvid2Utils_Node *Fvid2Utils_getHeadNode(Fvid2Utils_Handle handle);
 448
 449 /**
 450  *  Fvid2Utils_getTailNode
 451  *  \brief                  Returns the reference to the TailNode. Does
 452  *                          not remove the node from the head.
 453  *
 454  *  \param handle           Link list handle.
 455  *  \return                 Reference  to tail node.  Acutally  node is not
 456  *                          unlinked from list.
 457  *
 458  */
 459 Fvid2Utils_Node *Fvid2Utils_getTailNode(Fvid2Utils_Handle handle);
 460
 461 /**
 462  *  Fvid2Utils_isListEmpty
 463  *  \brief Checks whether a list is empty or not.
 464  *
 465  *  \param handle           List handle.
 466  *
 467  *  \return                 TRUE if List is empty else returns FALSE.
 468  */
 469 uint32_t Fvid2Utils_isListEmpty(Fvid2Utils_Handle handle);
 470
 471 /**
 472  *  Fvid2Utils_getNumNodes
 473  *  \brief Returns the number of nodes present in a list.
 474  *
 475  *  \param handle           List handle.
 476  *
 477  *  \return                 Number of nodes present in a list.
 478  */
 479 uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle);
 480
 481 /**
 482  *  Fvid2Utils_getNodeCnt
 483  *  \brief Returns the number of nodes in the link list
 484  *
 485  *  \param handle           Link list handle.
 486  *
 487  *
 488  *  \return                 Returns the number of nodes in the list.
 489  */
 490 uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle);
 491
 492 /**
 493  *  Fvid2Utils_constructQ
 494  *  \brief Constructs a Queue object.
 495  *
 496  * \param llobj pointer to object of type Fvid2UtilsLinkListObj
 497  *
 498  *  \return                 Returns FVID2_SOK on success else returns error value.
 499  */
 500 int32_t Fvid2Utils_constructQ(Fvid2UtilsLinkListObj *llobj);
 501
 502 /**
 503  *  Fvid2Utils_destructQ
 504  *  \brief Destructs a Queue object.
 505  *
 506  * \param llobj pointer to object of type Fvid2UtilsLinkListObj
 507  *
 508  *  \return                 None
 509  */
 510 void Fvid2Utils_destructQ(Fvid2UtilsLinkListObj *llobj);
 511
 512 /**
 513  *  Fvid2Utils_queue
 514  *  \brief Adds the data to the queue.
 515  *  The memory to the node object should be allocated by the caller.
 516  *
 517  *  \param handle           Queue handle.
 518  *  \param qElem            Queue Element object pointer used for linking.
 519  *  \param data             Data pointer to be added to the list.
 520  *                          This should be unique.
 521  */
 522 void Fvid2Utils_queue(Fvid2Utils_QHandle handle,
 523                       Fvid2Utils_QElem  *qElem,
 524                       void              *data);
 525
 526 /**
 527  *  Fvid2Utils_dequeue
 528  *  \brief Removes a element from the queue.
 529  *
 530  *  \param handle           Queue handle.
 531  *
 532  *  \return                 Returns the removed data pointer.
 533  */
 534 void *Fvid2Utils_dequeue(Fvid2Utils_QHandle handle);
 535
 536 /**
 537  *  Fvid2Utils_peakHead
 538  *  \brief Returns the reference of the first queued element.
 539  *
 540  *  This doesn't remove the element from the queue.
 541  *  If the queue is empty, then this returns NULL.
 542  *
 543  *  \param handle           Queue handle.
 544  *
 545  *  \return                 Returns the reference of the first element.
 546  */
 547 void *Fvid2Utils_peakHead(Fvid2Utils_QHandle handle);
 548
 549 /**
 550  *  Fvid2Utils_peakTail
 551  *  \brief Returns the reference of the last queued element.
 552  *
 553  *  This doesn't remove the element from the queue.
 554  *  If the queue is empty, then this returns NULL.
 555  *
 556  *  \param handle           Queue handle.
 557  *
 558  *  \return                 Returns the reference of the last queued element.
 559  */
 560 void *Fvid2Utils_peakTail(Fvid2Utils_QHandle handle);
 561
 562 /**
 563  *  Fvid2Utils_queueBack
 564  *  \brief Adds the data to start of the queue.
 565  *  The memory to the node object should be allocated by the caller.
 566  *
 567  *  \param handle           Queue handle.
 568  *  \param qElem            Queue Element object pointer used for linking.
 569  *  \param data             Data pointer to be added to the list.
 570  *                          This should be unique.
 571  */
 572 void Fvid2Utils_queueBack(Fvid2Utils_QHandle handle,
 573                           Fvid2Utils_QElem  *qElem,
 574                           void              *data);
 575
 576 /**
 577  *  Fvid2Utils_isQEmpty
 578  *  \brief Checks whether a queue is empty or not.
 579  *
 580  *  \param handle           Queue handle.
 581  *
 582  *  \return                 TRUE if queue is empty else returns FALSE.
 583  */
 584 uint32_t Fvid2Utils_isQEmpty(Fvid2Utils_QHandle handle);
 585
 586 /**
 587  *  Fvid2Utils_getNumQElem
 588  *  \brief Returns the number of Queue Elements present in a Queue.
 589  *
 590  *  \param handle           Queue handle.
 591  *
 592  *  \return                 Number of Queue Elements present in a Queue.
 593  */
 594 uint32_t Fvid2Utils_getNumQElem(Fvid2Utils_QHandle handle);
 595
 596 /**
 597  *  Fvid2Utils_floor
 598  *  \brief Floor a integer value.
 599  *
 600  *  \param val          [IN] Integer to floor.
 601  *  \param align        [IN] Alignment.
 602  *
 603  *  \return Returns the floored integer.
 604  */
 605 static inline uint32_t Fvid2Utils_floor(uint32_t val, uint32_t align);
 606
 607 /**
 608  *  Fvid2Utils_align
 609  *  \brief Align a integer value.
 610  *
 611  *  \param val          [IN] Integer to align.
 612  *  \param align        [IN] Alignment.
 613  *
 614  *  \return Returns the aligned integer.
 615  */
 616 static inline uint32_t Fvid2Utils_align(uint32_t val, uint32_t align);
 617
 618 /**
 619  *  Fvid2Utils_initPool
 620  *  \brief Initializes the pool object structure.
 621  *
 622  *  \param params           Pool parameters to be initialized.
 623  *  \param mem              Pointer to the pool memory.
 624  *  \param numElem          Number of elements in the pool.
 625  *  \param elemSize         Size of each element in bytes.
 626  *  \param flag             Array of flag variable used by pool manager to
 627  *                          indicate whether a pool element is allocated
 628  *                          or not. The size of this array should be
 629  *                          equal to the number of elements in this pool.
 630  *  \param traceMask        Trace mask used in trace prints.
 631  */
 632 static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
 633                                        void                  *mem,
 634                                        uint32_t               numElem,
 635                                        uint32_t               elemSize,
 636                                        uint32_t              *flag,
 637                                        uint32_t               traceMask);
 638
 639 /**
 640  *  Fvid2Utils_alloc
 641  *  \brief Allocates one element from the pool.
 642  *
 643  *  \param params           Pool parameters.
 644  *  \param size             Size in bytes to allocate.
 645  *  \param traceMask        Trace mask used in trace prints.
 646  *
 647  *  \return                 Returns memory pointer on success else returns
 648  *                          NULL.
 649  */
 650 static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
 651                                    uint32_t               size,
 652                                    uint32_t               traceMask);
 653
 654 /**
 655  *  Fvid2Utils_free
 656  *  \brief Frees the element and returns to the pool.
 657  *
 658  *  \param params           Pool parameters.
 659  *  \param mem              Memory pointer to deallocate.
 660  *  \param traceMask        Trace mask used in trace prints.
 661  *
 662  *  \return                 Returns 0 on success else returns error value.
 663  */
 664 static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
 665                                       const void            *mem,
 666                                       uint32_t               traceMask);
 667
 668 /**
 669  *  Fvid2Utils_initTsPrfLog
 670  *  \brief Initializes the structure. This should be called once before
 671  *  calling any other performance functions.
 672  *
 673  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
 674  *
 675  */
 676 static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
 677
 678 /**
 679  *  Fvid2Utils_startTsPrfLog
 680  *  \brief Log the start entry to the performance structure.
 681  *
 682  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
 683  */
 684 static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
 685
 686 /**
 687  *  Fvid2Utils_endTsPrfLog
 688  *  \brief Log the entry to the performance structure. This uses the previous
 689  *  startTime stored when calling Fvid2Utils_startTsPrfLog() to calculate the
 690  *  difference.
 691  *
 692  *  \param tsPrf            Pointer to Fvid2Utils_TsPrfLog structure.
 693  */
 694 static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf);
 695
 696 /**
 697  *  Osal_getTimestamp64
 698  *  \brief This API gets the 64 bit time stamp.
 699  */
 700 static inline uint64_t Osal_getTimestamp64(void);
 701
 702 /* ========================================================================== */
 703 /*                       Static Function Definitions                          */
 704 /* ========================================================================== */
 705
 706 static inline uint32_t Fvid2Utils_floor(uint32_t val, uint32_t align)
 707 {
 708     return ((uint32_t) ((val / align) * align));
 709 }
 710
 711 static inline uint32_t Fvid2Utils_align(uint32_t val, uint32_t align)
 712 {
 713     return (Fvid2Utils_floor((uint32_t) (val + (align - 1U)), align));
 714 }
 715
 716 static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
 717                                        void                  *mem,
 718                                        uint32_t               numElem,
 719                                        uint32_t               elemSize,
 720                                        uint32_t              *flag,
 721                                        uint32_t               traceMask)
 722 {
 723     uint32_t cnt;
 724
 725     /* NULL pointer check */
 726     GT_assert(traceMask, (NULL_PTR != params));
 727     GT_assert(traceMask, (NULL_PTR != mem));
 728     GT_assert(traceMask, (NULL_PTR != flag));
 729
 730     /* Init pool parameters */
 731     params->mem         = mem;
 732     params->numElem     = numElem;
 733     params->elemSize    = elemSize;
 734     params->flag        = flag;
 735     params->numFreeElem = numElem;
 736
 737     /* Set pool flags as free */
 738     for (cnt = 0U; cnt < params->numElem; cnt++)
 739     {
 740         params->flag[cnt] = (uint32_t) FALSE;
 741     }
 742
 743     return;
 744 }
 745
 746 static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
 747                                      uint32_t               size,
 748                                      uint32_t               traceMask)
 749 {
 750     uint32_t cnt;
 751     uintptr_t cookie;
 752     uintptr_t tempVal;
 753     void  *allocMem = NULL;
 754
 755     /* NULL pointer check */
 756     GT_assert(traceMask, (NULL_PTR != params));
 757     /* Check if the requested size if within each fixed size element */
 758     GT_assert(traceMask, (size <= params->elemSize));
 759     GT_assert(traceMask, (0U != size));
 760
 761     /* Disable global interrupts */
 762     cookie = HwiP_disable();
 763
 764     for (cnt = 0U; cnt < params->numElem; cnt++)
 765     {
 766         if ((uint32_t) FALSE == params->flag[cnt])
 767         {
 768             tempVal = ((uintptr_t) params->mem) + (((uintptr_t) params->elemSize) * ((uintptr_t) cnt));
 769             allocMem          = (void *) (tempVal);
 770             params->flag[cnt] = (uint32_t) TRUE;
 771
 772             /* Decrement free count.
 773              * Assert if it is zero as it can never happen. */
 774             GT_assert(traceMask, (0U != params->numFreeElem));
 775             params->numFreeElem--;
 776             break;
 777         }
 778     }
 779
 780     /* Restore global interrupts */
 781     HwiP_restore(cookie);
 782
 783     return (allocMem);
 784 }
 785
 786 static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
 787                                       const void            *mem,
 788                                       uint32_t               traceMask)
 789 {
 790     uint32_t cnt;
 791     uintptr_t tempVal;
 792     int32_t  retVal = FVID2_EFAIL;
 793     uintptr_t cookie;
 794
 795     /* NULL pointer check */
 796     GT_assert(traceMask, (NULL_PTR != params));
 797     GT_assert(traceMask, (NULL_PTR != mem));
 798
 799     /* Disable global interrupts */
 800     cookie = HwiP_disable();
 801
 802     for (cnt = 0U; cnt < params->numElem; cnt++)
 803     {
 804         tempVal = ((uintptr_t) params->mem) + (((uintptr_t)params->elemSize) * ((uintptr_t)cnt));
 805         if ((void *) (tempVal) == mem)
 806         {
 807             /* Check if the memory is already allocated */
 808             GT_assert(traceMask, ((uint32_t) TRUE == params->flag[cnt]));
 809             params->flag[cnt] = (uint32_t) FALSE;
 810
 811             /* Increment free count.
 812              * Assert if it is more than num elements as it can never happen. */
 813             params->numFreeElem++;
 814             GT_assert(traceMask, (params->numFreeElem <= params->numElem));
 815
 816             retVal = FVID2_SOK;
 817             break;
 818         }
 819     }
 820
 821     /* Restore global interrupts */
 822     HwiP_restore(cookie);
 823
 824     return (retVal);
 825 }
 826
 827 static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 828 {
 829     /* NULL pointer check */
 830     GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 831
 832     Fvid2Utils_memset(tsPrf, 0, sizeof (Fvid2Utils_TsPrfLog));
 833     /* Min can't be init to 0, set a higher value so that actual min gets
 834      * registered */
 835     tsPrf->min = 0xFFFFFFFFU;
 836
 837     return;
 838 }
 839
 840 static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 841 {
 842     /* NULL pointer check */
 843     GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 844
 845     tsPrf->startTime = Osal_getTimestamp64();
 846
 847     return;
 848 }
 849
 850 static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 851 {
 852     uint64_t endTime, diff;
 853
 854     /* NULL pointer check */
 855     GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 856
 857     endTime = Osal_getTimestamp64();
 858     diff    = endTime - tsPrf->startTime;
 859
 860     /* Log the difference */
 861     tsPrf->total += diff;
 862     tsPrf->totalCnt++;
 863     if (diff < tsPrf->min)
 864     {
 865         tsPrf->min = diff;
 866     }
 867     if (diff > tsPrf->max)
 868     {
 869         tsPrf->max = diff;
 870     }
 871     if (tsPrf->prfLogIndex >= FVID2UTILS_NUM_TIMESTAMP_LOG)
 872     {
 873         tsPrf->prfLogIndex = 0U;
 874     }
 875     tsPrf->prfLog[tsPrf->prfLogIndex] = diff;
 876     tsPrf->prfLogIndex++;
 877
 878     return;
 879 }
 880
 881 static inline uint64_t Osal_getTimestamp64(void)
 882 {
 883     //TODO: Call OSAL API once implementation is done
 884     return (0U);
 885 }
 886
 887 #ifdef __cplusplus
 888 }
 889 #endif
 890
 891 #endif /* #ifndef FVID2_UTILS_H_ */