Added XDC files and added top level include
authorSivaraj R <sivaraj@ti.com>
Mon, 9 Apr 2018 05:38:00 +0000 (11:08 +0530)
committerSivaraj R <sivaraj@ti.com>
Mon, 9 Apr 2018 05:38:00 +0000 (11:08 +0530)
Signed-off-by: Sivaraj R <sivaraj@ti.com>
Settings.xdc.xdt [new file with mode: 0644]
config_mk.bld [new file with mode: 0644]
fvid2.h
fvid2ver.h [new file with mode: 0644]
fvid2ver.h.xdt [new file with mode: 0644]
include/fvid2_api.h [new file with mode: 0644]
include/fvid2_drvMgr.h
makefile [new file with mode: 0644]
package.bld [new file with mode: 0644]
package.xdc [new file with mode: 0644]
package.xs [new file with mode: 0644]

diff --git a/Settings.xdc.xdt b/Settings.xdc.xdt
new file mode 100644 (file)
index 0000000..809772d
--- /dev/null
@@ -0,0 +1,48 @@
+\r
+%%{\r
+/*!\r
+ *  This template implements the Settings.xdc\r
+ */\r
+  /* Versioning */\r
+  var ver = this;\r
+  for each(i=0;i<ver.length;i++)\r
+  {\r
+      if(String(ver[i]).length < 2)\r
+      {\r
+        ver[i]="0"+ver[i];\r
+      }\r
+  }\r
+\r
+  var packageVersion = "\""+ver[0]+"."+ver[1]+"."+ver[2]+"."+ver[3]+"\"";\r
+\r
+%%}\r
+\r
+module Settings\r
+{\r
+    config string fvid2VersionString = `packageVersion`;\r
+\r
+    /*! This variable is to control the SoC type selection.\r
+     * By default this variable is set to NULL.\r
+     *\r
+     * To use FVID2 for the selected device, add the following lines to config\r
+     * file and set the deviceType correctly:\r
+     *\r
+     *      var fvid2Settings = xdc.useModule ('ti.drv.fvid2.Settings');\r
+     *      fvid2Settings.socType = "am65x";\r
+     *\r
+     */\r
+    metaonly config string socType = "";\r
+\r
+    /*! This variable is to control the device library type selection.\r
+     * By default this variable is set to release.\r
+     *\r
+     * To use the debug/release library, add the following lines to config\r
+     * file and set the library profile accordingly:\r
+     *\r
+     *      var fvid2 Settings = xdc.useModule ('ti.drv.fvid2.Settings');\r
+     *      fvid2Settings.libProfile = "debug";\r
+     *\r
+     */\r
+    metaonly config string libProfile = "release";\r
+}\r
+\r
diff --git a/config_mk.bld b/config_mk.bld
new file mode 100644 (file)
index 0000000..62a360c
--- /dev/null
@@ -0,0 +1,18 @@
+/******************************************************************************\r
+ * FILE PURPOSE: Build configuration Script for the FVID2 Driver\r
+ ******************************************************************************\r
+ * FILE NAME: config.bld\r
+ *\r
+ * DESCRIPTION: \r
+ *  This file contains the build configuration script for the FVID2 driver\r
+ *  and is responsible for configuration of the paths for the various \r
+ *  tools required to build the driver.\r
+ *\r
+ * Copyright (C) 2018, Texas Instruments, Inc.\r
+ *****************************************************************************/\r
+\r
+/* Configure the FVID2 Release Version Information */\r
+var fvid2DriverReleaseVersion = (""+Pkg.version.replace(/\s/g, "")).split(',');\r
+\r
+var Build = xdc.useModule('xdc.bld.BuildEnvironment');\r
+Build.useTargets=null;\r
diff --git a/fvid2.h b/fvid2.h
index 1cbe34abf69a0d34afc9f0368998b0cdf2c177cc..2470d591811953d6eb1e391f095899032437910f 100644 (file)
--- a/fvid2.h
+++ b/fvid2.h
 /**
  *  \file fvid2.h
  *
- *  \brief FVID2 API
- *
- *  FVID2 API is an interface which is used to create, control and use different
- *  video drivers. FVID2 API is used not only for on-chip
- *  peripherals drivers like capture, display but also for external off-chip
- *  video device peripherals like video decoders, video encoders and
- *  video sensors.
- *
- *  All video drivers and external video peripherals implement the FVID2
- *  API.
- *  Many drivers also extend the FVID2 interface by defining their own driver
- *  specific IOCTLs.
- *
- *  <b> All FVID2 API must be called from task context </b>. Some examples
- *  in the package maybe calling FVID2 APIs from callback and/or
- *  interrupt context. Such examples will be modified in subsequent releases
- *  and in order that user application do not have to do special migration it
- *  is strongly recommended to use FVID2 APIs only from task context.
- *
- *  A FVID2 API can be of two kinds,
- *
- *  - <b> Blocking API </b> <br>
- *    Here the FVID2 API call returns only after completing the request or
- *    functionality or if timed out or if some other error occurs.
- *    The below APIs are always blocking, unless specified otherwise by
- *    specific driver.
- *    - Fvid2_create()
- *    - Fvid2_delete()
- *    - Fvid2_start()
- *    - Fvid2_stop()
- *    - Fvid2_control()
- *    - Fvid2_setFormat()
- *    - Fvid2_getFormat()
- *
- *  - <b> Non-blocking API </b> <br>
- *    Here FVID2 API call queues the request to the driver and returns
- *    immediately before the request is processed or completed.
- *    Application should use the completion callback to wait for request
- *    completion.
- *    The below APIs are always non-blocking, unless specified otherwise by
- *    specific driver.
- *    - Fvid2_queue()
- *    - Fvid2_dequeue()
- *    - Fvid2_processFrames()
- *    - Fvid2_getProcessedFrames()
- *
- *  A FVID2 Driver can belong to one the below categories. The FVID2 APIs
- *  applicable to driver in a category are also listed below. The below is
- *  true for most driver unless specified otherwise by a specific driver.
- *  - <b> Streaming interface drivers </b> <br>
- *  Examples include, capture, display, graphics.
- *  Below FVID2 APIs are implemented by such drivers.
- *    - Fvid2_create()
- *    - Fvid2_delete()
- *    - Fvid2_start()
- *    - Fvid2_stop()
- *    - Fvid2_queue()
- *    - Fvid2_dequeue()
- *    - Fvid2_control()
- *    - Fvid2_setFormat() - OPTIONAL
- *    - Fvid2_getFormat() - OPTIONAL
- *
- *  - <b> Memory to memory processing interface drivers </b> <br>
- *   Examples include, M2M VPE.
- *   Below FVID2 APIs are implemented by such drivers.
- *    - Fvid2_create()
- *    - Fvid2_delete()
- *    - Fvid2_processFrames()
- *    - Fvid2_getProcessedFrames()
- *    - Fvid2_control()
- *    - Fvid2_setFormat() - OPTIONAL
- *    - Fvid2_getFormat() - OPTIONAL
- *
- *  - <b> Control interface drivers </b> <br>
- *   Examples include, display controller, external video devices.
- *   Below FVID2 APIs are implemented by such drivers.
- *    - Fvid2_create()
- *    - Fvid2_delete()
- *    - Fvid2_control()
- *    - Fvid2_start()
- *    - Fvid2_stop()
- *    - Fvid2_setFormat() - OPTIONAL
- *    - Fvid2_getFormat() - OPTIONAL
- *
- *  Before making any FVID2 API calls, Fvid2_init() must be called.
- *  Fvid2_deInit() must be called during system shutdown.
- *
- *  Fvid2_getVersionString() and Fvid2_getVersionNumber() can be used to get
- *  information about current driver version number.
- *
- *  All FVID2 drivers are of type Fvid2_Handle, which gets created when
- *  Fvid2_create() is called. This handle is used for all subsequent FVID2
- *  API calls. This handle and its associated resources are free'ed when
- *  Fvid2_delete() is called.
- *
- *  All FVID2 APIs make use of Fvid2_Frame, Fvid2_FrameList and/or
- *  Fvid2_ProcessList for exchanging and processing video frames via a driver.
- *  Further all drivers use a common user callback mechanism via Fvid2_CbParams
- *  to indicate to the user that a frame is ready. Many drivers, but not all,
- *  use the Fvid2_Format data structure to describe video input, output data
- *  formats.
- *
- *  All drivers use the constants, enum's, error codes defined in this file to
- *  control and configure a driver.
- *
- *  In addition, most drivers define driver specific create time parameters
- *  and IOCTLs to allow the user to control and configure the driver in driver
- *  specific ways. Further a driver may define driver specific run-time
- *  parameters which are passed by user to the driver via
- *  Fvid2_Frame.perFrameCfg and/or Fvid2_FrameList.perListCfg.
- *
- *  Also user application can associate user specific app data with a
- *  driver handle via Fvid2_CbParams.appData or with every frame via
- *  FIVD2_Frame.appData. The app data set as part of Fvid2_CbParams returned
- *  back to user when callback occurs. The app data set as part of Fvid2_Frame
- *  is returned back to the user when the Fvid2_Frame itself is returned back to
- *  user via Fvid2_dequeue() or Fvid2_getProcessedFrames(). The driver will not
- *  modify this app data. This could be used by the application to store any
- *  application specific data like application object info and so on.
- *
- */
-
-/*
- *  \version 0.1    Created.
- *           0.2    Changes for BIOS 6 and new FVID2 interface.
- *           0.2.1  Merged color and data format enums to data format enums.
- *                  Added process list structure to support M2M
- *                  (memory to memory) drivers.
- *                  Removed FVID2_Buf structure and directly used address array
- *                  in Fvid2_Frame structure.
- *                  Defined proper signature for FVID2 APIs.
- *           0.2.2  Added proper comments.
- *           0.3    Added subframe callback and added reserved fields in all the
- *                  structures.
- *           0.4    Made frames pointer to pointer to array of frame pointer in
- *                  framelist to simplify application allocation and ease of
- *                  use.
- *           0.5    Added FVID2 standard enums.
- *           0.6    Split into two files. fvid2.h will contain only FVID2 driver
- *                  specific defintions/declarations. It will include
- *                  fvid2_dataTypes.h for data type defintions
- *           1.0    Removed reserved fields as this is not used anywhere and
- *                  changed Ptr to void*, changed types to stdint.h types.
+ *  \brief FVID2 top level include file
  *
  */
 
 #include <ti/csl/csl_fvid2_dataTypes.h>
 #include <ti/drv/fvid2/include/trace.h>
 #include <ti/drv/fvid2/include/fvid2_utils.h>
