src/fvid2_drvMgr.c

   1 /*
   2  *  Copyright (c) Texas Instruments Incorporated 2012-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_drvMgr.c
  35  *
  36  *  \brief FVID2 driver manager layer.
  37  *  This file implements driver management functionality.
  38  *
  39  */
  40
  41 /* ========================================================================== */
  42 /*                             Include Files                                  */
  43 /* ========================================================================== */
  44
  45 #include <fvid2_drvMgr.h>
  46 #include <ti/osal/osal.h>
  47 /* This is needed for memset/memcpy */
  48 #include <string.h>
  49
  50 /* ========================================================================== */
  51 /*                           Macros & Typedefs                                */
  52 /* ========================================================================== */
  53
  54 /** \brief Number of entries in FVID2 standard info table. */
  55 #define FDM_NUM_STD_INFO_ENTRIES        (sizeof (gFdmStdInfoTable) / \
  56                                          sizeof (Fvid2_ModeInfo))
  57
  58 /** \brief Number of entries in FVID2 standard info table. */
  59 #define FDM_NUM_DATA_FMT_STR_ENTRIES    (sizeof (gFdmDataFmtStrTable) / \
  60                                          sizeof (Fdm_DataFmtString))
  61
  62 /** \brief Number of entries in FVID2 standard info table. */
  63 #define FDM_NUM_STD_STR_ENTRIES         (sizeof (gFdmStdStrTable) / \
  64                                          sizeof (Fdm_StdString))
  65
  66 /* ========================================================================== */
  67 /*                         Structure Declarations                             */
  68 /* ========================================================================== */
  69
  70 /**
  71  *  struct Fdm_Driver
  72  *  \brief Structure to store driver information.
  73  */
  74 typedef struct
  75 {
  76     const Fvid2_DrvOps *drvOps;
  77     /**< Driver operation table pointer. */
  78     uint32_t            numOpens;
  79     /**< Number of times the driver is opened using create API. */
  80     uint32_t            isUsed;
  81     /**< Flag indicating whether the object is used or not. */
  82 } Fdm_Driver;
  83
  84 /**
  85  *  struct Fdm_Channel
  86  *  \brief Structure to store channel information.
  87  */
  88 typedef struct
  89 {
  90     Fdm_Driver         *drv;
  91     /**< Pointer to the driver object to which this channel is created. */
  92     Fdrv_Handle         drvHandle;
  93     /**< Driver handle returned by the actual driver. */
  94     Fvid2_CbParams      cbParams;
  95     /**< Application call back parameters. */
  96     uint32_t            isUsed;
  97     /**< Flag indicating whether the object is used or not. */
  98 } Fdm_Channel;
  99
 100 /**
 101  *  struct Fdm_DataFmtString
 102  *  \brief Structure to store data format and string pair.
 103  */
 104 typedef struct
 105 {
 106     Fvid2_DataFormat    dataFmt;
 107     /**< Data format. */
 108     const char         *dataFmtStr;
 109     /**< Pointer to data format string. */
 110 } Fdm_DataFmtString;
 111
 112 /**
 113  *  struct Fdm_StdString
 114  *  \brief Structure to store standard and string pair.
 115  */
 116 typedef struct
 117 {
 118     Fvid2_Standard      standard;
 119     /**< Standard. */
 120     const char         *stdStr;
 121     /**< Pointer to data format string. */
 122 } Fdm_StdString;
 123
 124 /**
 125  *  struct Fdm_Object
 126  *  \brief Struture to store all global objects.
 127  */
 128 typedef struct
 129 {
 130     char               *versionString;
 131     /**< FVID2 drivers version number as string. */
 132     uint32_t            versionNumber;
 133     /**< FVID2 drivers version number as string. */
 134     Fdm_Driver          fdmDriverObjects[FVID2_CFG_FDM_NUM_DRV_OBJS];
 135     /**< FDM Driver objects. */
 136     Fdm_Channel         fdmChannelObjects[FVID2_CFG_FDM_NUM_CH_OBJS];
 137     /**< FDM Channel objects. */
 138     SemaphoreP_Handle   lockSem;
 139     /**< Semaphore to protect function calls and other memory allocation. */
 140 } Fdm_Object;
 141
 142 /* ========================================================================== */
 143 /*                          Function Declarations                             */
 144 /* ========================================================================== */
 145 /**
 146  *  Below ifdef __cplusplus is added so that C++ build passes without
 147  *  typecasting. This is because the prototype is build as C type
 148  *  whereas this file is build as CPP file. Hence we get C++ build error.
 149  *  Also if tyecasting is used, then we get MisraC error Rule 11.1.
 150  */
 151 #ifdef __cplusplus
 152 extern "C" {
 153 #endif
 154 static int32_t fdmDriverCbFxn(void *fdmData);
 155 static int32_t fdmDriverErrCbFxn(void *fdmData, void *errList);
 156 static Fdm_Driver *fdmAllocDriverObject(void);
 157 static int32_t fdmFreeDriverObject(const Fvid2_DrvOps *drvOps);
 158 static Fdm_Channel *fdmAllocChannelObject(void);
 159 static int32_t fdmFreeChannelObject(Fdm_Channel *channel);
 160 static void Fvid2_printf(const char *format, ...);
 161 static void Fvid2_memset(void *mem, int32_t ch, uint32_t byteCount);
 162 static void Fvid2_memcpy(void *dest, const void *src, uint32_t byteCount);
 163 #ifdef __cplusplus
 164 }
 165 #endif
 166
 167 /* ========================================================================== */
 168 /*                            Global Variables                                */
 169 /* ========================================================================== */
 170
 171 /** \brief FDM objects. */
 172 static Fdm_Object        gFdmObj;
 173
 174 /** \brief FVID2 standard information table. */
 175 static Fvid2_ModeInfo    gFdmStdInfoTable[] =
 176 {
 177     /* Standard, FrameWidth, FrameHeight, ScanFormat, PixelClock (KHz), FPS */
 178     {FVID2_STD_NTSC,           720U,  480U,  FVID2_SF_INTERLACED, 27000U,   30U,
 179      0U, 0U, 0U, 0U, 0U, 0U},
 180     {FVID2_STD_PAL,            720U,  576U,  FVID2_SF_INTERLACED, 27000U,   25U,
 181      0U, 0U, 0U, 0U, 0U, 0U},
 182     {FVID2_STD_480I,           720U,  480U,  FVID2_SF_INTERLACED, 27000U,   30U,
 183      0U, 0U, 0U, 0U, 0U, 0U},
 184     {FVID2_STD_576I,           720U,  576U,  FVID2_SF_INTERLACED, 27000U,   25U,
 185      0U, 0U, 0U, 0U, 0U, 0U},
 186     {FVID2_STD_480P,           720U,  480U,  FVID2_SF_PROGRESSIVE,27000U,   60U,
 187      0U, 0U, 0U, 0U, 0U, 0U},
 188     {FVID2_STD_576P,           720U,  576U,  FVID2_SF_PROGRESSIVE,27000U,   50U,
 189      0U, 0U, 0U, 0U, 0U, 0U},
 190     {FVID2_STD_720P_60,        1280U, 720U,  FVID2_SF_PROGRESSIVE,74250U,   60U,
 191      0U, 0U, 0U, 0U, 0U, 0U},
 192     {FVID2_STD_720P_50,        1280U, 720U,  FVID2_SF_PROGRESSIVE,74250U,   50U,
 193      0U, 0U, 0U, 0U, 0U, 0U},
 194     {FVID2_STD_1080I_60,       1920U, 1080U, FVID2_SF_INTERLACED, 74250U,   30U,
 195      0U, 0U, 0U, 0U, 0U, 0U},
 196     {FVID2_STD_1080I_50,       1920U, 1080U, FVID2_SF_INTERLACED, 74250U,   25U,
 197      0U, 0U, 0U, 0U, 0U, 0U},
 198     {FVID2_STD_1080P_60,       1920U, 1080U, FVID2_SF_PROGRESSIVE,148500U,  60U,
 199      0U, 0U, 0U, 0U, 0U, 0U},
 200     {FVID2_STD_1080P_50,       1920U, 1080U, FVID2_SF_PROGRESSIVE,148500U,  50U,
 201      0U, 0U, 0U, 0U, 0U, 0U},
 202     {FVID2_STD_1080P_24,       1920U, 1080U, FVID2_SF_PROGRESSIVE,74250U,   24U,
 203      0U, 0U, 0U, 0U, 0U, 0U},
 204     {FVID2_STD_1080P_30,       1920U, 1080U, FVID2_SF_PROGRESSIVE,74250U,   30U,
 205      0U, 0U, 0U, 0U, 0U, 0U},
 206     {FVID2_STD_VGA_60,         640U,  480U,  FVID2_SF_PROGRESSIVE,25175U,   60U,
 207      0U, 0U, 0U, 0U, 0U, 0U},
 208     {FVID2_STD_VGA_72,         640U,  480U,  FVID2_SF_PROGRESSIVE,31500U,   72U,
 209      0U, 0U, 0U, 0U, 0U, 0U},
 210     {FVID2_STD_VGA_75,         640U,  480U,  FVID2_SF_PROGRESSIVE,31500U,   75U,
 211      0U, 0U, 0U, 0U, 0U, 0U},
 212     {FVID2_STD_VGA_85,         640U,  480U,  FVID2_SF_PROGRESSIVE,36000U,   85U,
 213      0U, 0U, 0U, 0U, 0U, 0U},
 214     {FVID2_STD_WVGA_60,        800U,  480U,  FVID2_SF_PROGRESSIVE,33500U,   60U,
 215      0U, 0U, 0U, 0U, 0U, 0U},
 216     {FVID2_STD_SVGA_60,        800U,  600U,  FVID2_SF_PROGRESSIVE,40000U,   60U,
 217      0U, 0U, 0U, 0U, 0U, 0U},
 218     {FVID2_STD_SVGA_72,        800U,  600U,  FVID2_SF_PROGRESSIVE,50000U,   72U,
 219      0U, 0U, 0U, 0U, 0U, 0U},
 220     {FVID2_STD_SVGA_75,        800U,  600U,  FVID2_SF_PROGRESSIVE,49500U,   75U,
 221      0U, 0U, 0U, 0U, 0U, 0U},
 222     {FVID2_STD_SVGA_85,        800U,  600U,  FVID2_SF_PROGRESSIVE,56250U,   85U,
 223      0U, 0U, 0U, 0U, 0U, 0U},
 224     {FVID2_STD_WSVGA_70,       1024U, 600U,  FVID2_SF_PROGRESSIVE,50800U,   70U,
 225      0U, 0U, 0U, 0U, 0U, 0U},
 226     {FVID2_STD_XGA_60,         1024U, 768U,  FVID2_SF_PROGRESSIVE,65000U,   60U,
 227      0U, 0U, 0U, 0U, 0U, 0U},
 228     {FVID2_STD_XGA_DSS_TDM_60, 1024U, 768U,  FVID2_SF_PROGRESSIVE,64000U,   60U,
 229      0U, 0U, 0U, 0U, 0U, 0U},
 230     {FVID2_STD_XGA_70,         1024U, 768U,  FVID2_SF_PROGRESSIVE,75000U,   70U,
 231      0U, 0U, 0U, 0U, 0U, 0U},
 232     {FVID2_STD_XGA_75,         1024U, 768U,  FVID2_SF_PROGRESSIVE,78750U,   75U,
 233      0U, 0U, 0U, 0U, 0U, 0U},
 234     {FVID2_STD_XGA_85,         1024U, 768U,  FVID2_SF_PROGRESSIVE,94500U,   85U,
 235      0U, 0U, 0U, 0U, 0U, 0U},
 236     {FVID2_STD_WXGA_30,        1280U, 800U,  FVID2_SF_PROGRESSIVE,34125U,   30U,
 237      0U, 0U, 0U, 0U, 0U, 0U},
 238     {FVID2_STD_WXGA_60,        1280U, 800U,  FVID2_SF_PROGRESSIVE,83500U,   60U,
 239      0U, 0U, 0U, 0U, 0U, 0U},
 240     {FVID2_STD_WXGA_75,        1280U, 800U,  FVID2_SF_PROGRESSIVE,102250U,  75U,
 241      0U, 0U, 0U, 0U, 0U, 0U},
 242     {FVID2_STD_WXGA_85,        1280U, 800U,  FVID2_SF_PROGRESSIVE,117500U,  85U,
 243      0U, 0U, 0U, 0U, 0U, 0U},
 244     {FVID2_STD_1440_900_60,    1440U, 900U,  FVID2_SF_PROGRESSIVE,106500U,  60U,
 245      0U, 0U, 0U, 0U, 0U, 0U},
 246     {FVID2_STD_1368_768_60,    1368U, 768U,  FVID2_SF_PROGRESSIVE,85860U,   60U,
 247      0U, 0U, 0U, 0U, 0U, 0U},
 248     {FVID2_STD_1366_768_60,    1366U, 768U,  FVID2_SF_PROGRESSIVE,85500U,   60U,
 249      0U, 0U, 0U, 0U, 0U, 0U},
 250     {FVID2_STD_1360_768_60,    1360U, 768U,  FVID2_SF_PROGRESSIVE,85500U,   60U,
 251      0U, 0U, 0U, 0U, 0U, 0U},
 252     {FVID2_STD_SXGA_60,        1280U, 1024U, FVID2_SF_PROGRESSIVE,108000U,  60U,
 253      0U, 0U, 0U, 0U, 0U, 0U},
 254     {FVID2_STD_SXGA_75,        1280U, 1024U, FVID2_SF_PROGRESSIVE,135000U,  75U,
 255      0U, 0U, 0U, 0U, 0U, 0U},
 256     {FVID2_STD_SXGA_85,        1280U, 1024U, FVID2_SF_PROGRESSIVE,157500U,  85U,
 257      0U, 0U, 0U, 0U, 0U, 0U},
 258     {FVID2_STD_WSXGAP_60,      1680U, 1050U, FVID2_SF_PROGRESSIVE,146250U,  60U,
 259      0U, 0U, 0U, 0U, 0U, 0U},
 260     {FVID2_STD_SXGAP_60,       1400U, 1050U, FVID2_SF_PROGRESSIVE,121750U,  60U,
 261      0U, 0U, 0U, 0U, 0U, 0U},
 262     {FVID2_STD_SXGAP_75,       1400U, 1050U, FVID2_SF_PROGRESSIVE,156000U,  75U,
 263      0U, 0U, 0U, 0U, 0U, 0U},
 264     {FVID2_STD_UXGA_60,        1600U, 1200U, FVID2_SF_PROGRESSIVE,162000U,  60U,
 265      0U, 0U, 0U, 0U, 0U, 0U},
 266     {FVID2_STD_WXGA_5x3_30,    1280U, 800U,  FVID2_SF_PROGRESSIVE,34125U,   30U,
 267      0U, 0U, 0U, 0U, 0U, 0U},
 268     {FVID2_STD_WXGA_5x3_60,    1280U, 800U,  FVID2_SF_PROGRESSIVE,68250U,   60U,
 269      0U, 0U, 0U, 0U, 0U, 0U},
 270     {FVID2_STD_WXGA_5x3_75,    1280U, 800U,  FVID2_SF_PROGRESSIVE,102250U,  75U,
 271      0U, 0U, 0U, 0U, 0U, 0U}
 272 };
 273
 274 /** \brief Data format string table. */
 275 static Fdm_DataFmtString gFdmDataFmtStrTable[] =
 276 {
 277     {FVID2_DF_YUV422I_UYVY,           "YUV422I_UYVY"          },
 278     {FVID2_DF_YUV422I_YUYV,           "YUV422I_YUYV"          },
 279     {FVID2_DF_YUV422I_YVYU,           "YUV422I_YVYU"          },
 280     {FVID2_DF_YUV422I_VYUY,           "YUV422I_VYUY"          },
 281     {FVID2_DF_YUV422SP_UV,            "YUV422SP_UV"           },
 282     {FVID2_DF_YUV422SP_VU,            "YUV422SP_VU"           },
 283     {FVID2_DF_YUV422P,                "YUV422P"               },
 284     {FVID2_DF_YUV420SP_UV,            "YUV420SP_UV"           },
 285     {FVID2_DF_YUV420SP_VU,            "YUV420SP_VU"           },
 286     {FVID2_DF_YUV420P,                "YUV420P"               },
 287     {FVID2_DF_YUV444P,                "YUV444P"               },
 288     {FVID2_DF_YUV444I,                "YUV444I"               },
 289     {FVID2_DF_RGB16_565,              "RGB16_565"             },
 290     {FVID2_DF_ARGB16_1555,            "ARGB16_1555"           },
 291     {FVID2_DF_RGBA16_5551,            "RGBA16_5551"           },
 292     {FVID2_DF_ARGB16_4444,            "ARGB16_4444"           },
 293     {FVID2_DF_RGBA16_4444,            "RGBA16_4444"           },
 294     {FVID2_DF_BGRX_4444,              "RGBX12_4444"           },
 295     {FVID2_DF_XBGR_4444,              "XRGB12_4444"           },
 296     {FVID2_DF_ARGB24_6666,            "ARGB24_6666"           },
 297     {FVID2_DF_RGBA24_6666,            "RGBA24_6666"           },
 298     {FVID2_DF_RGB24_888,              "RGB24_888"             },
 299     {FVID2_DF_XBGR24_8888,            "XBGR24_8888"           },
 300     {FVID2_DF_RGBX24_8888,            "RGBX24_8888"           },
 301     {FVID2_DF_BGRX24_8888,            "BGRX24_8888"           },
 302     {FVID2_DF_ARGB32_8888,            "ARGB32_8888"           },
 303     {FVID2_DF_RGBA32_8888,            "RGBA32_8888"           },
 304     {FVID2_DF_BGR16_565,              "BGR16_565"             },
 305     {FVID2_DF_ABGR16_1555,            "ABGR16_1555"           },
 306     {FVID2_DF_ABGR16_4444,            "ABGR16_4444"           },
 307     {FVID2_DF_BGRA16_5551,            "BGRA16_5551"           },
 308     {FVID2_DF_BGRA16_4444,            "BGRA16_4444"           },
 309     {FVID2_DF_AGBR16_1555,            "AGBR16_1555"           },
 310     {FVID2_DF_AGBR16_4444,            "AGBR16_4444"           },
 311     {FVID2_DF_XGBR16_1555,            "XGBR16_1555"           },
 312     {FVID2_DF_BGRX16_5551,            "BGRX16_5551"           },
 313     {FVID2_DF_ABGR24_6666,            "ABGR24_6666"           },
 314     {FVID2_DF_BGR24_888,              "BGR24_888"             },
 315     {FVID2_DF_ABGR32_8888,            "ABGR32_8888"           },
 316     {FVID2_DF_BGRA24_6666,            "BGRA24_6666"           },
 317     {FVID2_DF_BGRA32_8888,            "BGRA32_8888"           },
 318     {FVID2_DF_BITMAP8,                "BITMAP8"               },
 319     {FVID2_DF_BITMAP4_LOWER,          "BITMAP4_LOWER"         },
 320     {FVID2_DF_BITMAP4_UPPER,          "BITMAP4_UPPER"         },
 321     {FVID2_DF_BITMAP2_OFFSET0,        "BITMAP2_OFFSET0"       },
 322     {FVID2_DF_BITMAP2_OFFSET1,        "BITMAP2_OFFSET1"       },
 323     {FVID2_DF_BITMAP2_OFFSET2,        "BITMAP2_OFFSET2"       },
 324     {FVID2_DF_BITMAP2_OFFSET3,        "BITMAP2_OFFSET3"       },
 325     {FVID2_DF_BITMAP1_OFFSET0,        "BITMAP1_OFFSET0"       },
 326     {FVID2_DF_BITMAP1_OFFSET1,        "BITMAP1_OFFSET1"       },
 327     {FVID2_DF_BITMAP1_OFFSET2,        "BITMAP1_OFFSET2"       },
 328     {FVID2_DF_BITMAP1_OFFSET3,        "BITMAP1_OFFSET3"       },
 329     {FVID2_DF_BITMAP1_OFFSET4,        "BITMAP1_OFFSET4"       },
 330     {FVID2_DF_BITMAP1_OFFSET5,        "BITMAP1_OFFSET5"       },
 331     {FVID2_DF_BITMAP1_OFFSET6,        "BITMAP1_OFFSET6"       },
 332     {FVID2_DF_BITMAP1_OFFSET7,        "BITMAP1_OFFSET7"       },
 333     {FVID2_DF_BITMAP8_BGRA32,         "BITMAP8_BGRA32"        },
 334     {FVID2_DF_BITMAP4_BGRA32_LOWER,   "BITMAP4_BGRA32_LOWER"  },
 335     {FVID2_DF_BITMAP4_BGRA32_UPPER,   "BITMAP4_BGRA32_UPPER"  },
 336     {FVID2_DF_BITMAP2_BGRA32_OFFSET0, "BITMAP2_BGRA32_OFFSET0"},
 337     {FVID2_DF_BITMAP2_BGRA32_OFFSET1, "BITMAP2_BGRA32_OFFSET1"},
 338     {FVID2_DF_BITMAP2_BGRA32_OFFSET2, "BITMAP2_BGRA32_OFFSET2"},
 339     {FVID2_DF_BITMAP2_BGRA32_OFFSET3, "BITMAP2_BGRA32_OFFSET3"},
 340     {FVID2_DF_BITMAP1_BGRA32_OFFSET0, "BITMAP1_BGRA32_OFFSET0"},
 341     {FVID2_DF_BITMAP1_BGRA32_OFFSET1, "BITMAP1_BGRA32_OFFSET1"},
 342     {FVID2_DF_BITMAP1_BGRA32_OFFSET2, "BITMAP1_BGRA32_OFFSET2"},
 343     {FVID2_DF_BITMAP1_BGRA32_OFFSET3, "BITMAP1_BGRA32_OFFSET3"},
 344     {FVID2_DF_BITMAP1_BGRA32_OFFSET4, "BITMAP1_BGRA32_OFFSET4"},
 345     {FVID2_DF_BITMAP1_BGRA32_OFFSET5, "BITMAP1_BGRA32_OFFSET5"},
 346     {FVID2_DF_BITMAP1_BGRA32_OFFSET6, "BITMAP1_BGRA32_OFFSET6"},
 347     {FVID2_DF_BITMAP1_BGRA32_OFFSET7, "BITMAP1_BGRA32_OFFSET7"},
 348     {FVID2_DF_BAYER_RAW,              "BAYER_RAW"             },
 349     {FVID2_DF_BAYER_GRBG,             "BAYER_GRBG"            },
 350     {FVID2_DF_BAYER_RGGB,             "BAYER_RGGB"            },
 351     {FVID2_DF_BAYER_BGGR,             "BAYER_BGGR"            },
 352     {FVID2_DF_BAYER_GBRG,             "BAYER_GBRG"            },
 353     {FVID2_DF_RAW_VBI,                "RAW_VBI"               },
 354     {FVID2_DF_RAW24,                  "RAW24"                 },
 355     {FVID2_DF_RAW16,                  "RAW16"                 },
 356     {FVID2_DF_RAW08,                  "RAW08"                 },
 357     {FVID2_DF_BGRX32_8888,            "BGRX32_8888"           },
 358     {FVID2_DF_BGRA16_1555,            "BGRA16_1555"           },
 359     {FVID2_DF_BGRX16_1555,            "BGRX16_1555"           },
 360     {FVID2_DF_BGRA32_1010102,         "BGRA32_1010102"        },
 361     {FVID2_DF_BGRX32_1010102,         "BGRX32_1010102"        },
 362     {FVID2_DF_RGBA32_1010102,         "RGBA32_1010102"        },
 363     {FVID2_DF_RGBX32_1010102,         "RGBX32_1010102"        },
 364     {FVID2_DF_BGRA64_16161616,        "BGRA64_16161616"       },
 365     {FVID2_DF_BGRX64_16161616,        "BGRX64_16161616"       },
 366     {FVID2_DF_ABGR64_16161616,        "ABGR64_16161616"       },
 367     {FVID2_DF_XBGR64_16161616,        "XBGR64_16161616"       },
 368     {FVID2_DF_XRGB32_8888,            "XRGB32_8888"           },
 369     {FVID2_DF_RGBX16_4444,            "RGBX16_4444"           },
 370     {FVID2_DF_BGR16_565_A8,           "BRG16_565_A8"          },
 371     {FVID2_DF_RGB16_565_A8,           "RGB16_565_A8"          },
 372     {FVID2_DF_MISC,                   "MISC"                  },
 373     {FVID2_DF_INVALID,                "INVALID"               },
 374 };
 375
 376 /** \brief Standard string table. */
 377 static Fdm_StdString     gFdmStdStrTable[] =
 378 {
 379     {FVID2_STD_NTSC,            "NTSC"           },
 380     {FVID2_STD_PAL,             "PAL"            },
 381     {FVID2_STD_480I,            "480I"           },
 382     {FVID2_STD_576I,            "576I"           },
 383     {FVID2_STD_CIF,             "CIF"            },
 384     {FVID2_STD_HALF_D1,         "HALF_D1"        },
 385     {FVID2_STD_D1,              "D1"             },
 386     {FVID2_STD_480P,            "480P"           },
 387     {FVID2_STD_576P,            "576P"           },
 388     {FVID2_STD_720P_60,         "720P60"         },
 389     {FVID2_STD_720P_50,         "720P50"         },
 390     {FVID2_STD_1080I_60,        "1080I60"        },
 391     {FVID2_STD_1080I_50,        "1080I50"        },
 392     {FVID2_STD_1080P_60,        "1080P60"        },
 393     {FVID2_STD_1080P_50,        "1080P50"        },
 394     {FVID2_STD_1080P_24,        "1080P24"        },
 395     {FVID2_STD_1080P_30,        "1080P30"        },
 396     {FVID2_STD_VGA_60,          "VGA60"          },
 397     {FVID2_STD_VGA_72,          "VGA72"          },
 398     {FVID2_STD_VGA_75,          "VGA75"          },
 399     {FVID2_STD_VGA_85,          "VGA85"          },
 400     {FVID2_STD_WVGA_60,         "WVGA60"         },
 401     {FVID2_STD_SVGA_60,         "SVGA60"         },
 402     {FVID2_STD_SVGA_72,         "SVGA72"         },
 403     {FVID2_STD_SVGA_75,         "SVGA75"         },
 404     {FVID2_STD_SVGA_85,         "SVGA85"         },
 405     {FVID2_STD_WSVGA_70,        "WSVGA70"        },
 406     {FVID2_STD_XGA_60,          "XGA60"          },
 407     {FVID2_STD_XGA_DSS_TDM_60,  "XGA_DSS_TDM_60" },
 408     {FVID2_STD_XGA_70,          "XGA70"          },
 409     {FVID2_STD_XGA_75,          "XGA75"          },
 410     {FVID2_STD_XGA_85,          "XGA85"          },
 411     {FVID2_STD_WXGA_30,         "WXGA30"         },
 412     {FVID2_STD_WXGA_60,         "WXGA60"         },
 413     {FVID2_STD_WXGA_75,         "WXGA75"         },
 414     {FVID2_STD_WXGA_85,         "WXGA85"         },
 415     {FVID2_STD_1440_900_60,     "1440X900@60"    },
 416     {FVID2_STD_1368_768_60,     "1368X768@60"    },
 417     {FVID2_STD_1366_768_60,     "1366X768@60"    },
 418     {FVID2_STD_1360_768_60,     "1360X768@60"    },
 419     {FVID2_STD_SXGA_60,         "SXGA60"         },
 420     {FVID2_STD_SXGA_75,         "SXGA75"         },
 421     {FVID2_STD_SXGA_85,         "SXGA85"         },
 422     {FVID2_STD_WSXGAP_60,       "WSXGAP60"       },
 423     {FVID2_STD_SXGAP_60,        "SXGAP60"        },
 424     {FVID2_STD_SXGAP_75,        "SXGAP75"        },
 425     {FVID2_STD_UXGA_60,         "UXGA60"         },
 426     {FVID2_STD_MUX_2CH_D1,      "MUX_2CH_D1"     },
 427     {FVID2_STD_MUX_2CH_HALF_D1, "MUX_2CH_HALF_D1"},
 428     {FVID2_STD_MUX_2CH_CIF,     "MUX_2CH_CIF"    },
 429     {FVID2_STD_MUX_4CH_D1,      "MUX_4CH_D1"     },
 430     {FVID2_STD_MUX_4CH_CIF,     "MUX_4CH_CIF"    },
 431     {FVID2_STD_MUX_4CH_HALF_D1, "MUX_4CH_HALF_D1"},
 432     {FVID2_STD_MUX_8CH_CIF,     "MUX_8CH_CIF"    },
 433     {FVID2_STD_MUX_8CH_HALF_D1, "MUX_8CH_HALF_D1"},
 434     {FVID2_STD_WXGA_5x3_30,     "WXGA_5x3_30"    },
 435     {FVID2_STD_WXGA_5x3_60,     "WXGA_5x3_60"    },
 436     {FVID2_STD_WXGA_5x3_75,     "WXGA_5x3_75"    },
 437     {FVID2_STD_AUTO_DETECT,     "AUTO_DETECT"    },
 438     {FVID2_STD_CUSTOM,          "CUSTOM"         },
 439 };
 440
 441 /* ========================================================================== */
 442 /*                          Function Definitions                              */
 443 /* ========================================================================== */
 444
 445 /**
 446  *  Fvid2_init
 447  *  \brief FVID2 init function.
 448  *
 449  *  Initializes the drivers and the hardware.
 450  *  This function should be called before calling any of driver API's.
 451  *
 452  *  \param arg          Not used currently. Meant for future purpose.
 453  *
 454  *  \return             Returns 0 on success else returns error value.
 455  */
 456 int32_t Fvid2_init(void *args)
 457 {
 458     uint32_t cnt;
 459     int32_t  retVal = FVID2_SOK;
 460     int32_t  initValue;
 461     SemaphoreP_Params params;
 462
 463     /* Init all global variables to zero */
 464     Fvid2_memset(&gFdmObj, 0U, sizeof (gFdmObj));
 465
 466     /* Mark pool flags as free */
 467     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
 468     {
 469         gFdmObj.fdmDriverObjects[cnt].isUsed = (uint32_t) FALSE;
 470     }
 471     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_CH_OBJS; cnt++)
 472     {
 473         gFdmObj.fdmChannelObjects[cnt].isUsed = (uint32_t) FALSE;
 474     }
 475
 476     gFdmObj.versionString = FVID2_VERSION_STRING;
 477     gFdmObj.versionNumber = FVID2_VERSION_NUMBER;
 478
 479     /* Allocate lock semaphore */
 480     SemaphoreP_Params_init(&params);
 481     params.mode = SemaphoreP_Mode_BINARY;
 482     initValue       = 1;
 483     gFdmObj.lockSem = SemaphoreP_create(initValue, &params);
 484     if (NULL == gFdmObj.lockSem)
 485     {
 486         Fvid2_printf("FVID2 semaphore create failed!!\r\n");
 487         retVal = FVID2_EALLOC;
 488     }
 489
 490     /* Free-up memory if error occurs */
 491     if (FVID2_SOK != retVal)
 492     {
 493         Fvid2_deInit(NULL);
 494     }
 495
 496     return (retVal);
 497 }
 498
 499 /**
 500  *  Fvid2_deInit
 501  *  \brief FVID2 deinit function.
 502  *
 503  *  Uninitializes the drivers and the hardware.
 504  *
 505  *  \param arg          Not used currently. Meant for future purpose.
 506  *
 507  *  \return             Returns 0 on success else returns error value.
 508  */
 509 int32_t Fvid2_deInit(void *args)
 510 {
 511     int32_t retVal = FVID2_SOK;
 512
 513     /* Delete the lock semaphore */
 514     if (NULL != gFdmObj.lockSem)
 515     {
 516         SemaphoreP_delete(gFdmObj.lockSem);
 517         gFdmObj.lockSem = NULL;
 518     }
 519
 520     return (retVal);
 521 }
 522
 523 /**
 524  *  Fvid2_getVersionString
 525  *  \brief Get the FVID2 driver version in string form. This API can be
 526  *  called before calling #Fvid2_init().
 527  *
 528  *  \return             Returns pointer to FVID2 version string.
 529  */
 530 const char *Fvid2_getVersionString(void)
 531 {
 532     return (FVID2_VERSION_STRING);
 533 }
 534
 535 /**
 536  *  Fvid2_getVersionNumber
 537  *  \brief Get the FVID2 driver version in number form. This API can be
 538  *  called before calling #Fvid2_init().
 539  *
 540  *  \return             FVID2 version number.
 541  */
 542 uint32_t Fvid2_getVersionNumber(void)
 543 {
 544     return (FVID2_VERSION_NUMBER);
 545 }
 546
 547 /**
 548  *  Fvid2_registerDriver
 549  *  \brief FVID2 register driver function.
 550  */
 551 int32_t Fvid2_registerDriver(const Fvid2_DrvOps *drvOps)
 552 {
 553     int32_t     retVal = FVID2_SOK;
 554     Fdm_Driver *drv;
 555     uint32_t    cnt;
 556
 557     /* Check for NULL pointers */
 558     OSAL_Assert(NULL == drvOps);
 559
 560     SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 561
 562     /* Check whether the driver is already registered */
 563     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
 564     {
 565         if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
 566         {
 567             /* Check for NULL pointers */
 568             OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
 569
 570             if (drvOps->drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
 571             {
 572                 Fvid2_printf("Driver with same id already registered!!\r\n");
 573                 retVal = FVID2_EDRIVER_INUSE;
 574                 break;
 575             }
 576         }
 577     }
 578
 579     if (FVID2_SOK == retVal)
 580     {
 581         /* Get a free driver object */
 582         drv = fdmAllocDriverObject();
 583         if (NULL != drv)
 584         {
 585             drv->drvOps   = drvOps;
 586             drv->numOpens = 0U;
 587         }
 588         else
 589         {
 590             Fvid2_printf("Alloc driver object failed!!\r\n");
 591             retVal = FVID2_EALLOC;
 592         }
 593     }
 594
 595     SemaphoreP_post(gFdmObj.lockSem);
 596
 597     return (retVal);
 598 }
 599
 600 /**
 601  *  Fvid2_unRegisterDriver
 602  *  \brief FVID2 unregister driver function.
 603  */
 604 int32_t Fvid2_unRegisterDriver(const Fvid2_DrvOps *drvOps)
 605 {
 606     int32_t retVal = FVID2_EFAIL;
 607
 608     /* Check for NULL pointers */
 609     OSAL_Assert(NULL == drvOps);
 610
 611     SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 612
 613     /* Free the driver object */
 614     retVal = fdmFreeDriverObject(drvOps);
 615
 616     SemaphoreP_post(gFdmObj.lockSem);
 617
 618     return (retVal);
 619 }
 620
 621 /**
 622  *  Fvid2_create
 623  *  \brief Opens the driver identified by the driver ID.
 624  */
 625 Fvid2_Handle Fvid2_create(uint32_t              drvId,
 626                           uint32_t              instanceId,
 627                           void                 *createArgs,
 628                           void                 *createStatusArgs,
 629                           const Fvid2_CbParams *cbParams)
 630 {
 631     Fdm_Driver       *drv = NULL;
 632     uint32_t          cnt;
 633     Fdrv_Handle       drvHandle = NULL;
 634     Fdm_Channel      *channel   = NULL;
 635     Fvid2_DrvCbParams fdmCbParams, *tempCbParams;
 636
 637     SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 638
 639     /* Get the matching driver object */
 640     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
 641     {
 642         if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
 643         {
 644             /* Check for NULL pointers */
 645             OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
 646
 647             if (drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
 648             {
 649                 drv = &gFdmObj.fdmDriverObjects[cnt];
 650                 /* Allocate channel object */
 651                 channel = fdmAllocChannelObject();
 652                 break;
 653             }
 654         }
 655     }
 656
 657     if (NULL != channel)
 658     {
 659         if (NULL != drv->drvOps->createFxn)
 660         {
 661             if (NULL != cbParams)
 662             {
 663                 if (NULL != cbParams->cbFxn)
 664                 {
 665                     fdmCbParams.fdmCbFxn = &fdmDriverCbFxn;
 666                 }
 667                 else
 668                 {
 669                     fdmCbParams.fdmCbFxn = NULL;
 670                 }
 671                 if (NULL != cbParams->errCbFxn)
 672                 {
 673                     fdmCbParams.fdmErrCbFxn = &fdmDriverErrCbFxn;
 674                 }
 675                 else
 676                 {
 677                     fdmCbParams.fdmErrCbFxn = NULL;
 678                 }
 679
 680                 fdmCbParams.handle   = channel;
 681                 fdmCbParams.errList  = cbParams->errList;
 682                 fdmCbParams.fdmData  = channel;
 683                 tempCbParams         = &fdmCbParams;
 684             }
 685             else
 686             {
 687                 tempCbParams = NULL;
 688             }
 689
 690             /* Call the driver's create function */
 691             drvHandle = drv->drvOps->createFxn(
 692                 drvId,
 693                 instanceId,
 694                 createArgs,
 695                 createStatusArgs,
 696                 tempCbParams);
 697         }
 698         else
 699         {
 700             Fvid2_printf("Driver Ops not supported!!\r\n");
 701         }
 702
 703         if (NULL != drvHandle)
 704         {
 705             drv->numOpens++;
 706
 707             channel->drv       = drv;
 708             channel->drvHandle = drvHandle;
 709             Fvid2CbParams_init(&channel->cbParams);
 710             if (NULL != cbParams)
 711             {
 712                 Fvid2_memcpy(
 713                     &channel->cbParams,
 714                     cbParams,
 715                     sizeof (Fvid2_CbParams));
 716             }
 717         }
 718         else
 719         {
 720             Fvid2_printf("Driver create failed!!\r\n");
 721
 722             /* Free the allocated channel object */
 723             fdmFreeChannelObject(channel);
 724             channel = NULL;
 725         }
 726     }
 727     else
 728     {
 729         Fvid2_printf("EALLOC: Invalid driver ID!!\r\n");
 730     }
 731
 732     SemaphoreP_post(gFdmObj.lockSem);
 733
 734     return (channel);
 735 }
 736
 737 /**
 738  *  Fvid2_delete
 739  *  \brief Application calls Fvid2_delete to close the logical channel
 740  *  associated with FVID2 handle.
 741  */
 742 int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs)
 743 {
 744     int32_t      retVal = FVID2_SOK;
 745     Fdm_Channel *channel;
 746
 747     SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 748
 749     if (NULL != handle)
 750     {
 751         channel = (Fdm_Channel *) handle;
 752
 753         /* Check for NULL pointers */
 754         OSAL_Assert(NULL == channel->drv);
 755         OSAL_Assert(NULL == channel->drv->drvOps);
 756
 757         if (NULL != channel->drv->drvOps->deleteFxn)
 758         {
 759             /* Call the driver's delete function */
 760             retVal = channel->drv->drvOps->deleteFxn(
 761                 channel->drvHandle,
 762                 deleteArgs);
 763         }
 764         else
 765         {
 766             Fvid2_printf("Driver Ops not supported!!\r\n");
 767         }
 768
 769         channel->drv->numOpens--;
 770         /* Free the allocated channel object */
 771         channel->drv               = NULL;
 772         channel->drvHandle         = NULL;
 773         channel->cbParams.cbFxn    = NULL;
 774         channel->cbParams.errCbFxn = NULL;
 775         channel->cbParams.errList  = NULL;
 776         channel->cbParams.appData  = NULL;
 777         fdmFreeChannelObject(channel);
 778     }
 779     else
 780     {
 781         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
 782         retVal = FVID2_EBADARGS;
 783     }
 784
 785     SemaphoreP_post(gFdmObj.lockSem);
 786
 787     return (retVal);
 788 }
 789
 790 /**
 791  *  Fvid2_control
 792  *  \brief An application calls Fvid2_control to send device-specific control
 793  *  commands to the video driver.
 794  */
 795 int32_t Fvid2_control(Fvid2_Handle  handle,
 796                       uint32_t      cmd,
 797                       void         *cmdArgs,
 798                       void         *cmdStatusArgs)
 799 {
 800     int32_t      retVal = FVID2_SOK;
 801     Fdm_Channel *channel;
 802
 803     if (NULL != handle)
 804     {
 805         channel = (Fdm_Channel *) handle;
 806
 807         /* Check for NULL pointers */
 808         OSAL_Assert(NULL == channel->drv);
 809         OSAL_Assert(NULL == channel->drv->drvOps);
 810
 811         if (NULL != channel->drv->drvOps->controlFxn)
 812         {
 813             /* Call the driver's control function */
 814             retVal = channel->drv->drvOps->controlFxn(
 815                 channel->drvHandle,
 816                 cmd,
 817                 cmdArgs,
 818                 cmdStatusArgs);
 819         }
 820         else
 821         {
 822             Fvid2_printf("Driver Ops not supported!!\r\n");
 823             retVal = FVID2_EUNSUPPORTED_OPS;
 824         }
 825     }
 826     else
 827     {
 828         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
 829         retVal = FVID2_EBADARGS;
 830     }
 831
 832     return (retVal);
 833 }
 834
 835 /**
 836  *  Fvid2_queue
 837  *  \brief An application calls Fvid2_queue to submit a video buffer to the
 838  *  video device driver.
 839  *  This is used in capture/display drivers.
 840  */
 841 int32_t Fvid2_queue(Fvid2_Handle     handle,
 842                     Fvid2_FrameList *frameList,
 843                     uint32_t         streamId)
 844 {
 845     int32_t      retVal = FVID2_SOK;
 846     Fdm_Channel *channel;
 847
 848     if (NULL != handle)
 849     {
 850         channel = (Fdm_Channel *) handle;
 851
 852         /* Check for NULL pointers */
 853         OSAL_Assert(NULL == channel->drv);
 854         OSAL_Assert(NULL == channel->drv->drvOps);
 855
 856         if (NULL != channel->drv->drvOps->queueFxn)
 857         {
 858             /* Call the driver's queue function */
 859             retVal = channel->drv->drvOps->queueFxn(
 860                 channel->drvHandle,
 861                 frameList,
 862                 streamId);
 863         }
 864         else
 865         {
 866             Fvid2_printf("Driver Ops not supported!!\r\n");
 867             retVal = FVID2_EUNSUPPORTED_OPS;
 868         }
 869     }
 870     else
 871     {
 872         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
 873         retVal = FVID2_EBADARGS;
 874     }
 875
 876     return (retVal);
 877 }
 878
 879 /**
 880  *  Fvid2_dequeue
 881  *  \brief An application calls Fvid2_dequeue to request the video device
 882  *  driver to give ownership of a video buffer.
 883  *  This is used in capture/display drivers.
 884  */
 885 int32_t Fvid2_dequeue(Fvid2_Handle      handle,
 886                       Fvid2_FrameList  *frameList,
 887                       uint32_t          streamId,
 888                       uint32_t          timeout)
 889 {
 890     int32_t      retVal = FVID2_SOK;
 891     Fdm_Channel *channel;
 892
 893     if (NULL != handle)
 894     {
 895         channel = (Fdm_Channel *) handle;
 896
 897         /* Check for NULL pointers */
 898         OSAL_Assert(NULL == channel->drv);
 899         OSAL_Assert(NULL == channel->drv->drvOps);
 900
 901         if (NULL != channel->drv->drvOps->dequeueFxn)
 902         {
 903             /* Call the driver's dequeue function */
 904             retVal = channel->drv->drvOps->dequeueFxn(
 905                 channel->drvHandle,
 906                 frameList,
 907                 streamId,
 908                 timeout);
 909         }
 910         else
 911         {
 912             Fvid2_printf("Driver Ops not supported!!\r\n");
 913             retVal = FVID2_EUNSUPPORTED_OPS;
 914         }
 915     }
 916     else
 917     {
 918         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
 919         retVal = FVID2_EBADARGS;
 920     }
 921
 922     return (retVal);
 923 }
 924
 925 /**
 926  *  Fvid2_processRequest
 927  *  \brief An application calls Fvid2_processRequest to submit a video buffer
 928  *  to the video device driver.
 929  */
 930 int32_t Fvid2_processRequest(Fvid2_Handle     handle,
 931                              Fvid2_FrameList *inFrameList,
 932                              Fvid2_FrameList *outFrameList)
 933 {
 934     int32_t      retVal = FVID2_SOK;
 935     Fdm_Channel *channel;
 936
 937     if (NULL != handle)
 938     {
 939         channel = (Fdm_Channel *) handle;
 940
 941         /* Check for NULL pointers */
 942         OSAL_Assert(NULL == channel->drv);
 943         OSAL_Assert(NULL == channel->drv->drvOps);
 944
 945         if (NULL != channel->drv->drvOps->processRequestFxn)
 946         {
 947             /* Call the driver's process frame function */
 948             retVal = channel->drv->drvOps->processRequestFxn(
 949                 channel->drvHandle,
 950                 inFrameList,
 951                 outFrameList);
 952         }
 953         else
 954         {
 955             Fvid2_printf("Driver Ops not supported!!\r\n");
 956             retVal = FVID2_EUNSUPPORTED_OPS;
 957         }
 958     }
 959     else
 960     {
 961         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
 962         retVal = FVID2_EBADARGS;
 963     }
 964
 965     return (retVal);
 966 }
 967
 968 /**
 969  *  Fvid2_getProcessedRequest
 970  *  \brief An application calls Fvid2_getProcessedRequest to request the video
 971  *  device driver to give ownership of a video buffer.
 972  */
 973 int32_t Fvid2_getProcessedRequest(Fvid2_Handle     handle,
 974                                   Fvid2_FrameList *inFrameList,
 975                                   Fvid2_FrameList *outFrameList,
 976                                   uint32_t         timeout)
 977 {
 978     int32_t      retVal = FVID2_SOK;
 979     Fdm_Channel *channel;
 980
 981     if (NULL != handle)
 982     {
 983         channel = (Fdm_Channel *) handle;
 984
 985         /* Check for NULL pointers */
 986         OSAL_Assert(NULL == channel->drv);
 987         OSAL_Assert(NULL == channel->drv->drvOps);
 988
 989         if (NULL != channel->drv->drvOps->getProcessedRequestFxn)
 990         {
 991             /* Call the driver's get process frame function */
 992             retVal = channel->drv->drvOps->getProcessedRequestFxn(
 993                 channel->drvHandle,
 994                 inFrameList,
 995                 outFrameList,
 996                 timeout);
 997         }
 998         else
 999         {
1000             Fvid2_printf("Driver Ops not supported!!\r\n");
1001             retVal = FVID2_EUNSUPPORTED_OPS;
1002         }
1003     }
1004     else
1005     {
1006         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
1007         retVal = FVID2_EBADARGS;
1008     }
1009
1010     return (retVal);
1011 }
1012
1013 /**
1014  *  Fvid2_getModeInfo
1015  *  \brief Function to get the information about various FVID2 modes/standards.
1016  */
1017 int32_t Fvid2_getModeInfo(Fvid2_ModeInfo *modeInfo)
1018 {
1019     int32_t         retVal = FVID2_SOK;
1020     uint32_t        entryCnt;
1021     Fvid2_ModeInfo *matchedEntry = NULL;
1022
1023     if (NULL != modeInfo)
1024     {
1025         for (entryCnt = 0U; entryCnt < FDM_NUM_STD_INFO_ENTRIES; entryCnt++)
1026         {
1027             if (gFdmStdInfoTable[entryCnt].standard == modeInfo->standard)
1028             {
1029                 matchedEntry = &gFdmStdInfoTable[entryCnt];
1030                 break;
1031             }
1032         }
1033
1034         if (NULL == matchedEntry)
1035         {
1036             Fvid2_printf("Unsupported standard!!\r\n");
1037             retVal = FVID2_EINVALID_PARAMS;
1038         }
1039         else
1040         {
1041             Fvid2_memcpy(modeInfo, matchedEntry, sizeof (Fvid2_ModeInfo));
1042         }
1043     }
1044     else
1045     {
1046         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
1047         retVal = FVID2_EBADARGS;
1048     }
1049
1050     return (retVal);
1051 }
1052
1053 /**
1054  *  \brief Function to get the name of the data format in printable string.
1055  *
1056  *  \param dataFmt      [IN] Data format to get the name.
1057  *                           For valid values see #Fvid2_DataFormat.
1058  *
1059  *  \return Returns a const pointer to the string. If the data format is not
1060  *  known, then it return the string as "UNKNOWN".
1061  */
1062 const char *Fvid2_getDataFmtString(uint32_t dataFmt)
1063 {
1064     uint32_t    entryCnt;
1065     const char *dataFmtStr = NULL;
1066
1067     for (entryCnt = 0U; entryCnt < FDM_NUM_DATA_FMT_STR_ENTRIES; entryCnt++)
1068     {
1069         if (gFdmDataFmtStrTable[entryCnt].dataFmt == dataFmt)
1070         {
1071             dataFmtStr = gFdmDataFmtStrTable[entryCnt].dataFmtStr;
1072             break;
1073         }
1074     }
1075
1076     if (NULL == dataFmtStr)
1077     {
1078         dataFmtStr = "UNKNOWN";
1079     }
1080
1081     return (dataFmtStr);
1082 }
1083
1084 /**
1085  *  \brief Function to get the name of the standard in printable string.
1086  *
1087  *  \param standard     [IN] Standard to get the name.
1088  *                           For valid values see #Fvid2_Standard.
1089  *
1090  *  \return Returns a const pointer to the string. If the standard is not
1091  *  known, then it return the string as "UNKNOWN".
1092  */
1093 const char *Fvid2_getStandardString(uint32_t standard)
1094 {
1095     uint32_t    entryCnt;
1096     const char *stdStr = NULL;
1097
1098     for (entryCnt = 0U; entryCnt < FDM_NUM_STD_STR_ENTRIES; entryCnt++)
1099     {
1100         if (gFdmStdStrTable[entryCnt].standard == standard)
1101         {
1102             stdStr = gFdmStdStrTable[entryCnt].stdStr;
1103             break;
1104         }
1105     }
1106
1107     if (NULL == stdStr)
1108     {
1109         stdStr = "UNKNOWN";
1110     }
1111
1112     return (stdStr);
1113 }
1114
1115 /**
1116  *  Fvid2_checkFrameList
1117  *  \brief Checks the FVID2 frame list for error and returns appropriate error.
1118  *  This is used by the drivers and not by the application.
1119  */
1120 int32_t Fvid2_checkFrameList(const Fvid2_FrameList *frameList,
1121                              uint32_t maxFrames)
1122 {
1123     int32_t  retVal = FVID2_SOK;
1124     uint32_t frmCnt;
1125
1126     /* Check for NULL pointer */
1127     if (NULL == frameList)
1128     {
1129         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
1130         retVal = FVID2_EBADARGS;
1131     }
1132     else
1133     {
1134         /* Check whether num frames is within range */
1135         if (frameList->numFrames > maxFrames)
1136         {
1137             Fvid2_printf("Number of frames exceeds max!!\r\n");
1138             retVal = FVID2_EOUT_OF_RANGE;
1139         }
1140
1141         /* Check whether num frames is within range */
1142         if (frameList->numFrames > FVID2_MAX_FRAME_PTR)
1143         {
1144             Fvid2_printf("Number of frames exceeds FVID2 max!!\r\n");
1145             retVal = FVID2_EOUT_OF_RANGE;
1146         }
1147
1148         /* Check whether num frames is zero */
1149         if (0U == frameList->numFrames)
1150         {
1151             Fvid2_printf("Number of frames is zero!!\r\n");
1152             retVal = FVID2_EOUT_OF_RANGE;
1153         }
1154
1155         if (FVID2_SOK == retVal)
1156         {
1157             /* Check the individual frame pointers */
1158             for (frmCnt = 0U; frmCnt < frameList->numFrames; frmCnt++)
1159             {
1160                 /* Check for NULL pointer */
1161                 if (NULL == frameList->frames[frmCnt])
1162                 {
1163                     Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
1164                     retVal = FVID2_EBADARGS;
1165                     break;
1166                 }
1167             }
1168         }
1169     }
1170
1171     return (retVal);
1172 }
1173
1174 /**
1175  *  Fvid2_checkDqFrameList
1176  *  \brief Checks the FVID2 frame list of dequeue call for error and returns
1177  *  appropriate error. For dequeue operation, the frame pointers in the frames
1178  *  should not be checked as this will be filled by the driver.
1179  *  This is used by the drivers and not by the application.
1180  */
1181 int32_t Fvid2_checkDqFrameList(const Fvid2_FrameList *frameList,
1182                                uint32_t               maxFrames)
1183 {
1184     int32_t retVal = FVID2_SOK;
1185
1186     /* Check for NULL pointer */
1187     if (NULL == frameList)
1188     {
1189         Fvid2_printf("EBADARGS: NULL pointer!!\r\n");
1190         retVal = FVID2_EBADARGS;
1191     }
1192     else
1193     {
1194         /* Check whether max frames is within range */
1195         if (maxFrames > FVID2_MAX_FRAME_PTR)
1196         {
1197             Fvid2_printf("Number of frames exceeds FVID2 max!!\r\n");
1198             retVal = FVID2_EOUT_OF_RANGE;
1199         }
1200     }
1201
1202     return (retVal);
1203 }
1204
1205 /**
1206  *  Fvid2_copyFrameList
1207  *  \brief Copies the source frame list to the destination frame list.
1208  *  This also resets the frame pointers from the source frame list.
1209  *  This is used by the drivers and not by the application.
1210  */
1211 void Fvid2_copyFrameList(Fvid2_FrameList *dest, Fvid2_FrameList *src)
1212 {
1213     uint32_t frmCnt;
1214
1215     /* Check for NULL pointers */
1216     OSAL_Assert(NULL == dest);
1217     OSAL_Assert(NULL == src);
1218     OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
1219
1220     dest->numFrames  = src->numFrames;
1221     dest->drvData    = src->drvData;
1222
1223     /* Copy the individual frames */
1224     for (frmCnt = 0U; frmCnt < src->numFrames; frmCnt++)
1225     {
1226         dest->frames[frmCnt] = src->frames[frmCnt];
1227         src->frames[frmCnt]  = NULL;
1228     }
1229
1230     return;
1231 }
1232
1233 /**
1234  *  Fvid2_duplicateFrameList
1235  *  \brief Duplicate the source frame list to the destination frame list.
1236  *  This does not reset the frame pointers from the source frame list.
1237  *  This is used by the drivers and not by the application.
1238  */
1239 void Fvid2_duplicateFrameList(Fvid2_FrameList *dest, const Fvid2_FrameList *src)
1240 {
1241     uint32_t frmCnt;
1242
1243     /* Check for NULL pointers */
1244     OSAL_Assert(NULL == dest);
1245     OSAL_Assert(NULL == src);
1246     OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
1247
1248     dest->numFrames  = src->numFrames;
1249     dest->drvData    = src->drvData;
1250
1251     /* Duplicate the individual frames */
1252     for (frmCnt = 0U; frmCnt < src->numFrames; frmCnt++)
1253     {
1254         dest->frames[frmCnt] = src->frames[frmCnt];
1255     }
1256
1257     return;
1258 }
1259
1260 /**
1261  *  fdmDriverCbFxn
1262  *  \brief FVID2 driver manager driver callback function. Whenever the drivers
1263  *  wants to call the application callback function, this function will be
1264  *  called by the driver and FDM will in turn call the application callback
1265  *  function.
1266  *  This is used by the drivers and not by the application.
1267  */
1268 static int32_t fdmDriverCbFxn(void *fdmData)
1269 {
1270     int32_t      retVal;
1271     Fdm_Channel *channel;
1272
1273     /* Check for NULL pointers */
1274     OSAL_Assert(NULL == fdmData);
1275
1276     channel = (Fdm_Channel *) fdmData;
1277     OSAL_Assert(NULL == channel->cbParams.cbFxn);
1278     retVal = channel->cbParams.cbFxn(channel, channel->cbParams.appData);
1279
1280     return (retVal);
1281 }
1282
1283 /**
1284  *  fdmDriverErrCbFxn
1285  *  \brief FVID2 driver manager driver error callback function.
1286  *  Whenever the drivers wants to call the application error callback function,
1287  *  this function will be called by the driver and FDM will in turn call the
1288  *  application error callback function.
1289  *  This is used by the drivers and not by the application.
1290  */
1291 static int32_t fdmDriverErrCbFxn(void *fdmData, void *errList)
1292 {
1293     int32_t      retVal;
1294     Fdm_Channel *channel;
1295
1296     /* Check for NULL pointers */
1297     OSAL_Assert(NULL == fdmData);
1298
1299     channel = (Fdm_Channel *) fdmData;
1300     OSAL_Assert(NULL == channel->cbParams.errCbFxn);
1301     retVal =
1302         channel->cbParams.errCbFxn(channel, channel->cbParams.appData, errList);
1303
1304     return (retVal);
1305 }
1306
1307 /**
1308  *  fdmAllocDriverObject
1309  *  \brief Allocate memory for driver object from static memory pool.
1310  *  Returns NULL if memory pool is full.
1311  */
1312 static Fdm_Driver *fdmAllocDriverObject(void)
1313 {
1314     uint32_t    cnt;
1315     Fdm_Driver *drv = NULL;
1316
1317     /* Get a free driver object */
1318     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
1319     {
1320         if (FALSE == gFdmObj.fdmDriverObjects[cnt].isUsed)
1321         {
1322             drv         = &gFdmObj.fdmDriverObjects[cnt];
1323             drv->isUsed = (uint32_t) TRUE;
1324             break;
1325         }
1326     }
1327
1328     return (drv);
1329 }
1330
1331 /**
1332  *  fdmFreeDriverObject
1333  *  \brief Free-up the memory allocated for driver object.
1334  */
1335 static int32_t fdmFreeDriverObject(const Fvid2_DrvOps *drvOps)
1336 {
1337     uint32_t cnt;
1338     int32_t  retVal = FVID2_EFAIL;
1339
1340     /* Check for NULL pointers */
1341     OSAL_Assert(NULL == drvOps);
1342
1343     /* Free the driver object */
1344     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
1345     {
1346         if ((TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed) &&
1347             (drvOps == gFdmObj.fdmDriverObjects[cnt].drvOps))
1348         {
1349             if (0u == gFdmObj.fdmDriverObjects[cnt].numOpens)
1350             {
1351                 gFdmObj.fdmDriverObjects[cnt].isUsed   = (uint32_t) FALSE;
1352                 gFdmObj.fdmDriverObjects[cnt].drvOps   = NULL;
1353                 gFdmObj.fdmDriverObjects[cnt].numOpens = 0u;
1354                 retVal = FVID2_SOK;
1355             }
1356             else
1357             {
1358                 Fvid2_printf("Driver in use!!\r\n");
1359                 retVal = FVID2_EDEVICE_INUSE;
1360             }
1361             break;
1362         }
1363     }
1364
1365     if (FVID2_EFAIL == retVal)
1366     {
1367         Fvid2_printf("Driver ops not found!!\r\n");
1368     }
1369
1370     return (retVal);
1371 }
1372
1373 /**
1374  *  fdmAllocChannelObject
1375  *  \brief Allocate memory for channel object from static memory pool.
1376  *  Returns NULL if memory pool is full.
1377  */
1378 static Fdm_Channel *fdmAllocChannelObject(void)
1379 {
1380     uint32_t       cnt;
1381     Fdm_Channel *channel = NULL;
1382
1383     /* Get a free channel object */
1384     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_CH_OBJS; cnt++)
1385     {
1386         if (FALSE == gFdmObj.fdmChannelObjects[cnt].isUsed)
1387         {
1388             channel         = &gFdmObj.fdmChannelObjects[cnt];
1389             channel->isUsed = (uint32_t) TRUE;
1390             break;
1391         }
1392     }
1393
1394     return (channel);
1395 }
1396
1397 /**
1398  *  fdmFreeChannelObject
1399  *  \brief Free-up the memory allocated for channel object.
1400  */
1401 static int32_t fdmFreeChannelObject(Fdm_Channel *channel)
1402 {
1403     int32_t retVal = FVID2_EALLOC;
1404
1405     /* Check for NULL pointers */
1406     OSAL_Assert(NULL == channel);
1407
1408     /* Free the channel object */
1409     if (TRUE == channel->isUsed)
1410     {
1411         channel->isUsed = (uint32_t) FALSE;
1412         retVal          = FVID2_SOK;
1413     }
1414     else
1415     {
1416         Fvid2_printf("Freeing a channel object not in use!!\r\n");
1417     }
1418
1419     return (retVal);
1420 }
1421
1422 static void Fvid2_printf(const char *format, ...)
1423 {
1424     return;
1425 }
1426
1427 static void Fvid2_memset(void *mem, int32_t ch, uint32_t byteCount)
1428 {
1429     memset(mem, ch, byteCount);
1430     return;
1431 }
1432
1433 static void Fvid2_memcpy(void *dest, const void *src, uint32_t byteCount)
1434 {
1435     memcpy(dest, src, byteCount);
1436     return;
1437 }