| /* |
| * |
| * FVID2 inteface header file for TI81XX VPSS |
| * |
| * Copyright (C) 2009 TI |
| * Author: Yihe Hu <yihehu@ti.com> |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| */ |
| |
| |
| #ifndef __LINUX_FVID2_H__ |
| #define __LINUX_FVID2_H__ |
| |
| #ifdef __KERNEL__ |
| |
| /* |
| * =========== Error codes returned by FVID functions ============= |
| */ |
| |
| /** \brief FVID2 API call successful. */ |
| #define FVID2_SOK ((int) 0) |
| /** \brief FVID2 API call returned with error as failed. It may be some |
| * hardware failure or software failure */ |
| #define FVID2_EFAIL ((int) -1) |
| /** \brief FVID2 API call returned with error as bad arguments. Typically |
| * NULL pointer passed to the FVID2 API where its not expected. */ |
| #define FVID2_EBADARGS ((int) -2) |
| /** \brief FVID2 API call returned with error as invalid parameters. Typically |
| * when parameters are not valid. */ |
| #define FVID2_EINVALID_PARAMS ((int) -3) |
| /** \brief FVID2 API call returned with error as device already in use. Tried |
| * to open the driver maximum + 1 times. Display and Capture driver suppports |
| * single open, while M2M driver supports multiple open. */ |
| #define FVID2_EDEVICE_INUSE ((int) -4) |
| /** \brief FVID2 API call returned with error as timed out. Typically API is |
| * waiting for some condition and returned as condition not happened |
| * in the timeout period. */ |
| #define FVID2_ETIMEOUT ((int) -5) |
| /** \brief FVID2 API call returned with error as allocation failure. Typically |
| * memory or resource allocation failure. */ |
| #define FVID2_EALLOC ((int) -6) |
| /** \brief FVID2 API call returned with error as out of range. Typically when |
| * API is called with some argument that is out of range for that API like |
| * array index etc. */ |
| #define FVID2_EOUT_OF_RANGE ((int) -7) |
| /** \brief FVID2 API call returned with error as try again. Momentarily API is |
| * not able to service request because of queue full or any other temporary |
| * reason. */ |
| #define FVID2_EAGAIN ((int) -8) |
| /** \brief FVID2 API call returned with unsupported command. Typically when |
| * command is not supported by control API. */ |
| #define FVID2_EUNSUPPORTED_CMD ((int) -9) |
| /** \brief FVID2 API call returned with error as no more buffers available. |
| * Typically when no buffers are available. */ |
| #define FVID2_ENO_MORE_BUFFERS ((int) -10) |
| /** \brief FVID2 API call returned with error as unsupported operation. |
| * Typically when the specific operation is not supported by that API such |
| * as IOCTL not supporting some specific functions. */ |
| #define FVID2_EUNSUPPORTED_OPS ((int) -11) |
| /** \brief FVID2 API call returned with error as driver already in use. */ |
| #define FVID2_EDRIVER_INUSE ((int) -12) |
| /** \brief No Timeout. */ |
| #define FVID2_TIMEOUT_NONE (0u) |
| /** \brief Timeout wait forever. */ |
| #define FVID2_TIMEOUT_FOREVER (~(0u)) |
| |
| /** |
| * \brief this macro determines the maximum number of fvid2 frame pointers |
| * that can be passed per frame list. |
| */ |
| #define FVID2_MAX_FVID_FRAME_PTR (64u) |
| |
| /** |
| * \brief This macro determines the maximum number of planes/address used to |
| * represent a video buffer per field. |
| * |
| * Currently this is set to 3 to support the maximum pointers required for |
| * YUV planar format - Y, Cb and Cr. |
| */ |
| #define FVID2_MAX_PLANES (3u) |
| |
| /** |
| * \brief Number of fields - top and bottom. Used for allocating address |
| * pointers for both the fields. |
| */ |
| #define FVID2_MAX_FIELDS (2u) |
| |
| /** \brief Number of IN/OUT frame list per process list - Used for array |
| * allocation in process list structure. */ |
| #define FVID2_MAX_IN_OUT_PROCESS_LISTS (4u) |
| |
| /* |
| * == Array index to the buffer address for various formats ==== |
| * fvid2_Buffer structure contains a two dimensional array of void pointers. |
| * The below indices are used to identity the correct buffer address |
| * corresponding to the field and buffer formats. |
| */ |
| |
| /** \brief Index for top field address in case of interlaced mode. */ |
| #define FVID2_FIELD_TOP_ADDR_IDX (0u) |
| |
| /** \brief Index for bottom field address in case of interlaced mode. */ |
| #define FVID2_FIELD_BOTTOM_ADDR_IDX (1u) |
| |
| /** \brief Index for frame address in case of progressive mode. */ |
| #define FVID2_FRAME_ADDR_IDX (0u) |
| |
| /** \brief Index for field mode address index. This is used in case of field |
| * mode of operation as in field capture or in deinterlacing mode of |
| * operation. In these cases both the even and odd field index is one and |
| * the same. */ |
| #define FVID2_FIELD_MODE_ADDR_IDX (0u) |
| |
| |
| /** \brief Index for even field address in case of interlaced mode. */ |
| #define FVID2_FIELD_EVEN_ADDR_IDX (FVID2_FIELD_TOP_ADDR_IDX) |
| |
| /** \brief Index for odd field address in case of interlaced mode. */ |
| #define FVID2_FIELD_ODD_ADDR_IDX (FVID2_FIELD_BOTTOM_ADDR_IDX) |
| |
| /** \brief Index for frame address in case of progressive mode. */ |
| #define FVID2_FIELD_NONE_ADDR_IDX (FVID2_FRAME_ADDR_IDX) |
| |
| /** \brief Index for YUV444/YUV422 interleaved formats. */ |
| #define FVID2_YUV_INT_ADDR_IDX (0u) |
| |
| /** \brief Y Index for YUV444/YUV422/YUV420 planar formats. */ |
| #define FVID2_YUV_PL_Y_ADDR_IDX (0u) |
| |
| /** \brief CB Index for YUV444/YUV422/YUV420 planar formats. */ |
| #define FVID2_YUV_PL_CB_ADDR_IDX (1u) |
| |
| /** \brief CR Index for YUV444/YUV422/YUV420 planar formats. */ |
| #define FVID2_YUV_PL_CR_ADDR_IDX (2u) |
| |
| /** \brief Y Index for YUV semi planar formats. */ |
| #define FVID2_YUV_SP_Y_ADDR_IDX (0u) |
| |
| /** \brief CB Index for semi planar formats. */ |
| #define FVID2_YUV_SP_CBCR_ADDR_IDX (1u) |
| |
| /** \brief Index for RGB888/RGB565/ARGB32 formats. */ |
| #define FVID2_RGB_ADDR_IDX (0u) |
| |
| /** \brief Index for RAW formats. */ |
| #define FVID2_RAW_ADDR_IDX (0u) |
| |
| /* |
| * =========== 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) |
| |
| /** |
| * \brief Command for fvid2_allocBuffer to request the video device driver |
| * to allocate one video buffer. |
| * |
| * \param cmdargs [in] fvid2_frame * |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_ALLOC_BUFFER (FVID2_CTRL_BASE + 1) |
| |
| /** \brief Command for fvid2_freeBuffer to request the video device driver to |
| * free memory of given video buffer. |
| * |
| * \param cmdargs [in] fvid2_frame * |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_FREE_BUFFER (FVID2_CTRL_BASE + 2) |
| |
| /** |
| * \brief Command for fvid2_setFormat to request the video driver to |
| * configure itself with the provided format information. |
| * |
| * \param cmdargs [in] const fvid2_format * |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_SET_FORMAT (FVID2_CTRL_BASE + 3) |
| |
| /** |
| * \brief Command for fvid2_getFormat to request the video driver to |
| * give back the current format configuration. |
| * |
| * \param cmdargs [in] fvid2_format * |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_GET_FORMAT (FVID2_CTRL_BASE + 4) |
| |
| /** |
| * \brief Command for FVID2_start to request the video driver to start the |
| * video display or capture operation. |
| * |
| * \param cmdargs [in] driver specific |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_START (FVID2_CTRL_BASE + 5) |
| |
| /** |
| * \brief Command for FVID2_stop to request the video driver to stop the |
| * video display or capture operation. |
| * |
| * \param cmdargs [in] driver specific |
| * \param cmdstatusargs [out] null |
| * |
| * \return fvid_sok on success, else failure |
| * |
| */ |
| #define FVID2_STOP (FVID2_CTRL_BASE + 6) |
| |
| /** |
| * \brief Data format. |
| */ |
| enum fvid2_dataformat { |
| FVID2_DF_YUV422I_UYVY = 0x0000, |
| /**< YUV 422 Interleaved format - UYVY. */ |
| FVID2_DF_YUV422I_YUYV, |
| /**< YUV 422 Interleaved format - YUYV. */ |
| FVID2_DF_YUV422I_YVYU, |
| /**< YUV 422 Interleaved format - YVYU. */ |
| FVID2_DF_YUV422I_VYUY, |
| /**< YUV 422 Interleaved format - VYUY. */ |
| FVID2_DF_YUV422SP_UV, |
| /**< YUV 422 Semi-Planar - Y separate, UV interleaved. */ |
| FVID2_DF_YUV422SP_VU, |
| /**< YUV 422 Semi-Planar - Y separate, VU interleaved. */ |
| FVID2_DF_YUV422P, |
| /**< YUV 422 Planar - Y, U and V separate. */ |
| FVID2_DF_YUV420SP_UV, |
| /**< YUV 420 Semi-Planar - Y separate, UV interleaved. */ |
| FVID2_DF_YUV420SP_VU, |
| /**< YUV 420 Semi-Planar - Y separate, VU interleaved. */ |
| FVID2_DF_YUV420P, |
| /**< YUV 420 Planar - Y, U and V separate. */ |
| FVID2_DF_YUV444P, |
| /**< YUV 444 Planar - Y, U and V separate. */ |
| FVID2_DF_YUV444I, |
| /**< YUV 444 interleaved - YUVYUV... */ |
| FVID2_DF_RGB16_565 = 0x1000, |
| /**< RGB565 16-bit - 5-bits R, 6-bits G, 5-bits B. */ |
| FVID2_DF_ARGB16_1555, |
| /**< ARGB1555 5-bits R, 5-bits G, 5-bits B, 1-bit Alpha (MSB). */ |
| FVID2_DF_RGBA16_5551, |
| /**< RGBA5551 5-bits R, 5-bits G, 5-bits B, 1-bit Alpha (LSB). */ |
| FVID2_DF_ARGB16_4444, |
| /**< ARGB4444 4-bits R, 4-bits G, 4-bits B, 4-bit Alpha (MSB). */ |
| FVID2_DF_RGBA16_4444, |
| /**< RGBA4444 4-bits R, 4-bits G, 4-bits B, 4-bit Alpha (LSB). */ |
| FVID2_DF_ARGB24_6666, |
| /**< ARGB4444 6-bits R, 6-bits G, 6-bits B, 6-bit Alpha (MSB). */ |
| FVID2_DF_RGBA24_6666, |
| /**< RGBA4444 6-bits R, 6-bits G, 6-bits B, 6-bit Alpha (LSB). */ |
| FVID2_DF_RGB24_888, |
| /**< RGB24 8-bits R, 8-bits G, 8-bits B. */ |
| FVID2_DF_ARGB32_8888, |
| /**< ARGB32 8-bits R, 8-bits G, 8-bits B, 8-bit Alpha (MSB). */ |
| FVID2_DF_RGBA32_8888, |
| /**< RGBA32 - 8-bits R, 8-bits G, 8-bits B, 8-bit Alpha (LSB). */ |
| FVID2_DF_BITMAP8 = 0x2000, |
| /**< BITMAP 8bpp. */ |
| FVID2_DF_BITMAP4_LOWER, |
| /**< BITMAP 4bpp lower address in CLUT. */ |
| FVID2_DF_BITMAP4_UPPER, |
| /**< BITMAP 4bpp upper address in CLUT. */ |
| FVID2_DF_BITMAP2_OFFSET0, |
| /**< BITMAP 2bpp offset 0 in CLUT. */ |
| FVID2_DF_BITMAP2_OFFSET1, |
| /**< BITMAP 2bpp offset 1 in CLUT. */ |
| FVID2_DF_BITMAP2_OFFSET2, |
| /**< BITMAP 2bpp offset 2 in CLUT. */ |
| FVID2_DF_BITMAP2_OFFSET3, |
| /**< BITMAP 2bpp offset 3 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET0, |
| /**< BITMAP 1bpp offset 0 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET1, |
| /**< BITMAP 1bpp offset 1 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET2, |
| /**< BITMAP 1bpp offset 2 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET3, |
| /**< BITMAP 1bpp offset 3 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET4, |
| /**< BITMAP 1bpp offset 4 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET5, |
| /**< BITMAP 1bpp offset 5 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET6, |
| /**< BITMAP 1bpp offset 6 in CLUT. */ |
| FVID2_DF_BITMAP1_OFFSET7, |
| /**< BITMAP 1bpp offset 7 in CLUT. */ |
| FVID2_DF_BAYER_RAW = 0x3000, |
| /**< Bayer pattern. */ |
| FVID2_DF_RAW_VBI, |
| /**< Raw VBI data. */ |
| FVID2_DF_RAW, |
| /**< Raw data - Format not interpreted. */ |
| FVID2_DF_MISC, |
| /**< For future purpose. */ |
| FVID2_DF_INVALID, |
| /**< Invalid data format. Could be used to initialize variables. */ |
| FVID2_DF_MAX |
| /**< Should be the last value of this enumeration. |
| Will be used by driver for validating the input parameters. */ |
| } ; |
| |
| /** |
| * \brief Scan format. |
| */ |
| enum fvid2_scanformat { |
| FVID2_SF_INTERLACED = 0, |
| /**< Interlaced mode. */ |
| FVID2_SF_PROGRESSIVE, |
| /**< Progressive mode. */ |
| FVID2_SF_MAX |
| /**< Should be the last value of this enumeration. |
| Will be used by driver for validating the input parameters. */ |
| }; |
| |
| /** |
| * \brief Video standards. |
| */ |
| enum fvid2_standard { |
| FVID2_STD_NTSC = 0u, |
| /**< 720x480 30FPS interlaced NTSC standard. */ |
| FVID2_STD_PAL, |
| |
| /**< 720x576 30FPS interlaced PAL standard. */ |
| FVID2_STD_480I, |
| /**< 720x480 30FPS interlaced SD standard. */ |
| FVID2_STD_576I, |
| /**< 720x576 30FPS interlaced SD standard. */ |
| |
| FVID2_STD_CIF, |
| /**< Interlaced, 360x120 per field NTSC, 360x144 per field PAL. */ |
| FVID2_STD_HALF_D1, |
| /**< Interlaced, 360x240 per field NTSC, 360x288 per field PAL. */ |
| FVID2_STD_D1, |
| /**< Interlaced, 720x240 per field NTSC, 720x288 per field PAL. */ |
| |
| FVID2_STD_480P, |
| /**< 720x480 60FPS progressive ED standard. */ |
| FVID2_STD_576P, |
| /**< 720x576 60FPS progressive ED standard. */ |
| |
| FVID2_STD_720P_60, |
| /**< 1280x720 60FPS progressive HD standard. */ |
| FVID2_STD_720P_50, |
| /**< 1280x720 50FPS progressive HD standard. */ |
| |
| FVID2_STD_1080I_60, |
| /**< 1920x1080 30FPS interlaced HD standard. */ |
| FVID2_STD_1080I_50, |
| /**< 1920x1080 50FPS interlaced HD standard. */ |
| |
| FVID2_STD_1080P_60, |
| /**< 1920x1080 60FPS progressive HD standard. */ |
| FVID2_STD_1080P_50, |
| /**< 1920x1080 50FPS progressive HD standard. */ |
| |
| FVID2_STD_1080P_24, |
| /**< 1920x1080 24FPS progressive HD standard. */ |
| FVID2_STD_1080P_30, |
| /**< 1920x1080 30FPS progressive HD standard. */ |
| |
| FVID2_STD_VGA_60, |
| /**< 640x480 60FPS VESA standard. */ |
| FVID2_STD_VGA_72, |
| /**< 640x480 72FPS VESA standard. */ |
| FVID2_STD_VGA_75, |
| /**< 640x480 75FPS VESA standard. */ |
| FVID2_STD_VGA_85, |
| /**< 640x480 85FPS VESA standard. */ |
| |
| FVID2_STD_SVGA_60, |
| /**< 800x600 60FPS VESA standard. */ |
| FVID2_STD_SVGA_72, |
| /**< 800x600 72FPS VESA standard. */ |
| FVID2_STD_SVGA_75, |
| /**< 800x600 75FPS VESA standard. */ |
| FVID2_STD_SVGA_85, |
| /**< 800x600 85FPS VESA standard. */ |
| |
| FVID2_STD_XGA_60, |
| /**< 1024x768 60FPS VESA standard. */ |
| FVID2_STD_XGA_70, |
| /**< 1024x768 72FPS VESA standard. */ |
| FVID2_STD_XGA_75, |
| /**< 1024x768 75FPS VESA standard. */ |
| FVID2_STD_XGA_85, |
| /**< 1024x768 85FPS VESA standard. */ |
| |
| FVID2_STD_WXGA_60, |
| /**< 1280x768 60FPS VESA standard. */ |
| FVID2_STD_WXGA_75, |
| /**< 1280x768 75FPS VESA standard. */ |
| FVID2_STD_WXGA_85, |
| /**< 1280x768 85FPS VESA standard. */ |
| |
| FVID2_STD_SXGA_60, |
| /**< 1280x1024 60FPS VESA standard. */ |
| FVID2_STD_SXGA_75, |
| /**< 1280x1024 75FPS VESA standard. */ |
| FVID2_STD_SXGA_85, |
| /**< 1280x1024 85FPS VESA standard. */ |
| |
| FVID2_STD_SXGAP_60, |
| /**< 1400x1050 60FPS VESA standard. */ |
| FVID2_STD_SXGAP_75, |
| /**< 1400x1050 75FPS VESA standard. */ |
| |
| FVID2_STD_UXGA_60, |
| /**< 1600x1200 60FPS VESA standard. */ |
| |
| FVID2_STD_MUX_2CH_D1, |
| /**< Interlaced, 2Ch D1, NTSC or PAL. */ |
| FVID2_STD_MUX_4CH_D1, |
| /**< Interlaced, 4Ch D1, NTSC or PAL. */ |
| FVID2_STD_MUX_4CH_CIF, |
| /**< Interlaced, 4Ch CIF, NTSC or PAL. */ |
| FVID2_STD_MUX_4CH_HALF_D1, |
| /**< Interlaced, 4Ch Half-D1, NTSC or PAL. */ |
| FVID2_STD_MUX_8CH_CIF, |
| /**< Interlaced, 8Ch CIF, NTSC or PAL. */ |
| FVID2_STD_MUX_8CH_HALF_D1, |
| /**< Interlaced, 8Ch Half-D1, NTSC or PAL. */ |
| |
| FVID2_STD_AUTO_DETECT, |
| /**< Auto-detect standard. Used in capture mode. */ |
| FVID2_STD_CUSTOM, |
| /**< Custom standard used when connecting to external LCD etc... |
| The video timing is provided by the application. |
| Used in display mode. */ |
| |
| FVID2_STD_MAX |
| /**< Should be the last value of this enumeration. |
| Will be used by driver for validating the input parameters. */ |
| }; |
| |
| /** |
| * \brief Field type |
| */ |
| enum fvid2_fid { |
| FVID2_FID_TOP = 0, |
| /**< Top field. */ |
| FVID2_FID_BOTTOM, |
| /**< Bottom field. */ |
| FVID2_FID_FRAME, |
| /**< Frame mode - Contains both the fields or a progressive frame. */ |
| FVID2_FID_MAX |
| /**< Should be the last value of this enumeration. |
| Will be used by driver for validating the input parameters. */ |
| }; |
| |
| /** \brief Even Field */ |
| #define FVID2_FID_EVEN (FVID2_FID_TOP) |
| /** \brief Odd Field */ |
| #define FVID2_FID_ODD (FVID2_FID_BOTTOM) |
| /** \brief No Field */ |
| #define FVID2_FID_NONE (FVID2_FID_FRAME) |
| |
| /** |
| * \brief Bits per pixel. |
| */ |
| enum fvid2_bitsperpixel { |
| FVID2_BPP_BITS1 = 0, |
| /**< 1 Bits per Pixel. */ |
| FVID2_BPP_BITS2, |
| /**< 2 Bits per Pixel. */ |
| FVID2_BPP_BITS4, |
| /**< 4 Bits per Pixel. */ |
| FVID2_BPP_BITS8, |
| /**< 8 Bits per Pixel. */ |
| FVID2_BPP_BITS12, |
| /**< 12 Bits per Pixel - used for YUV420 format. */ |
| FVID2_BPP_BITS16, |
| /**< 26 Bits per Pixel. */ |
| FVID2_BPP_BITS24, |
| /**< 24 Bits per Pixel. */ |
| FVID2_BPP_BITS32, |
| /**< 32 Bits per Pixel. */ |
| FVID2_BPP_MAX |
| /**< Should be the last value of this enumeration. |
| Will be used by driver for validating the input parameters. */ |
| }; |
| |
| |
| /** |
| * \brief Structure for setting FVID2 callback functions. |
| */ |
| struct fvid2_cbparams { |
| int (*cbfxn)(void *handle, void *appdata, void *reserved); |
| /**< 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. */ |
| int (*errcbfnx)(void *handle, void *appdata, void *errdata, |
| void *reserved); |
| /**< 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 framelist (FVID2_FrameList) in case of capture |
| and display drivers or a pointer to a valid processlist |
| (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. */ |
| void *reserved; |
| /**< For future use. Not used currently. Set this to NULL. */ |
| } ; |
| |
| /** |
| * \brief Structure for setting or getting the FVID2 buffer formats. |
| */ |
| struct fvid2_format { |
| u32 channelnum; |
| /**< Channel Number to which this format belongs to. |
| This is used in case of multiple buffers queuing/deqeuing using a |
| single call. This is not applicable for all the drivers. When not |
| used set it to zero. */ |
| u32 width; |
| /**< Width in pixels. */ |
| u32 height; |
| /**< Number of lines per frame. For interlaced mode, this should be set |
| to the frame size and not the field size. */ |
| u32 pitch[FVID2_MAX_PLANES]; |
| /**< Pitch in bytes for each of the sub-buffers. This represents the |
| difference between two consecutive line address. |
| This is irrespective of whether the video is interlaced or |
| progressive and whether the fields are merged or separated for |
| interlaced video. */ |
| u32 fieldmerged[FVID2_MAX_PLANES]; |
| /**< Whether both the fields have to be merged - line interleaved or |
| not. Used only for interlaced format. The effective pitch is |
| calculated based on this information along with pitch parameter. |
| If fields are merged, effective pitch = pitch * 2 else effective |
| pitch = pitch. */ |
| u32 dataformat; |
| /**< Frame data Format. */ |
| u32 scanformat; |
| /**< Scan Format. */ |
| u32 bpp; |
| /**< Number of bits per pixel. */ |
| void *reserved; |
| /**< For future use. Not used currently. Set this to NULL. */ |
| }; |
| |
| /** |
| * \brief Slice information used in drivers supporting subframe level |
| * processing, for application and driver interaction |
| * [IN] sliceNumber and NoOfLines available in the frame for queue |
| * operation. Set by application and used by driver |
| * [OUT] NoOfLines output for current subframe for Dequeue. Set by driver |
| * and used by application |
| */ |
| struct fvid2_subframeinfo { |
| u32 subframenum; |
| /**< Current subframe Number in this frame, |
| range is from 0 to (NoOfSlicesInFrame-1) */ |
| u32 numinlines; |
| /**< Number of lines available in the frame at the end of this slice. |
| */ |
| u32 numoutlines; |
| /**< Number of lines generated in output buffer after processing |
| current subframe */ |
| } ; |
| /** |
| * \brief FVID2 frame buffer structure. |
| */ |
| struct fvid2_frame { |
| void *addr[FVID2_MAX_FIELDS][FVID2_MAX_PLANES]; |
| /**< FVID2 buffer pointers for supporting multiple addresses like |
| y, u, v etc for a given frame. The interpretation of these |
| pointers depend on the format configured. |
| The first dimension represents the field and the second dimension |
| represents the plane. |
| Not all pointers are valid for a given format. |
| |
| Representation of YUV422 Planar Buffer: |
| Field 0 Y -> addr[0][0], Field 1 Y -> addr[1][0] |
| Field 0 U -> addr[0][1], Field 1 U -> addr[1][1] |
| Field 0 V -> addr[0][2], Field 1 V -> addr[1][2] |
| |
| Representation of YUV422 Interleaved Buffer: |
| Field 0 YUV -> addr[0][0], Field 1 YUV -> addr[1][0] |
| Other pointers are not valid. |
| |
| Representation of RGB888 Buffer(Assuming RGB is always progressive) |
| RGB -> addr[0][0] |
| Other pointers are not valid. |
| |
| Instead of using numericals for accessing the buffers, |
| the application can use the macros defined for each buffer |
| formats like FVID2_YUV_INT_ADDR_IDX, FVID2_RGB_ADDR_IDX, |
| FVID2_FID_TOP etc. |
| |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| |
| u32 fid; |
| /**< Indicates whether this frame belong to top or bottom field. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| u32 channelnum; |
| /**< Channel number to which this FVID2 frame belongs to. |
| This is used in case of multiple buffers queuing/deqeuing using a |
| single call. |
| If only one channel is supported, then this should be set to zero. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| |
| u32 timestamp; |
| /**< Time Stamp for captured or displayed frame. |
| [OUT] for dequeue operation. Not valid for queue operation. */ |
| |
| void *appdata; |
| /**< Additional application parameter per frame. This is not modified |
| by driver. */ |
| void *perframecfg; |
| /**< Per frame configuration parameters like scaling ratio, cropping, |
| positioning etc... |
| This could be set to NULL if not used. |
| [IN] for queue operation. Dequeue returns the same pointer back to |
| the application. */ |
| |
| void *blankdata; |
| /**< Blanking data. |
| This could be set to NULL if not used. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| void *drvdata; |
| /**< Used by driver. Application should not modify this. */ |
| struct fvid2_subframeinfo *subframeinfo; |
| /**< Used for Slice level processing information exchange between |
| application and driver. |
| This could be set to NULL if subframe level processing is not used. |
| */ |
| void *reserved; |
| /**< For future use. Not used currently. Set this to NULL. */ |
| } ; |
| |
| /** |
| * \brief FVID2 Mode information structure. |
| */ |
| struct fvid2_modeinfo { |
| u32 standard; |
| /**< [IN] Standard for which to get the info. |
| For valid values see #FVID2_Standard. */ |
| u32 width; |
| /**< Active video frame width in pixels. */ |
| u32 height; |
| /**< Active video frame height in lines. */ |
| u32 scanformat; |
| /**< Scan format of standard. For valid values see #FVID2_ScanFormat. */ |
| u32 pixelclock; |
| /**< Pixel clock of standard in KHz. */ |
| u32 fps; |
| /**< Frames per second. Not Used */ |
| u32 hfrontporch; |
| /**< Horizontal front porch. Same for both fields in case of interlaced |
| display */ |
| u32 hbackporch; |
| /**< Horizontal back porch */ |
| u32 hsynclen; |
| /**< Horizontal sync length. Same for both fields in case of interlaced |
| display */ |
| u32 vfrontporch; |
| /**< Vertical front porch for each field or frame */ |
| u32 vbackporch; |
| /**< Vertical back porch for each field or frame */ |
| u32 vsynclen; |
| /**< Vertical sync length for each field */ |
| u32 reserved[4u]; |
| /**< For future use. Not used currently. */ |
| }; |
| |
| /** |
| * \brief FVID2 frame buffer list used to exchange multiple FVID2 |
| * frames in a single driver call. |
| */ |
| struct fvid2_framelist { |
| struct fvid2_frame *frames[FVID2_MAX_FVID_FRAME_PTR]; |
| /**< an array of fvid2 frame pointers. |
| [in] the content of the pointer array i.e fvid2_frame pointer is input |
| for queue operation |
| output for dequeue operation. */ |
| u32 numframes; |
| /**< Number of frames - Size of the array containing FVID2 pointers. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| void *perlistcfg; |
| /**< Per list configuration parameters like scaling ratio, positioning, |
| cropping etc for all the frames together. |
| This could be set to NULL if not used. In this case, the driver |
| will use the previous configuration. |
| [IN] for queue operation. Dequeue returns the same pointer back to |
| the application. */ |
| void *drvdata; |
| /**< Used by driver. Application should not modify this. */ |
| void *reserved; |
| /**< For future use. Not used currently. Set this to NULL. */ |
| void *appdata; |
| /**< Additional application parameter per frame. This is not modified by |
| driver. */ |
| |
| } ; |
| |
| /** |
| * \brief FVID2 process list containing frame list used to exchange multiple |
| * input/output buffers in M2M (memory to memory) operation. Each of the frame |
| * list in turn have multiple frames/request. |
| */ |
| struct fvid2_processlist { |
| struct fvid2_framelist *inframelist[FVID2_MAX_IN_OUT_PROCESS_LISTS]; |
| /**< Pointer to an array of FVID2 frame list pointers for input nodes. |
| [IN] for both queue and dequeue operation. |
| The content of the pointer array i.e FVID2_FrameList pointer is |
| input for queue operation and is output for dequeue operation. */ |
| struct fvid2_framelist *outframelist[FVID2_MAX_IN_OUT_PROCESS_LISTS]; |
| /**< Pointer to an array of FVID2 frame list pointers for output nodes. |
| [IN] for both queue and dequeue operation. |
| The content of the pointer array i.e FVID2_FrameList pointer is |
| input for queue operation and is output for dequeue operation. */ |
| u32 numinlists; |
| /**< Number of input frame list valid in inFrameList. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| u32 numoutlists; |
| /**< Number of output frame list valid in outFrameList. |
| [IN] for queue operation. |
| [OUT] for dequeue operation. */ |
| void *drvdata; |
| /**< Used by driver. Application should not modify this. */ |
| void *reserved; |
| /**< For future use. Not used currently. Set this to NULL. */ |
| } ; |
| |
| |
| /** |
| * FVID2_create |
| * \brief Opens the driver identified by the driver ID. |
| * |
| * \param drvId [IN] Used to find a matching ID in the driver |
| * table. |
| * \param instanceId [IN] Instance ID of the driver to open and is |
| * used to differentiate multiple instance |
| * support on a single driver. |
| * \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 Returns a non-NULL FVID2_Handle object on success else returns |
| * NULL on error. |
| */ |
| void *vps_fvid2_create(u32 drvid, |
| u32 instanceid, |
| void *createargs, |
| void *createstatusargs, |
| struct fvid2_cbparams *cbparams); |
| |
| /** |
| * FVID2_delete |
| * \brief Application calls FVID2_delete to close the logical channel |
| * associated with FVID2 handle. Driver will relinquish all the resources |
| * allocated at the time of FVID2_create once all the logical handles for |
| * the driver is closed. |
| * |
| * \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. |
| */ |
| int vps_fvid2_delete(void *handle, void *deleteargs); |
| |
| /** |
| * \brief An application calls FVID2_control to send standard control |
| * commands or device/driver specific control commands to the video |
| * 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. |
| */ |
| int vps_fvid2_control(void *handle, |
| u32 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. |
| */ |
| int vps_fvid2_queue(void *handle, |
| struct fvid2_framelist *framelist, |
| u32 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. |
| */ |
| int vps_fvid2_dequeue(void *handle, |
| struct fvid2_framelist *framelist, |
| u32 stream_id, |
| u32 timeout); |
| |
| /** |
| * \brief An application calls FVID2_processFrames to submit a video |
| * buffer to the video device driver. |
| * |
| * this api is very similar to the fvid2_queue api except that this is |
| * used in m2m drivers only. |
| * - 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 processList [IN] Pointer to the process list structure |
| * containing the information about the FVID2 |
| * frame lists and frames that has to be |
| * queued to the driver for processing. |
| * |
| * \return FVID2_SOK on success, else appropriate FVID2 error code on |
| * failure. |
| */ |
| int vps_fvid2_processframes(void *handle, |
| struct fvid2_processlist *processlist); |
| |
| /** |
| * \brief An application calls FVID2_getProcessedFrames to request the |
| * video device driver to give ownership of a video buffer. |
| * |
| * this api is very similar to the fvid2_dequeue api except that this is |
| * used in m2m drivers only. |
| * - 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 processList [OUT] Pointer to the process list structure |
| * where the driver will copy the references |
| * to the dequeued FVID2 frame lists and |
| * frames. |
| * \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. |
| */ |
| int vps_fvid2_getprocessedframes(void *handle, |
| struct fvid2_processlist *processlist, |
| u32 timeout); |
| |
| |
| /** |
| * \brief An application calls FVID2_start to request the video device |
| * driver to start the video display or capture operation. |
| * |
| * \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 int vps_fvid2_start(void *handle, void *cmdargs) |
| { |
| return vps_fvid2_control(handle, FVID2_START, cmdargs, NULL); |
| } |
| |
| /** |
| * \brief An application calls FVID2_stop to request the video device |
| * driver to stop the video display or capture operation. |
| * |
| * \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 int vps_fvid2_stop(void *handle, void *cmdargs) |
| { |
| return vps_fvid2_control(handle, FVID2_STOP, cmdargs, NULL); |
| } |
| |
| /** |
| * \brief An application calls FVID2_setFormat to request the video device |
| * driver to set the format for a given channel. |
| * |
| * \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 int vps_fvid2_setformat(void *handle, struct fvid2_format *fmt) |
| { |
| return vps_fvid2_control(handle, FVID2_SET_FORMAT, fmt, NULL); |
| } |
| |
| /** |
| * \brief An application calls FVID2_getFormat to request the video device |
| * driver to get the current format for a given channel. |
| * |
| * \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 int vps_fvid2_getformat(void *handle, struct fvid2_format *fmt) |
| { |
| return vps_fvid2_control(handle, FVID2_GET_FORMAT, fmt, NULL); |
| } |
| |
| #endif |
| |
| #endif |
| |