+#include <ti/drv/fvid2/include/fvid2_api.h>
+#include <ti/drv/fvid2/include/fvid2_drvMgr.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -198,567 +58,19 @@ extern "C" {
 /*                           Macros & Typedefs                                */
 /* ========================================================================== */
 
-/**
- *  \brief FVID2 driver version string.
- *  Version is of the form mm_nn_xx_yy where,
- *      mm - Product version (02 for FVID2). This increments for any new FVID2
- *           versions.
- *      nn - Major number - Increments if any backward compatibility is broken
- *           or major change within a product version.
- *      xx - Minor number - Increments for any minor change or any additions
- *           done without breaking backward compatibility.
- *      yy - Build number - Increments for every release.
- */
-#define FVID2_VERSION_STRING            "FVID_02_02_00_00"
-
-/** \brief FVID2 driver version number. */
-#define FVID2_VERSION_NUMBER            (0x02020000U)
-
-/** \brief FVID2 Driver handle. */
-typedef void *Fvid2_Handle;
-
-/**
- *  \brief FVID2 driver callback function prototype.
- *
- *  This callback is used by the drivers which implement non-blocking
- *  FVID2 APIs.
- *
- *  User should assume that callbacks happen in ISR context and hence should
- *  apply rules relevant to ISR context when implementing callback functions,
- *  i.e blocking APIs should not be called from callback. Users should also
- *  assume that interrupts are enabled when in callback context, i.e other
- *  interrupt / callbacks can occur when a callback is under execution.
- *  User callback implementation should not be very long, since callback
- *  execution may block other drivers from executing. Typically it is
- *  recommended to set a semaphore or flag when callback happens and do the
- *  more involved callback handling in task context.
- *
- *  This callback is typically called by the driver as mentioned below,
- *  unless specified otherwise by specific drivers.
- *
- *  In case of display drivers, this callback function will be called
- *  when a frame(s) is/are completed displayed. Then the application can
- *  dequeue the displayed buffer back from the driver.
- *
- *  In case of capture drivers, this callback function will be called
- *  when a frame(s) is/are captured. Then the application can dequeue the
- *  captured buffer back from the driver.
- *
- *  In case of M2M drivers, this callback function will be called
- *  when a request from the application is completed by the driver. Then the
- *  application can dequeue the completed request buffers back from the driver.
- *
- *  In case of control drivers, callbacks are typically not used since mostly
- *  FVID2 APIs implemented by control drivers are of blocking nature.
- *
- *  \param handle   [OUT] FVID2 handle for which the callback has occurred.
- *  \param appData  [OUT] Application data provided to the driver at the
- *                        time of Fvid2_create().
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-typedef int32_t (*Fvid2_CbFxn)(Fvid2_Handle handle, void *appData);
-
-/**
- *  \brief FVID2 error callback function prototype.
- *
- *  Error callback is called by driver when it encounters a error during
- *  processing of frames in its internal queue.
- *
- *  When user submits frames to the driver it does minimal error checks and
- *  stores the the frames in its internal queues. In case of any error at
- *  this point the FVID2 API will simply return error and error callback
- *  will not be called.
- *
- *  The driver will later (depending on how its request queue is full) process
- *  these frames submitted by the user. If driver finds any error in either
- *  the input frame information or hardware itself then it will call this error
- *  callback to notify the user about this error. As part of the callback
- *  information it also returns the frames or request for which error happened
- *  so that user can take appropriate action.
- *
- *  Users should apply same rules as that of Fvid2_CbFxn when implementing
- *  error callbacks.
- *
- *  \param handle   [OUT] FVID2 handle for which the callback has occurred.
- *  \param appData  [OUT] Application data provided to the driver at the time
- *                        of Fvid2_create().
- *  \param errList  [OUT] Pointer to a valid framelist (Fvid2_FrameList)
- *                        in case of capture and display drivers or a pointer
- *                        to a valid processlist (Fvid2_ProcessList) in case of
- *                        M2M drivers. The driver copies the aborted/error
- *                        frames in this frame list or process list.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-typedef int32_t (*Fvid2_ErrCbFxn)(Fvid2_Handle handle,
-                                  void        *appData,
-                                  void        *errList);
-
-/**
- *  \brief FVID2 callback that is called by subframe mode Capture driver.
- *
- *  This callback is called for every subframe of frame that
- *  is captured. This function is used by Capture Driver and not meant for M2M
- *  drivers.
- *
- *  Users should apply same rules as that of Fvid2_CbFxn when implementing
- *  subframe callbacks.
- *
- *  \param handle       [OUT] FVID2 handle for which this callback happened.
- *  \param subFrameInfo [OUT] SubFrame information.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-typedef int32_t (*Fvid2_SubFrameCbFxn)(Fvid2_Handle handle,
-                                       Fvid2_Frame *subFrame);
-
-/**
- *  \name FVID2 Max limits
- *  @{
- */
-
-/** \brief Decide the streamid based on channel number.  */
-#define FVID2_STREAM_ID_ANY             (0xFFFFFFFFU)
-
-/* @} */
-
-/*
- * =========== Command codes for Submit call =============
- */
-/** \brief Control command base address. */
-#define FVID2_CTRL_BASE                 (0x00000000U)
-/** \brief User command base address. */
-#define FVID2_USER_BASE                 (0x10000000U)
-
-/**
- *  \addtogroup BSP_DRV_IOCTL_FVID2
- *  @{
- */
-
-/**
- *  \brief Control command used by Fvid2_setFormat()
- *
- *  \param cmdArgs       [IN]  const Fvid2_Format *
- *  \param cmdStatusArgs [OUT] NULL
- *
- *  \return FVID2_SOK on success, else failure.
- */
-#define FVID2_SET_FORMAT                ((uint32_t) FVID2_CTRL_BASE + 3U)
-
-/**
- *  \brief Control command used by Fvid2_getFormat()
- *
- *  \param cmdArgs       [IN]  Fvid2_Format *
- *  \param cmdStatusArgs [OUT] NULL
- *
- *  \return FVID2_SOK on success, else failure.
- */
-#define FVID2_GET_FORMAT                ((uint32_t) FVID2_CTRL_BASE + 4U)
-
-/**
- *  \brief Control command used by Fvid2_start()
- *
- *  \param cmdArgs       [IN]  Driver specific
- *  \param cmdStatusArgs [OUT] NULL
- *
- *  \return FVID2_SOK on success, else failure.
- */
-#define FVID2_START                     ((uint32_t) FVID2_CTRL_BASE + 5U)
-
-/**
- *  \brief Control command used by Fvid2_stop()
- *
- *  \param cmdArgs       [IN]  Driver specific
- *  \param cmdStatusArgs [OUT] NULL
- *
- *  \return FVID2_SOK on success, else failure.
- */
-#define FVID2_STOP                      ((uint32_t) FVID2_CTRL_BASE + 6U)
-
-/* @} */
-
-/* ========================================================================== */
-/*                         Structure Declarations                             */
-/* ========================================================================== */
-
-/**
- *  \brief FVID2 callback parameters that are setup during Fvid2_create().
- */
-typedef struct
-{
-    Fvid2_CbFxn    cbFxn;
-    /**< Application callback function used by the driver to intimate any
-     *   operation has completed or not. This is an optional parameter
-     *   in case application decides to use polling method and so could be
-     *   set to NULL. */
-
-    Fvid2_ErrCbFxn errCbFxn;
-    /**< Application error callback function used by the driver to intimate
-     *   any error occurs at the time of streaming. This is an optional
-     *   parameter in case application decides not to get any error callback
-     *   and so could be set to NULL. */
-
-    void           *errList;
-    /**< Pointer to a valid Fvid2_FrameList in case of capture
-     *   and display drivers or a pointer to a valid Fvid2_ProcessList
-     *   in case of M2M drivers where the driver copies
-     *   the aborted/error packet. The memory of this list should be
-     *   allocated by the application and provided to the driver at the time
-     *   of driver creation. When the application gets this callback, it has
-     *   to empty this list and taken necessary action like freeing up memories
-     *   etc. The driver will then reuse the same list for future error
-     *   callback.
-     *   This could be NULL if errCbFxn is NULL. Otherwise this should be
-     *   non-NULL. */
-
-    void           *appData;
-    /**< Application specific data which is returned in the callback function
-     *   as it is. This could be set to NULL if not used. */
-} Fvid2_CbParams;
+/* None */
 
 /* ========================================================================== */
 /*                          Function Declarations                             */
 /* ========================================================================== */
 
-/**
- *  \brief FVID2 init function.
- *
- *  Initializes the FVID2 layer.
- *  This function should be called before calling any of FVID2 API's and
- *  should be called only once.
- *
- *  \param args         [IN] Not used currently. Set to NULL.
- *
- *  \return FVID2_SOK on success else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_init(void *args);
-
-/**
- *  \brief FVID2 deinit function.
- *
- *  Uninitializes the FVID2 layer and should be called during system shutdown.
- *  Should not be called if Fvid2_init() is not called.
- *
- *  \param args         [IN] Not used currently. Set to NULL.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_deInit(void *args);
-
-/**
- *  \brief Get the version string for FVID2 interface.
- *
- *  This is the version number for the FVID2 interface. This
- *  function can be called prior to #Fvid2_init() to get the version number.
- *
- *  \return Pointer to FVID2 version string.
- */
-const char *Fvid2_getVersionString(void);
-
-/**
- *  \brief Same as #Fvid2_getVersionString() except it returns the version in
- *  uint32_t form.
- *
- *  Example, v1.0.1.17 will be 0x01000117
- *
- *  \return FVID2 version number.
- */
-uint32_t Fvid2_getVersionNumber(void);
-
-/**
- *  \brief Creates the driver identified by the driver ID.
- *
- *  This will allocate HW and/or SW resources and return a Fvid2_Handle
- *  for this driver. This handle will be used for subsequent FVID2 API calls
- *
- *  \param drvId        [IN] Driver to open. Driver ID is driver specific.
- *
- *  \param instanceId   [IN] Instance of the driver to open and is used
- *                      to differentiate multiple instance support on a
- *                      single driver. Instance ID is driver specific.
- *
- *  \param createArgs   [IN] Pointer to the create argument structure. The type
- *                      of the structure is defined by the specific driver.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \param createStatusArgs [OUT] Pointer to status argument structure where the
- *                      driver returns any status information. The type
- *                      of the structure is defined by the specific driver.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \param cbParams     [IN] Application callback parameters.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \return non-NULL Fvid2_Handle object pointer on success else returns NULL
- *  on error.
- */
-Fvid2_Handle Fvid2_create(uint32_t              drvId,
-                          uint32_t              instanceId,
-                          void                 *createArgs,
-                          void                 *createStatusArgs,
-                          const Fvid2_CbParams *cbParams);
-
-/**
- *  \brief Deletes a previously created FVID2 driver handle.
- *
- *  This free's the HW/SW resources allocated during create
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *
- *  \param deleteArgs   [IN] Pointer to the delete argument structure. The type
- *                      of the structure is defined by the specific driver.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs);
-
-/**
- *  \brief Send control commands (IOCTLs) to the driver.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *
- *  \param cmd          [IN] IOCTL command. The type of command supported
- *                      is defined by the specific driver.
- *
- *  \param cmdArgs      [IN] Pointer to the command argument structure. The type
- *                      of the structure is defined by the specific driver
- *                      for each of the supported IOCTL.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \param cmdStatusArgs [OUT] Pointer to status argument structure where the
- *                      driver returns any status information. The type
- *                      of the structure is defined by the specific driver
- *                      for each of the supported IOCTL.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_control(Fvid2_Handle  handle,
-                      uint32_t      cmd,
-                      void         *cmdArgs,
-                      void         *cmdStatusArgs);
-
-/**
- *  \brief An application calls Fvid2_queue to submit a video buffer to the
- *  video device driver.
- *
- *  - This is used in capture/display drivers.
- *  - This function could be called from task or ISR context unless the specific
- *  driver restricts from doing so.
- *  - This is a non-blocking API unless the specific driver restricts from
- *  doing so.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param frameList    [IN] Pointer to the frame list structure containing the
- *                      information about the FVID2 frames that has to be
- *                      queued in the driver.
- *  \param streamId     [IN] Stream ID to which the frames should be queued
- *                      This is used in drivers where they could support
- *                      multiple streams for the same handle. Otherwise this
- *                      should be set to zero.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_queue(Fvid2_Handle        handle,
-                    Fvid2_FrameList    *frameList,
-                    uint32_t            streamId);
-
-/**
- *  \brief An application calls Fvid2_dequeue to request the video device
- *  driver to give ownership of a video buffer.
- *
- *  - This is used in capture/display drivers.
- *  - This is a non-blocking API if timeout is FVID2_TIMEOUT_NONE and could be
- *  called by task and ISR context unless the specific driver restricts from
- *  doing so.
- *  - This is blocking API if timeout is FVID2_TIMEOUT_FOREVER if supported by
- *  specific driver implementation.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param frameList    [OUT] Pointer to the frame list structure where the
- *                      dequeued frame pointer will be stored.
- *  \param streamId     [IN] Stream ID from where frames should be dequeued.
- *                      This is used in drivers where it could support multiple
- *                      streams for the same handle. Otherwise this
- *                      should be set to zero.
- *  \param timeout      [IN] FVID2 timeout in units of OS ticks. This will
- *                      determine the timeout value till the driver will block
- *                      for a free or completed buffer is available.
- *                      For non-blocking drivers this parameter might be
- *                      ignored.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_dequeue(Fvid2_Handle      handle,
-                      Fvid2_FrameList  *frameList,
-                      uint32_t          streamId,
-                      uint32_t          timeout);
-
-/**
- *  \brief An application calls Fvid2_processRequest to submit a video buffer
- *  to the video device driver.
- *
- *  This API is used for submitting a single channel video processing request
- *  to the video device driver. It uses framelist to submit multiple
- *  frames of different stream ids of the same request.
- *
- *  - This function could be called from task or ISR context unless the specific
- *  driver restricts from doing so.
- *  - This is a non-blocking API unless the specific driver restricts from
- *  doing so.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param inFrameList  [IN] Pointer to the array of input frames with
- *                           different stream ids.
- *  \param outFrameList [IN] Pointer to the array of output frames with
- *                           different stream ids
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_processRequest(Fvid2_Handle       handle,
-                             Fvid2_FrameList   *inFrameList,
-                             Fvid2_FrameList   *outFrameList);
-
-/**
- *  \brief An application calls Fvid2_getProcessedRequest to get the
- *  processed request back from the driver and thus to get the
- *  ownership of request back from the driver.
- *
- *  - This is a non-blocking API if timeout is FVID2_TIMEOUT_NONE and could be
- *  called by task and ISR context unless the specific driver restricts from
- *  doing so.
- *  - This is blocking API if timeout is FVID2_TIMEOUT_FOREVER if supported by
- *  specific driver implementation.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param inFrameList  [OUT] Pointer to frame list in which input frames with
- *                            different stream ids will be returned
- *                            by the driver.
- *  \param outFrameList [OUT] Pointer to frame list in which output frames with
- *                            different stream ids will be returned by
- *                            the driver.
- *  \param timeout      [IN] FVID2 timeout. This will determine the timeout
- *                           value till the driver will block for a
- *                           free or completed buffer is available.
- *                           For non-blocking drivers this parameter
- *                           might be ignored.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-int32_t Fvid2_getProcessedRequest(Fvid2_Handle      handle,
-                                  Fvid2_FrameList  *inFrameList,
-                                  Fvid2_FrameList  *outFrameList,
-                                  uint32_t          timeout);
-/**
- *  \brief An application calls Fvid2_start to request the video device
- *  driver to start the video display or capture operation.
- *  This function should be called from task context only and should not be
- *  called from ISR context.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param cmdArgs      [IN] Pointer to the start argument structure. The type
- *                      of the structure is defined by the specific driver.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-static inline int32_t Fvid2_start(Fvid2_Handle handle, void *cmdArgs);
-
-/**
- *  \brief An application calls Fvid2_stop to request the video device
- *  driver to stop the video display or capture operation.
- *  This function should be called from task context only and should not be
- *  called from ISR context.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param cmdArgs      [IN] Pointer to the stop argument structure. The type
- *                      of the structure is defined by the specific driver.
- *                      This parameter could be NULL depending on whether the
- *                      actual driver forces it or not.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-static inline int32_t Fvid2_stop(Fvid2_Handle handle, void *cmdArgs);
-
-/**
- *  \brief An application calls Fvid2_setFormat to request the video device
- *  driver to set the format for a given channel.
- *  This function should be called from task context only and should not be
- *  called from ISR context.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param fmt          [IN] Pointer to the FVID2 format structure.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-static inline int32_t Fvid2_setFormat(Fvid2_Handle handle, Fvid2_Format *fmt);
-
-/**
- *  \brief An application calls Fvid2_getFormat to request the video device
- *  driver to get the current format for a given channel.
- *  This function should be called from task context only and should not be
- *  called from ISR context.
- *
- *  \param handle       [IN] FVID2 handle returned by create call.
- *  \param fmt          [OUT] Pointer to the FVID2 format structure.
- *
- *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
- */
-static inline int32_t Fvid2_getFormat(Fvid2_Handle handle, Fvid2_Format *fmt);
-
-/**
- *  \brief Fvid2_CbParams structure init function.
- *
- *  \param cbPrms       [IN] Pointer to #Fvid2_CbParams structure.
- *
- */
-static inline void Fvid2CbParams_init(Fvid2_CbParams *cbPrms);
+/* None */
 
 /* ========================================================================== */
 /*                       Static Function Definitions                          */
 /* ========================================================================== */
 
-static inline int32_t Fvid2_start(Fvid2_Handle handle, void *cmdArgs)
-{
-    return Fvid2_control(handle, FVID2_START, cmdArgs, NULL);
-}
-
-static inline int32_t Fvid2_stop(Fvid2_Handle handle, void *cmdArgs)
-{
-    return Fvid2_control(handle, FVID2_STOP, cmdArgs, NULL);
-}
-
-static inline int32_t Fvid2_setFormat(Fvid2_Handle handle, Fvid2_Format *fmt)
-{
-    return Fvid2_control(handle, FVID2_SET_FORMAT, fmt, NULL);
-}
-
-static inline int32_t Fvid2_getFormat(Fvid2_Handle handle, Fvid2_Format *fmt)
-{
-    return Fvid2_control(handle, FVID2_GET_FORMAT, fmt, NULL);
-}
-
-static inline void Fvid2CbParams_init(Fvid2_CbParams *cbPrms)
-{
-    if (NULL != cbPrms)
-    {
-        cbPrms->cbFxn    = NULL;
-        cbPrms->errCbFxn = NULL;
-        cbPrms->errList  = NULL;
-        cbPrms->appData  = NULL;
-    }
-
-    return;
-}
+/* None */
 
 #ifdef __cplusplus
 }
@@ -766,4 +78,3 @@ static inline void Fvid2CbParams_init(Fvid2_CbParams *cbPrms)
 
 #endif  /* #ifndef FVID2_H_ */
 
-/* @} */
diff --git a/fvid2ver.h b/fvid2ver.h
new file mode 100644 (file)
index 0000000..e8f2ec1
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef FVID2VER_H
+#define FVID2VER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================= */
+/**
+ *   @file  fvid2ver.h
+ *
+ *   path  ti/drv/fvid2/fvid2ver.h
+ *
+ *   @brief  FVID2 Driver Version Definitions
+ *
+ *  ============================================================
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+*/
+
+/**
+ * @brief   This is the FVID2 Driver Version. Versions numbers are encoded in the following
+ * format:
+ *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
+ */
+#define FVID2_DRV_VERSION_ID                     (0x01000000)
+
+/**
+ * @brief   This is the version string which describes the FVID2 driver along with the
+ * date and build information.
+ */
+#define FVID2_DRV_VERSION_STR                    "FVID2 Driver Revision: 01.00.00.00"
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  /* FVID2VER_H */
diff --git a/fvid2ver.h.xdt b/fvid2ver.h.xdt
new file mode 100644 (file)
index 0000000..eaa65f8
--- /dev/null
@@ -0,0 +1,100 @@
+%%{
+/*!
+ *  This template implements the fvid2ver.h
+ */
+  /* Versioning */
+  var ver = this;
+  var ver1 = [00,00,00,00];
+  var ver2 = [00,00,00,00];
+
+  for each(i=0;i<ver.length;i++)
+  {
+      if(String(ver[i]).length < 2)
+      {
+        ver1[i]="0"+ver[i];
+      }
+      else
+      {
+        ver1[i] = ver[i];
+      }
+
+      ver2[i] = Number(ver[i]).toString(16).toUpperCase();
+
+      if(String(ver2[i]).length < 2)
+      {
+        ver2[i]="0"+ver2[i];
+      }
+  }
+
+  var versionStr = "\""+"FVID2 Driver Revision: "+ver1[0]+"."+ver1[1]+"."+ver1[2]+"."+ver1[3]+"\"";
+  var versionID = "(0x"+ver2[0]+ver2[1]+ver2[2]+ver2[3]+")";
+
+%%}
+#ifndef FVID2VER_H
+#define FVID2VER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================= */
+/**
+ *   @file  fvid2ver.h
+ *
+ *   path  ti/drv/fvid2/fvid2ver.h
+ *
+ *   @brief  FVID2 Driver Version Definitions
+ *
+ *  ============================================================
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+*/
+
+/**
+ * @brief   This is the FVID2 Driver Version. Versions numbers are encoded in the following
+ * format:
+ *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
+ */
+#define FVID2_DRV_VERSION_ID                     `versionID`
+
+/**
+ * @brief   This is the version string which describes the FVID2 driver along with the
+ * date and build information.
+ */
+#define FVID2_DRV_VERSION_STR                    `versionStr`
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  /* FVID2VER_H */
diff --git a/include/fvid2_api.h b/include/fvid2_api.h
new file mode 100644 (file)
index 0000000..3ccdb40
--- /dev/null
@@ -0,0 +1,769 @@
+/*
+ *  Copyright (c) Texas Instruments Incorporated 2018
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  \file fvid2_api.h
+ *
+ *  \brief FVID2 API
+ *
+ *  FVID2 API is an interface which is used to create, control and use different
+ *  video drivers. FVID2 API is used not only for on-chip
+ *  peripherals drivers like capture, display but also for external off-chip
+ *  video device peripherals like video decoders, video encoders and
+ *  video sensors.
+ *
+ *  All video drivers and external video peripherals implement the FVID2
+ *  API.
+ *  Many drivers also extend the FVID2 interface by defining their own driver
+ *  specific IOCTLs.
+ *
+ *  <b> All FVID2 API must be called from task context </b>. Some examples
+ *  in the package maybe calling FVID2 APIs from callback and/or
+ *  interrupt context. Such examples will be modified in subsequent releases
+ *  and in order that user application do not have to do special migration it
+ *  is strongly recommended to use FVID2 APIs only from task context.
+ *
+ *  A FVID2 API can be of two kinds,
+ *
+ *  - <b> Blocking API </b> <br>
+ *    Here the FVID2 API call returns only after completing the request or
+ *    functionality or if timed out or if some other error occurs.
+ *    The below APIs are always blocking, unless specified otherwise by
+ *    specific driver.
+ *    - Fvid2_create()
+ *    - Fvid2_delete()
+ *    - Fvid2_start()
+ *    - Fvid2_stop()
+ *    - Fvid2_control()
+ *    - Fvid2_setFormat()
+ *    - Fvid2_getFormat()
+ *
+ *  - <b> Non-blocking API </b> <br>
+ *    Here FVID2 API call queues the request to the driver and returns
+ *    immediately before the request is processed or completed.
+ *    Application should use the completion callback to wait for request
+ *    completion.
+ *    The below APIs are always non-blocking, unless specified otherwise by
+ *    specific driver.
+ *    - Fvid2_queue()
+ *    - Fvid2_dequeue()
+ *    - Fvid2_processFrames()
+ *    - Fvid2_getProcessedFrames()
+ *
+ *  A FVID2 Driver can belong to one the below categories. The FVID2 APIs
+ *  applicable to driver in a category are also listed below. The below is
+ *  true for most driver unless specified otherwise by a specific driver.
+ *  - <b> Streaming interface drivers </b> <br>
+ *  Examples include, capture, display, graphics.
+ *  Below FVID2 APIs are implemented by such drivers.
+ *    - Fvid2_create()
+ *    - Fvid2_delete()
+ *    - Fvid2_start()
+ *    - Fvid2_stop()
+ *    - Fvid2_queue()
+ *    - Fvid2_dequeue()
+ *    - Fvid2_control()
+ *    - Fvid2_setFormat() - OPTIONAL
+ *    - Fvid2_getFormat() - OPTIONAL
+ *
+ *  - <b> Memory to memory processing interface drivers </b> <br>
+ *   Examples include, M2M VPE.
+ *   Below FVID2 APIs are implemented by such drivers.
+ *    - Fvid2_create()
+ *    - Fvid2_delete()
+ *    - Fvid2_processFrames()
+ *    - Fvid2_getProcessedFrames()
+ *    - Fvid2_control()
+ *    - Fvid2_setFormat() - OPTIONAL
+ *    - Fvid2_getFormat() - OPTIONAL
+ *
+ *  - <b> Control interface drivers </b> <br>
+ *   Examples include, display controller, external video devices.
+ *   Below FVID2 APIs are implemented by such drivers.
+ *    - Fvid2_create()
+ *    - Fvid2_delete()
+ *    - Fvid2_control()
+ *    - Fvid2_start()
+ *    - Fvid2_stop()
+ *    - Fvid2_setFormat() - OPTIONAL
+ *    - Fvid2_getFormat() - OPTIONAL
+ *
+ *  Before making any FVID2 API calls, Fvid2_init() must be called.
+ *  Fvid2_deInit() must be called during system shutdown.
+ *
+ *  Fvid2_getVersionString() and Fvid2_getVersionNumber() can be used to get
+ *  information about current driver version number.
+ *
+ *  All FVID2 drivers are of type Fvid2_Handle, which gets created when
+ *  Fvid2_create() is called. This handle is used for all subsequent FVID2
+ *  API calls. This handle and its associated resources are free'ed when
+ *  Fvid2_delete() is called.
+ *
+ *  All FVID2 APIs make use of Fvid2_Frame, Fvid2_FrameList and/or
+ *  Fvid2_ProcessList for exchanging and processing video frames via a driver.
+ *  Further all drivers use a common user callback mechanism via Fvid2_CbParams
+ *  to indicate to the user that a frame is ready. Many drivers, but not all,
+ *  use the Fvid2_Format data structure to describe video input, output data
+ *  formats.
+ *
+ *  All drivers use the constants, enum's, error codes defined in this file to
+ *  control and configure a driver.
+ *
+ *  In addition, most drivers define driver specific create time parameters
+ *  and IOCTLs to allow the user to control and configure the driver in driver
+ *  specific ways. Further a driver may define driver specific run-time
+ *  parameters which are passed by user to the driver via
+ *  Fvid2_Frame.perFrameCfg and/or Fvid2_FrameList.perListCfg.
+ *
+ *  Also user application can associate user specific app data with a
+ *  driver handle via Fvid2_CbParams.appData or with every frame via
+ *  FIVD2_Frame.appData. The app data set as part of Fvid2_CbParams returned
+ *  back to user when callback occurs. The app data set as part of Fvid2_Frame
+ *  is returned back to the user when the Fvid2_Frame itself is returned back to
+ *  user via Fvid2_dequeue() or Fvid2_getProcessedFrames(). The driver will not
+ *  modify this app data. This could be used by the application to store any
+ *  application specific data like application object info and so on.
+ *
+ */
+
+/*
+ *  \version 0.1    Created.
+ *           0.2    Changes for BIOS 6 and new FVID2 interface.
+ *           0.2.1  Merged color and data format enums to data format enums.
+ *                  Added process list structure to support M2M
+ *                  (memory to memory) drivers.
+ *                  Removed FVID2_Buf structure and directly used address array
+ *                  in Fvid2_Frame structure.
+ *                  Defined proper signature for FVID2 APIs.
+ *           0.2.2  Added proper comments.
+ *           0.3    Added subframe callback and added reserved fields in all the
+ *                  structures.
+ *           0.4    Made frames pointer to pointer to array of frame pointer in
+ *                  framelist to simplify application allocation and ease of
+ *                  use.
+ *           0.5    Added FVID2 standard enums.
+ *           0.6    Split into two files. fvid2.h will contain only FVID2 driver
+ *                  specific defintions/declarations. It will include
+ *                  fvid2_dataTypes.h for data type defintions
+ *           1.0    Removed reserved fields as this is not used anywhere and
+ *                  changed Ptr to void*, changed types to stdint.h types.
+ *
+ */
+
+#ifndef FVID2_API_H_
+#define FVID2_API_H_
+
+/* ========================================================================== */
+/*                             Include Files                                  */
+/* ========================================================================== */
+
+#include <ti/csl/csl_fvid2_dataTypes.h>
+#include <ti/drv/fvid2/include/trace.h>
+#include <ti/drv/fvid2/include/fvid2_utils.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ========================================================================== */
+/*                           Macros & Typedefs                                */
+/* ========================================================================== */
+
+/**
+ *  \brief FVID2 driver version string.
+ *  Version is of the form mm_nn_xx_yy where,
+ *      mm - Product version (02 for FVID2). This increments for any new FVID2
+ *           versions.
+ *      nn - Major number - Increments if any backward compatibility is broken
+ *           or major change within a product version.
+ *      xx - Minor number - Increments for any minor change or any additions
+ *           done without breaking backward compatibility.
+ *      yy - Build number - Increments for every release.
+ */
+#define FVID2_VERSION_STRING            "FVID_02_02_00_00"
+
+/** \brief FVID2 driver version number. */
+#define FVID2_VERSION_NUMBER            (0x02020000U)
+
+/** \brief FVID2 Driver handle. */
+typedef void *Fvid2_Handle;
+
+/**
+ *  \brief FVID2 driver callback function prototype.
+ *
+ *  This callback is used by the drivers which implement non-blocking
+ *  FVID2 APIs.
+ *
+ *  User should assume that callbacks happen in ISR context and hence should
+ *  apply rules relevant to ISR context when implementing callback functions,
+ *  i.e blocking APIs should not be called from callback. Users should also
+ *  assume that interrupts are enabled when in callback context, i.e other
+ *  interrupt / callbacks can occur when a callback is under execution.
+ *  User callback implementation should not be very long, since callback
+ *  execution may block other drivers from executing. Typically it is
+ *  recommended to set a semaphore or flag when callback happens and do the
+ *  more involved callback handling in task context.
+ *
+ *  This callback is typically called by the driver as mentioned below,
+ *  unless specified otherwise by specific drivers.
+ *
+ *  In case of display drivers, this callback function will be called
+ *  when a frame(s) is/are completed displayed. Then the application can
+ *  dequeue the displayed buffer back from the driver.
+ *
+ *  In case of capture drivers, this callback function will be called
+ *  when a frame(s) is/are captured. Then the application can dequeue the
+ *  captured buffer back from the driver.
+ *
+ *  In case of M2M drivers, this callback function will be called
+ *  when a request from the application is completed by the driver. Then the
+ *  application can dequeue the completed request buffers back from the driver.
+ *
+ *  In case of control drivers, callbacks are typically not used since mostly
+ *  FVID2 APIs implemented by control drivers are of blocking nature.
+ *
+ *  \param handle   [OUT] FVID2 handle for which the callback has occurred.
+ *  \param appData  [OUT] Application data provided to the driver at the
+ *                        time of Fvid2_create().
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+typedef int32_t (*Fvid2_CbFxn)(Fvid2_Handle handle, void *appData);
+
+/**
+ *  \brief FVID2 error callback function prototype.
+ *
+ *  Error callback is called by driver when it encounters a error during
+ *  processing of frames in its internal queue.
+ *
+ *  When user submits frames to the driver it does minimal error checks and
+ *  stores the the frames in its internal queues. In case of any error at
+ *  this point the FVID2 API will simply return error and error callback
+ *  will not be called.
+ *
+ *  The driver will later (depending on how its request queue is full) process
+ *  these frames submitted by the user. If driver finds any error in either
+ *  the input frame information or hardware itself then it will call this error
+ *  callback to notify the user about this error. As part of the callback
+ *  information it also returns the frames or request for which error happened
+ *  so that user can take appropriate action.
+ *
+ *  Users should apply same rules as that of Fvid2_CbFxn when implementing
+ *  error callbacks.
+ *
+ *  \param handle   [OUT] FVID2 handle for which the callback has occurred.
+ *  \param appData  [OUT] Application data provided to the driver at the time
+ *                        of Fvid2_create().
+ *  \param errList  [OUT] Pointer to a valid framelist (Fvid2_FrameList)
+ *                        in case of capture and display drivers or a pointer
+ *                        to a valid processlist (Fvid2_ProcessList) in case of
+ *                        M2M drivers. The driver copies the aborted/error
+ *                        frames in this frame list or process list.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+typedef int32_t (*Fvid2_ErrCbFxn)(Fvid2_Handle handle,
+                                  void        *appData,
+                                  void        *errList);
+
+/**
+ *  \brief FVID2 callback that is called by subframe mode Capture driver.
+ *
+ *  This callback is called for every subframe of frame that
+ *  is captured. This function is used by Capture Driver and not meant for M2M
+ *  drivers.
+ *
+ *  Users should apply same rules as that of Fvid2_CbFxn when implementing
+ *  subframe callbacks.
+ *
+ *  \param handle       [OUT] FVID2 handle for which this callback happened.
+ *  \param subFrameInfo [OUT] SubFrame information.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+typedef int32_t (*Fvid2_SubFrameCbFxn)(Fvid2_Handle handle,
+                                       Fvid2_Frame *subFrame);
+
+/**
+ *  \name FVID2 Max limits
+ *  @{
+ */
+
+/** \brief Decide the streamid based on channel number.  */
+#define FVID2_STREAM_ID_ANY             (0xFFFFFFFFU)
+
+/* @} */
+
+/*
+ * =========== Command codes for Submit call =============
+ */
+/** \brief Control command base address. */
+#define FVID2_CTRL_BASE                 (0x00000000U)
+/** \brief User command base address. */
+#define FVID2_USER_BASE                 (0x10000000U)
+
+/**
+ *  \addtogroup BSP_DRV_IOCTL_FVID2
+ *  @{
+ */
+
+/**
+ *  \brief Control command used by Fvid2_setFormat()
+ *
+ *  \param cmdArgs       [IN]  const Fvid2_Format *
+ *  \param cmdStatusArgs [OUT] NULL
+ *
+ *  \return FVID2_SOK on success, else failure.
+ */
+#define FVID2_SET_FORMAT                ((uint32_t) FVID2_CTRL_BASE + 3U)
+
+/**
+ *  \brief Control command used by Fvid2_getFormat()
+ *
+ *  \param cmdArgs       [IN]  Fvid2_Format *
+ *  \param cmdStatusArgs [OUT] NULL
+ *
+ *  \return FVID2_SOK on success, else failure.
+ */
+#define FVID2_GET_FORMAT                ((uint32_t) FVID2_CTRL_BASE + 4U)
+
+/**
+ *  \brief Control command used by Fvid2_start()
+ *
+ *  \param cmdArgs       [IN]  Driver specific
+ *  \param cmdStatusArgs [OUT] NULL
+ *
+ *  \return FVID2_SOK on success, else failure.
+ */
+#define FVID2_START                     ((uint32_t) FVID2_CTRL_BASE + 5U)
+
+/**
+ *  \brief Control command used by Fvid2_stop()
+ *
+ *  \param cmdArgs       [IN]  Driver specific
+ *  \param cmdStatusArgs [OUT] NULL
+ *
+ *  \return FVID2_SOK on success, else failure.
+ */
+#define FVID2_STOP                      ((uint32_t) FVID2_CTRL_BASE + 6U)
+
+/* @} */
+
+/* ========================================================================== */
+/*                         Structure Declarations                             */
+/* ========================================================================== */
+
+/**
+ *  \brief FVID2 callback parameters that are setup during Fvid2_create().
+ */
+typedef struct
+{
+    Fvid2_CbFxn    cbFxn;
+    /**< Application callback function used by the driver to intimate any
+     *   operation has completed or not. This is an optional parameter
+     *   in case application decides to use polling method and so could be
+     *   set to NULL. */
+
+    Fvid2_ErrCbFxn errCbFxn;
+    /**< Application error callback function used by the driver to intimate
+     *   any error occurs at the time of streaming. This is an optional
+     *   parameter in case application decides not to get any error callback
+     *   and so could be set to NULL. */
+
+    void           *errList;
+    /**< Pointer to a valid Fvid2_FrameList in case of capture
+     *   and display drivers or a pointer to a valid Fvid2_ProcessList
+     *   in case of M2M drivers where the driver copies
+     *   the aborted/error packet. The memory of this list should be
+     *   allocated by the application and provided to the driver at the time
+     *   of driver creation. When the application gets this callback, it has
+     *   to empty this list and taken necessary action like freeing up memories
+     *   etc. The driver will then reuse the same list for future error
+     *   callback.
+     *   This could be NULL if errCbFxn is NULL. Otherwise this should be
+     *   non-NULL. */
+
+    void           *appData;
+    /**< Application specific data which is returned in the callback function
+     *   as it is. This could be set to NULL if not used. */
+} Fvid2_CbParams;
+
+/* ========================================================================== */
+/*                          Function Declarations                             */
+/* ========================================================================== */
+
+/**
+ *  \brief FVID2 init function.
+ *
+ *  Initializes the FVID2 layer.
+ *  This function should be called before calling any of FVID2 API's and
+ *  should be called only once.
+ *
+ *  \param args         [IN] Not used currently. Set to NULL.
+ *
+ *  \return FVID2_SOK on success else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_init(void *args);
+
+/**
+ *  \brief FVID2 deinit function.
+ *
+ *  Uninitializes the FVID2 layer and should be called during system shutdown.
+ *  Should not be called if Fvid2_init() is not called.
+ *
+ *  \param args         [IN] Not used currently. Set to NULL.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_deInit(void *args);
+
+/**
+ *  \brief Get the version string for FVID2 interface.
+ *
+ *  This is the version number for the FVID2 interface. This
+ *  function can be called prior to #Fvid2_init() to get the version number.
+ *
+ *  \return Pointer to FVID2 version string.
+ */
+const char *Fvid2_getVersionString(void);
+
+/**
+ *  \brief Same as #Fvid2_getVersionString() except it returns the version in
+ *  uint32_t form.
+ *
+ *  Example, v1.0.1.17 will be 0x01000117
+ *
+ *  \return FVID2 version number.
+ */
+uint32_t Fvid2_getVersionNumber(void);
+
+/**
+ *  \brief Creates the driver identified by the driver ID.
+ *
+ *  This will allocate HW and/or SW resources and return a Fvid2_Handle
+ *  for this driver. This handle will be used for subsequent FVID2 API calls
+ *
+ *  \param drvId        [IN] Driver to open. Driver ID is driver specific.
+ *
+ *  \param instanceId   [IN] Instance of the driver to open and is used
+ *                      to differentiate multiple instance support on a
+ *                      single driver. Instance ID is driver specific.
+ *
+ *  \param createArgs   [IN] Pointer to the create argument structure. The type
+ *                      of the structure is defined by the specific driver.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \param createStatusArgs [OUT] Pointer to status argument structure where the
+ *                      driver returns any status information. The type
+ *                      of the structure is defined by the specific driver.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \param cbParams     [IN] Application callback parameters.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \return non-NULL Fvid2_Handle object pointer on success else returns NULL
+ *  on error.
+ */
+Fvid2_Handle Fvid2_create(uint32_t              drvId,
+                          uint32_t              instanceId,
+                          void                 *createArgs,
+                          void                 *createStatusArgs,
+                          const Fvid2_CbParams *cbParams);
+
+/**
+ *  \brief Deletes a previously created FVID2 driver handle.
+ *
+ *  This free's the HW/SW resources allocated during create
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *
+ *  \param deleteArgs   [IN] Pointer to the delete argument structure. The type
+ *                      of the structure is defined by the specific driver.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs);
+
+/**
+ *  \brief Send control commands (IOCTLs) to the driver.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *
+ *  \param cmd          [IN] IOCTL command. The type of command supported
+ *                      is defined by the specific driver.
+ *
+ *  \param cmdArgs      [IN] Pointer to the command argument structure. The type
+ *                      of the structure is defined by the specific driver
+ *                      for each of the supported IOCTL.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \param cmdStatusArgs [OUT] Pointer to status argument structure where the
+ *                      driver returns any status information. The type
+ *                      of the structure is defined by the specific driver
+ *                      for each of the supported IOCTL.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_control(Fvid2_Handle  handle,
+                      uint32_t      cmd,
+                      void         *cmdArgs,
+                      void         *cmdStatusArgs);
+
+/**
+ *  \brief An application calls Fvid2_queue to submit a video buffer to the
+ *  video device driver.
+ *
+ *  - This is used in capture/display drivers.
+ *  - This function could be called from task or ISR context unless the specific
+ *  driver restricts from doing so.
+ *  - This is a non-blocking API unless the specific driver restricts from
+ *  doing so.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param frameList    [IN] Pointer to the frame list structure containing the
+ *                      information about the FVID2 frames that has to be
+ *                      queued in the driver.
+ *  \param streamId     [IN] Stream ID to which the frames should be queued
+ *                      This is used in drivers where they could support
+ *                      multiple streams for the same handle. Otherwise this
+ *                      should be set to zero.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_queue(Fvid2_Handle        handle,
+                    Fvid2_FrameList    *frameList,
+                    uint32_t            streamId);
+
+/**
+ *  \brief An application calls Fvid2_dequeue to request the video device
+ *  driver to give ownership of a video buffer.
+ *
+ *  - This is used in capture/display drivers.
+ *  - This is a non-blocking API if timeout is FVID2_TIMEOUT_NONE and could be
+ *  called by task and ISR context unless the specific driver restricts from
+ *  doing so.
+ *  - This is blocking API if timeout is FVID2_TIMEOUT_FOREVER if supported by
+ *  specific driver implementation.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param frameList    [OUT] Pointer to the frame list structure where the
+ *                      dequeued frame pointer will be stored.
+ *  \param streamId     [IN] Stream ID from where frames should be dequeued.
+ *                      This is used in drivers where it could support multiple
+ *                      streams for the same handle. Otherwise this
+ *                      should be set to zero.
+ *  \param timeout      [IN] FVID2 timeout in units of OS ticks. This will
+ *                      determine the timeout value till the driver will block
+ *                      for a free or completed buffer is available.
+ *                      For non-blocking drivers this parameter might be
+ *                      ignored.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_dequeue(Fvid2_Handle      handle,
+                      Fvid2_FrameList  *frameList,
+                      uint32_t          streamId,
+                      uint32_t          timeout);
+
+/**
+ *  \brief An application calls Fvid2_processRequest to submit a video buffer
+ *  to the video device driver.
+ *
+ *  This API is used for submitting a single channel video processing request
+ *  to the video device driver. It uses framelist to submit multiple
+ *  frames of different stream ids of the same request.
+ *
+ *  - This function could be called from task or ISR context unless the specific
+ *  driver restricts from doing so.
+ *  - This is a non-blocking API unless the specific driver restricts from
+ *  doing so.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param inFrameList  [IN] Pointer to the array of input frames with
+ *                           different stream ids.
+ *  \param outFrameList [IN] Pointer to the array of output frames with
+ *                           different stream ids
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_processRequest(Fvid2_Handle       handle,
+                             Fvid2_FrameList   *inFrameList,
+                             Fvid2_FrameList   *outFrameList);
+
+/**
+ *  \brief An application calls Fvid2_getProcessedRequest to get the
+ *  processed request back from the driver and thus to get the
+ *  ownership of request back from the driver.
+ *
+ *  - This is a non-blocking API if timeout is FVID2_TIMEOUT_NONE and could be
+ *  called by task and ISR context unless the specific driver restricts from
+ *  doing so.
+ *  - This is blocking API if timeout is FVID2_TIMEOUT_FOREVER if supported by
+ *  specific driver implementation.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param inFrameList  [OUT] Pointer to frame list in which input frames with
+ *                            different stream ids will be returned
+ *                            by the driver.
+ *  \param outFrameList [OUT] Pointer to frame list in which output frames with
+ *                            different stream ids will be returned by
+ *                            the driver.
+ *  \param timeout      [IN] FVID2 timeout. This will determine the timeout
+ *                           value till the driver will block for a
+ *                           free or completed buffer is available.
+ *                           For non-blocking drivers this parameter
+ *                           might be ignored.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+int32_t Fvid2_getProcessedRequest(Fvid2_Handle      handle,
+                                  Fvid2_FrameList  *inFrameList,
+                                  Fvid2_FrameList  *outFrameList,
+                                  uint32_t          timeout);
+/**
+ *  \brief An application calls Fvid2_start to request the video device
+ *  driver to start the video display or capture operation.
+ *  This function should be called from task context only and should not be
+ *  called from ISR context.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param cmdArgs      [IN] Pointer to the start argument structure. The type
+ *                      of the structure is defined by the specific driver.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+static inline int32_t Fvid2_start(Fvid2_Handle handle, void *cmdArgs);
+
+/**
+ *  \brief An application calls Fvid2_stop to request the video device
+ *  driver to stop the video display or capture operation.
+ *  This function should be called from task context only and should not be
+ *  called from ISR context.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param cmdArgs      [IN] Pointer to the stop argument structure. The type
+ *                      of the structure is defined by the specific driver.
+ *                      This parameter could be NULL depending on whether the
+ *                      actual driver forces it or not.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+static inline int32_t Fvid2_stop(Fvid2_Handle handle, void *cmdArgs);
+
+/**
+ *  \brief An application calls Fvid2_setFormat to request the video device
+ *  driver to set the format for a given channel.
+ *  This function should be called from task context only and should not be
+ *  called from ISR context.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param fmt          [IN] Pointer to the FVID2 format structure.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+static inline int32_t Fvid2_setFormat(Fvid2_Handle handle, Fvid2_Format *fmt);
+
+/**
+ *  \brief An application calls Fvid2_getFormat to request the video device
+ *  driver to get the current format for a given channel.
+ *  This function should be called from task context only and should not be
+ *  called from ISR context.
+ *
+ *  \param handle       [IN] FVID2 handle returned by create call.
+ *  \param fmt          [OUT] Pointer to the FVID2 format structure.
+ *
+ *  \return FVID2_SOK on success, else appropriate FVID2 error code on failure.
+ */
+static inline int32_t Fvid2_getFormat(Fvid2_Handle handle, Fvid2_Format *fmt);
+
+/**
+ *  \brief Fvid2_CbParams structure init function.
+ *
+ *  \param cbPrms       [IN] Pointer to #Fvid2_CbParams structure.
+ *
+ */
+static inline void Fvid2CbParams_init(Fvid2_CbParams *cbPrms);
+
+/* ========================================================================== */
+/*                       Static Function Definitions                          */
+/* ========================================================================== */
+
+static inline int32_t Fvid2_start(Fvid2_Handle handle, void *cmdArgs)
+{
+    return Fvid2_control(handle, FVID2_START, cmdArgs, NULL);
+}
+
+static inline int32_t Fvid2_stop(Fvid2_Handle handle, void *cmdArgs)
+{
+    return Fvid2_control(handle, FVID2_STOP, cmdArgs, NULL);
+}
+
+static inline int32_t Fvid2_setFormat(Fvid2_Handle handle, Fvid2_Format *fmt)
+{
+    return Fvid2_control(handle, FVID2_SET_FORMAT, fmt, NULL);
+}
+
+static inline int32_t Fvid2_getFormat(Fvid2_Handle handle, Fvid2_Format *fmt)
+{
+    return Fvid2_control(handle, FVID2_GET_FORMAT, fmt, NULL);
+}
+
+static inline void Fvid2CbParams_init(Fvid2_CbParams *cbPrms)
+{
+    if (NULL != cbPrms)
+    {
+        cbPrms->cbFxn    = NULL;
+        cbPrms->errCbFxn = NULL;
+        cbPrms->errList  = NULL;
+        cbPrms->appData  = NULL;
+    }
+
+    return;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* #ifndef FVID2_API_H_ */
+
+/* @} */
index 3d28c0dfc4e7bf723338f2682f3289f76b356392..0bf2cc86cd556ed1c43cdc3771b09d3676e3b795 100644 (file)
@@ -48,7 +48,7 @@
 /*                             Include Files                                  */
 /* ========================================================================== */
 
-#include <ti/drv/fvid2/fvid2.h>
+#include <ti/drv/fvid2/include/fvid2_api.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/makefile b/makefile
new file mode 100644 (file)
index 0000000..cb48055
--- /dev/null
+++ b/makefile
@@ -0,0 +1,42 @@
+#
+# Copyright (c) 2018, Texas Instruments Incorporated
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# *  Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#
+# *  Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# *  Neither the name of Texas Instruments Incorporated nor the names of
+#    its contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+include $(PDK_INSTALL_PATH)/ti/build/Rules.make
+
+COMP = fvid2
+
+lib_$(COMP)_BUILD_DEPENDENCY = soc
+
+$(COMP)_DOXYGEN_SUPPORT = yes
+
+include $(PDK_INSTALL_PATH)/ti/build/comp_top.mk
+
diff --git a/package.bld b/package.bld
new file mode 100644 (file)
index 0000000..58d528c
--- /dev/null
@@ -0,0 +1,19 @@
+/******************************************************************************
+ * FILE PURPOSE: Build description for the FVID2 LLD Package
+ ******************************************************************************
+ * FILE NAME: package.bld
+ *
+ * DESCRIPTION: 
+ *  This file contains the build specification and description for the FVID2 driver
+ *
+ *
+ * Copyright (C) 2018, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Generate Settings.xdc */
+var tplt = xdc.loadTemplate("./Settings.xdc.xdt");
+tplt.genFile("./Settings.xdc",fvid2DriverReleaseVersion);
+
+/* Generate paver.h */
+var tplt = xdc.loadTemplate("./fvid2ver.h.xdt");
+tplt.genFile("./fvid2ver.h",fvid2DriverReleaseVersion);
diff --git a/package.xdc b/package.xdc
new file mode 100644 (file)
index 0000000..150d15e
--- /dev/null
@@ -0,0 +1,13 @@
+/******************************************************************************
+ * FILE PURPOSE: Package specification file
+ ******************************************************************************
+ * FILE NAME: package.xdc
+ *
+ * DESCRIPTION:
+ *  This file contains the package specification for the fvid2 Driver
+ *
+ * Copyright (C) 2018, Texas Instruments, Inc.
+ *****************************************************************************/
+package ti.drv.fvid2[1, 0, 0, 0] {
+    module Settings;
+}
diff --git a/package.xs b/package.xs
new file mode 100644 (file)
index 0000000..1a57c56
--- /dev/null
@@ -0,0 +1,103 @@
+/*
+ *  ======== package.xs ========
+ *
+ */
+
+
+/*
+ *  ======== Package.getLibs ========
+ *  This function is called when a program's configuration files are
+ *  being generated and it returns the name of a library appropriate
+ *  for the program's configuration.
+ */
+
+function getLibs(prog)
+{
+    var suffix  = prog.build.target.suffix;
+    var socType = this.Settings.socType;
+    var socTypes = [
+                     'am65x',
+                   ];
+    var libNames = [
+                     'fvid2'
+                   ];
+
+    /* Read LIBDIR variable */
+    var lib = java.lang.System.getenv("LIBDIR");
+
+    /* If NULL, default to "lib" folder */
+    if (lib == null)
+    {
+        lib = "./lib";
+    } else {
+        print ("\tSystem environment LIBDIR variable defined : " + lib);
+    }
+
+    /* Get the SOC */
+    for each (var soc in socTypes)
+    {
+        if (socType.equals(soc))
+        {
+            lib = lib + "/" + soc;
+            name = this.$name + ".a" + suffix;
+            break;
+        }
+    }
+
+    /* Get target folder, if applicable */
+    if (java.lang.String(suffix).contains('mcu1_0'))
+        lib = lib + "/mcu1_0";
+    else if (java.lang.String(suffix).contains('mpu1_1'))
+        lib = lib + "/mpu1_1";
+    else if (java.lang.String(suffix).contains('mpu1_0'))
+        lib = lib + "/mpu1_0";
+    else if (java.lang.String(suffix).contains('mpu1_1'))
+        lib = lib + "/mpu1_1";
+    else
+        throw new Error("\tUnknown target for: " + this.packageBase + lib);
+
+    var libProfiles = ["debug", "release"];
+    /* get the configured library profile */
+    for each(var profile in libProfiles)
+    {
+        if (this.Settings.libProfile.equals(profile))
+        {
+            lib = lib + "/" + profile;
+            break;
+        }
+    }
+
+    /* Update the lib names with the lib extension */
+    lib_dir = lib;
+    lib     ="";
+    for each(var libName in libNames)
+    {
+        libName = libName + ".a" + suffix;
+        if ((java.io.File(this.packageBase + lib_dir + "/" + libName).exists()))
+        {
+            /* Get library name with path */
+            lib = lib + lib_dir +"/" + libName;
+            lib = lib + ";";
+            print ("\tLinking with library " + this.packageBase + lib_dir + "/" + libName );
+        }
+        else
+        {
+           /* Could not find any library, throw exception */
+           throw new Error("\tLibrary not found: " + this.packageBase + lib_dir + "/" + libName);
+           break;
+        }
+    }
+
+    /* Get library name with path */
+    return lib;
+}
+
+/*
+ *  ======== package.close ========
+ */
+function close()
+{
+    if (xdc.om.$name != 'cfg') {
+        return;
+    }
+}