/*
   * Copyright (c) 2015-2016 Freescale Semiconductor, Inc.
   * Copyright 2017 NXP
   *
   * SPDX-License-Identifier:	GPL-2.0+
   */
  
  #ifndef IMXDPUV1_H
  #define IMXDPUV1_H
  
  #include <linux/types.h>
  #include <errno.h>
  
  /* these will be removed */
  #undef IMXDPUV1_VERSION_0
  #define IMXDPUV1_VERSION_1
  
  /* #define DEBUG */
  /* #define ENABLE_IMXDPUV1_TRACE */
  /* #define ENABLE_IMXDPUV1_TRACE_REG */
  /* #define ENABLE_IMXDPUV1_TRACE_IRQ */
  /* #define ENABLE_IMXDPUV1_TRACE_IRQ_READ */
  /* #define ENABLE_IMXDPUV1_TRACE_IRQ_WRITE */
  
  #ifdef ENABLE_IMXDPUV1_TRACE
  #define IMXDPUV1_TRACE(fmt, ...) \
  printf((fmt), ##__VA_ARGS__)
  #else
  #define IMXDPUV1_TRACE(fmt, ...) do {} while (0)
  #endif
  
  #ifdef ENABLE_IMXDPUV1_TRACE_IRQ
  #define IMXDPUV1_TRACE_IRQ(fmt, ...) \
  printf((fmt), ##__VA_ARGS__)
  #else
  #define IMXDPUV1_TRACE_IRQ(fmt, ...) do {} while (0)
  #endif
  
  #ifdef ENABLE_IMXDPUV1_TRACE_REG
  #define IMXDPUV1_TRACE_REG(fmt, ...) \
  printf((fmt), ##__VA_ARGS__)
  #else
  #define IMXDPUV1_TRACE_REG(fmt, ...) do {} while (0)
  #endif
  
  #define IMXDPUV1_PRINT(fmt, ...) \
  printf((fmt), ##__VA_ARGS__)
  
  /* #define IMXDPUV1_TCON0_MAP_24BIT_0_23 */
  /* #define IMXDPUV1_TCON1_MAP_24BIT_0_23 */
  
  /* todo: this need to come from device tree */
  #define IMXDPUV1_NUM_DI_MAX 2
  #define IMXDPUV1_MAX_NUM		2
  #define IMXDPUV1_NUM_DI           2
  #define IMXDPUV1_NUM_CI           2
  #define IMXDPUV1_REGS_BASE_PHY0	0x56180000
  #define IMXDPUV1_REGS_BASE_PHY1	0x57180000
  #define IMXDPUV1_REGS_BASE_SIZE	0x14000
  
  #ifdef IMXDPUV1_VERSION_0
  #define IMXDPUV1_ENABLE_INTSTAT2
  #endif
  #define IMXDPUV1_SET_FIELD(field, value) (((value) << (field ## _SHIFT)) & (field ## _MASK))
  #define IMXDPUV1_GET_FIELD(field, reg) (((reg)&(field ## _MASK)) >> (field  ## _SHIFT))
  
  /*
  	IMXDPU windows, planes, layers, streams
  
  	IMXDPU hardware documentation confuses the meaning of layers and
  		planes. These are software usages of these terms.
  
  	window - a logical buffer of pixels in a rectangular arrangment.
  		Image, Integral and video planes suport one window.
  		Fractional and warp plane support 8 windows. Blending is not
  		supported between the sub-windows of a fractional or warp plane.
  
  	sub-window - one of the eight logical windows of a fractional or warp
  		plane.
  
  	channel - the logical DMA configuration for etiher a fetch or store unit
  
  	plane - a plane is a hardware supported feature. There are four types
  		of display planes:
  
  		video x2
  		fractional x2
  		intergral x2
  		warp
  
  	layer - each of the 7 planes is fed to a layer blender. Full Alpha
  		blending is supported for all of the planes fed to the layer
  		blender.
  
  	streams - the layer bleder produces four streams: two normal streams
  		(0 and 1) and two panic streams (4 and 5).
  
  		In normal mode, streams 0 and 1 are fed to the displays.
  		In panic mode, streams 4 and 5 are fed to the displays.
  */
  
  
  /*!
   * Enumeration of IMXDPU blend mode flags
   */
  typedef enum {
  	IMXDPUV1_PLANE_CLUT               = 1 << 0,	/* Color lookup */
  	IMXDPUV1_PLANE_DECODE             = 1 << 1,	/* Decode compressed bufers */
  	IMXDPUV1_PLANE_ETERNAL_ALPHA      = 1 << 2,	/* supports external alpha buffer  */
  	IMXDPUV1_PLANE_VIDEO_PROC         = 1 << 2,	/* Gamma, Matrix, Scaler, histogram  */
  	IMXDPUV1_PLANE_PLANAR             = 1 << 3,	/* Support Planar pixel buffers*/
  	IMXDPUV1_PLANE_WARP               = 1 << 4,	/* Warping */
  	IMXDPUV1_PLANE_MULTIWINDOW        = 1 << 5,	/* Support multiple buffers per plane */
  	IMXDPUV1_PLANE_CAPTURE            = 1 << 6,	/* Video capture */
  } imxdpuv1_plane_features_t;
  
  /*!
   * Enumeration of IMXDPU layer blend mode flags
   */
  typedef enum {
  	IMXDPUV1_LAYER_NONE               = 1 << 0,	/* Disable blending */
  	IMXDPUV1_LAYER_TRANSPARENCY       = 1 << 1,	/* Transparency */
  	IMXDPUV1_LAYER_GLOBAL_ALPHA       = 1 << 2,	/* Global alpha mode */
  	IMXDPUV1_LAYER_LOCAL_ALPHA        = 1 << 3,	/* Alpha contained in source buffer */
  	IMXDPUV1_LAYER_EXTERN_ALPHA       = 1 << 4,	/* Alpha is contained in a separate plane */
  	IMXDPUV1_LAYER_PRE_MULITPLY       = 1 << 5,	/* Pre-multiply alpha mode */
  } imxdpuv1_layer_blend_modes_t;
  
  /*!
   * Enumeration of IMXDPU layers
   */
  typedef enum {
  	IMXDPUV1_LAYER_0 = 0,
  	IMXDPUV1_LAYER_1,
  	IMXDPUV1_LAYER_2,
  	IMXDPUV1_LAYER_3,
  	IMXDPUV1_LAYER_4,
  #ifdef IMXDPUV1_VERSION_0
  	IMXDPUV1_LAYER_5,
  	IMXDPUV1_LAYER_6,
  #endif
  	IMXDPUV1_LAYER_MAX,
  } imxdpuv1_layer_idx_t;
  
  /*!
   * Enumeration of IMXDPU sub-windows
   */
  typedef enum {
  	IMXDPUV1_SUBWINDOW_NONE = 0,
  	IMXDPUV1_SUBWINDOW_1,
  	IMXDPUV1_SUBWINDOW_2,
  	IMXDPUV1_SUBWINDOW_3,
  	IMXDPUV1_SUBWINDOW_4,
  	IMXDPUV1_SUBWINDOW_5,
  	IMXDPUV1_SUBWINDOW_6,
  	IMXDPUV1_SUBWINDOW_7,
  	IMXDPUV1_SUBWINDOW_8,
  } imxdpuv1_subwindow_id_t;
  
  /*!
   * Enumeration of IMXDPU display streams
   */
  typedef enum {
  	IMXDPUV1_DISPLAY_STREAM_NONE = (0),
  	IMXDPUV1_DISPLAY_STREAM_0 = (1U<<0),
  	IMXDPUV1_DISPLAY_STREAM_1 = (1U<<1),
  	IMXDPUV1_DISPLAY_STREAM_4 = (1U<<4),
  	IMXDPUV1_DISPLAY_STREAM_5 = (1U<<5),
  } imxdpuv1_display_stream_t;
  
  /*!
   * Enumeration of IMXDPU rotation modes
   */
  typedef enum {
  	/* todo: these need to aligh to imxdpu scan direction */
  	IMXDPUV1_ROTATE_NONE = 0,
  	IMXDPUV1_ROTATE_VERT_FLIP = 1,
  	IMXDPUV1_ROTATE_HORIZ_FLIP = 2,
  	IMXDPUV1_ROTATE_180 = 3,
  	IMXDPUV1_ROTATE_90_RIGHT = 4,
  	IMXDPUV1_ROTATE_90_RIGHT_VFLIP = 5,
  	IMXDPUV1_ROTATE_90_RIGHT_HFLIP = 6,
  	IMXDPUV1_ROTATE_90_LEFT = 7,
  } imxdpuv1_rotate_mode_t;
  
  
  /*!
   * Enumeration of types of buffers for a logical channel.
   */
  typedef enum {
  	IMXDPUV1_OUTPUT_BUFFER = 0,	/*!< Buffer for output from IMXDPU BLIT or capture */
  	IMXDPUV1_ALPHA_IN_BUFFER = 1,	/*!< Buffer for alpha input to IMXDPU */
  	IMXDPUV1_GRAPH_IN_BUFFER = 2,	/*!< Buffer for graphics input to IMXDPU */
  	IMXDPUV1_VIDEO_IN_BUFFER = 3,	/*!< Buffer for video input to IMXDPU */
  } imxdpuv1_buffer_t;
  
  #ifdef IMXDPUV1_VERSION_0
  /*!
   * Enumeration of IMXDPU logical block ids
   * NOTE: these match the hardware layout and are not arbitrary
   */
  typedef enum {
  	IMXDPUV1_ID_NONE = 0,
  	IMXDPUV1_ID_FETCHDECODE9,
  	IMXDPUV1_ID_FETCHPERSP9,
  	IMXDPUV1_ID_FETCHECO9,
  	IMXDPUV1_ID_ROP9,
  	IMXDPUV1_ID_CLUT9,
  	IMXDPUV1_ID_MATRIX9,
  	IMXDPUV1_ID_HSCALER9,
  	IMXDPUV1_ID_VSCALER9,
  	IMXDPUV1_ID_FILTER9,
  	IMXDPUV1_ID_BLITBLEND9,
  	IMXDPUV1_ID_STORE9,
  	IMXDPUV1_ID_CONSTFRAME0,
  	IMXDPUV1_ID_EXTDST0,
  	IMXDPUV1_ID_CONSTFRAME4,
  	IMXDPUV1_ID_EXTDST4,
  	IMXDPUV1_ID_CONSTFRAME1,
  	IMXDPUV1_ID_EXTDST1,
  	IMXDPUV1_ID_CONSTFRAME5,
  	IMXDPUV1_ID_EXTDST5,
  	IMXDPUV1_ID_EXTSRC4,
  	IMXDPUV1_ID_STORE4,
  	IMXDPUV1_ID_EXTSRC5,
  	IMXDPUV1_ID_STORE5,
  	IMXDPUV1_ID_FETCHDECODE2,
  	IMXDPUV1_ID_FETCHDECODE3,
  	IMXDPUV1_ID_FETCHWARP2,
  	IMXDPUV1_ID_FETCHECO2,
  	IMXDPUV1_ID_FETCHDECODE0,
  	IMXDPUV1_ID_FETCHECO0,
  	IMXDPUV1_ID_FETCHDECODE1,
  	IMXDPUV1_ID_FETCHECO1,
  	IMXDPUV1_ID_FETCHLAYER0,
  	IMXDPUV1_ID_FETCHLAYER1,
  	IMXDPUV1_ID_GAMMACOR4,
  	IMXDPUV1_ID_MATRIX4,
  	IMXDPUV1_ID_HSCALER4,
  	IMXDPUV1_ID_VSCALER4,
  	IMXDPUV1_ID_HISTOGRAM4,
  	IMXDPUV1_ID_GAMMACOR5,
  	IMXDPUV1_ID_MATRIX5,
  	IMXDPUV1_ID_HSCALER5,
  	IMXDPUV1_ID_VSCALER5,
  	IMXDPUV1_ID_HISTOGRAM5,
  	IMXDPUV1_ID_LAYERBLEND0,
  	IMXDPUV1_ID_LAYERBLEND1,
  	IMXDPUV1_ID_LAYERBLEND2,
  	IMXDPUV1_ID_LAYERBLEND3,
  	IMXDPUV1_ID_LAYERBLEND4,
  	IMXDPUV1_ID_LAYERBLEND5,
  	IMXDPUV1_ID_LAYERBLEND6,
  	IMXDPUV1_ID_EXTSRC0,
  	IMXDPUV1_ID_EXTSRC1,
  	IMXDPUV1_ID_DISENGCFG,
  	IMXDPUV1_ID_FRAMEDUMP0,
  	IMXDPUV1_ID_FRAMEDUMP1,
  	IMXDPUV1_ID_FRAMEGEN0,
  	IMXDPUV1_ID_MATRIX0,
  	IMXDPUV1_ID_GAMMACOR0,
  	IMXDPUV1_ID_DITHER0,
  	IMXDPUV1_ID_TCON0,
  	IMXDPUV1_ID_SIG0,
  	IMXDPUV1_ID_FRAMEGEN1,
  	IMXDPUV1_ID_MATRIX1,
  	IMXDPUV1_ID_GAMMACOR1,
  	IMXDPUV1_ID_DITHER1,
  	IMXDPUV1_ID_TCON1,
  	IMXDPUV1_ID_SIG1,
  	IMXDPUV1_ID_CAPENGCFG,
  	IMXDPUV1_ID_FRAMECAP4,
  	IMXDPUV1_ID_FRAMECAP5,
  	IMXDPUV1_ID_ANALYSER4,
  	IMXDPUV1_ID_ANALYSER5,
  	/* the following are added arbitrarily */
  	IMXDPUV1_ID_DPUXPC,
  
  } imxdpuv1_id_t;
  #else
  /*!
   * Enumeration of IMXDPU logical block ids
   * NOTE: these match the hardware layout and are not arbitrary
   */
  typedef enum {
  	IMXDPUV1_ID_NONE = 0,
  	IMXDPUV1_ID_FETCHDECODE9,
  	IMXDPUV1_ID_FETCHWARP9,
  	IMXDPUV1_ID_FETCHECO9,
  	IMXDPUV1_ID_ROP9,
  	IMXDPUV1_ID_CLUT9,
  	IMXDPUV1_ID_MATRIX9,
  	IMXDPUV1_ID_HSCALER9,
  	IMXDPUV1_ID_VSCALER9,
  	IMXDPUV1_ID_FILTER9,
  	IMXDPUV1_ID_BLITBLEND9,
  	IMXDPUV1_ID_STORE9,
  	IMXDPUV1_ID_CONSTFRAME0,
  	IMXDPUV1_ID_EXTDST0,
  	IMXDPUV1_ID_CONSTFRAME4,
  	IMXDPUV1_ID_EXTDST4,
  	IMXDPUV1_ID_CONSTFRAME1,
  	IMXDPUV1_ID_EXTDST1,
  	IMXDPUV1_ID_CONSTFRAME5,
  	IMXDPUV1_ID_EXTDST5,
  	IMXDPUV1_ID_FETCHWARP2,
  	IMXDPUV1_ID_FETCHECO2,
  	IMXDPUV1_ID_FETCHDECODE0,
  	IMXDPUV1_ID_FETCHECO0,
  	IMXDPUV1_ID_FETCHDECODE1,
  	IMXDPUV1_ID_FETCHECO1,
  	IMXDPUV1_ID_FETCHLAYER0,
  	IMXDPUV1_ID_MATRIX4,
  	IMXDPUV1_ID_HSCALER4,
  	IMXDPUV1_ID_VSCALER4,
  	IMXDPUV1_ID_MATRIX5,
  	IMXDPUV1_ID_HSCALER5,
  	IMXDPUV1_ID_VSCALER5,
  	IMXDPUV1_ID_LAYERBLEND0,
  	IMXDPUV1_ID_LAYERBLEND1,
  	IMXDPUV1_ID_LAYERBLEND2,
  	IMXDPUV1_ID_LAYERBLEND3,
  	IMXDPUV1_ID_DISENGCFG,
  	IMXDPUV1_ID_FRAMEGEN0,
  	IMXDPUV1_ID_MATRIX0,
  	IMXDPUV1_ID_GAMMACOR0,
  	IMXDPUV1_ID_DITHER0,
  	IMXDPUV1_ID_TCON0,
  	IMXDPUV1_ID_SIG0,
  	IMXDPUV1_ID_FRAMEGEN1,
  	IMXDPUV1_ID_MATRIX1,
  	IMXDPUV1_ID_GAMMACOR1,
  	IMXDPUV1_ID_DITHER1,
  	IMXDPUV1_ID_TCON1,
  	IMXDPUV1_ID_SIG1,
  	IMXDPUV1_ID_DPUXPC,
  } imxdpuv1_id_t;
  #endif
  
  #ifdef IMXDPUV1_VERSION_0
  typedef enum {
  	IMXDPUV1_SHDLD_CONSTFRAME0  =  1U << 4,
  	IMXDPUV1_SHDLD_CONSTFRAME4  =  1U << 5,
  	IMXDPUV1_SHDLD_CONSTFRAME1  =  1U << 6,
  	IMXDPUV1_SHDLD_CONSTFRAME5  =  1U << 7,
  	IMXDPUV1_SHDLD_EXTSRC4      =  1U << 8,
  	IMXDPUV1_SHDLD_EXTSRC5      =  1U << 9,
  	IMXDPUV1_SHDLD_FETCHDECODE2 =  1U << 10,
  	IMXDPUV1_SHDLD_FETCHDECODE3 =  1U << 11,
  	IMXDPUV1_SHDLD_FETCHWARP2   =  1U << 12,
  	IMXDPUV1_SHDLD_FETCHECO2    =  1U << 13,
  	IMXDPUV1_SHDLD_FETCHDECODE0 =  1U << 14,
  	IMXDPUV1_SHDLD_FETCHECO0    =  1U << 15,
  	IMXDPUV1_SHDLD_FETCHDECODE1 =  1U << 16,
  	IMXDPUV1_SHDLD_FETCHECO1    =  1U << 17,
  	IMXDPUV1_SHDLD_FETCHLAYER0  =  1U << 18,
  	IMXDPUV1_SHDLD_FETCHLAYER1  =  1U << 19,
  	IMXDPUV1_SHDLD_EXTSRC0      =  1U << 20,
  	IMXDPUV1_SHDLD_EXTSRC1      =  1U << 21,
  } imxdpuv1_shadow_load_req_id_t;
  #else
  typedef enum {
  	IMXDPUV1_SHDLD_CONSTFRAME0  =  1U << 4,
  	IMXDPUV1_SHDLD_CONSTFRAME4  =  1U << 5,
  	IMXDPUV1_SHDLD_CONSTFRAME1  =  1U << 6,
  	IMXDPUV1_SHDLD_CONSTFRAME5  =  1U << 7,
  	IMXDPUV1_SHDLD_FETCHWARP2   =  1U << 8,
  	IMXDPUV1_SHDLD_FETCHECO2    =  1U << 9,
  	IMXDPUV1_SHDLD_FETCHDECODE0 =  1U << 10,
  	IMXDPUV1_SHDLD_FETCHECO0    =  1U << 11,
  	IMXDPUV1_SHDLD_FETCHDECODE1 =  1U << 12,
  	IMXDPUV1_SHDLD_FETCHECO1    =  1U << 13,
  	IMXDPUV1_SHDLD_FETCHLAYER0  =  1U << 14,
  
  	IMXDPUV1_SHDLD_EXTSRC4      =  0,
  	IMXDPUV1_SHDLD_EXTSRC5      =  0,
  	IMXDPUV1_SHDLD_FETCHDECODE2 =  0,
  	IMXDPUV1_SHDLD_FETCHDECODE3 =  0,
  	IMXDPUV1_SHDLD_FETCHLAYER1  =  0,
  	IMXDPUV1_SHDLD_EXTSRC0      =  0,
  	IMXDPUV1_SHDLD_EXTSRC1      =  0,
  
  } imxdpuv1_shadow_load_req_id_t;
  
  
  #endif
  typedef struct {
  	imxdpuv1_id_t primary;
  	imxdpuv1_id_t secondary;
  	imxdpuv1_display_stream_t stream;
  	bool enable;
  } imxdpuv1_layer_t;
  
  typedef enum {
  	/* Fetch Channels */
  	IMXDPUV1_CHAN_IDX_IN_FIRST = 0,
  	IMXDPUV1_CHAN_IDX_00 = 0,	/* IMXDPUV1_ID_SRC_FETCHDECODE2 */
  	IMXDPUV1_CHAN_IDX_01,	/* IMXDPUV1_ID_SRC_FETCHDECODE0 */
  	IMXDPUV1_CHAN_IDX_02,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_03,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_04,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_05,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_06,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_07,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_08,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_09,	/* IMXDPUV1_ID_SRC_FETCHLAYER0 */
  	IMXDPUV1_CHAN_IDX_10,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_11,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_12,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_13,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_14,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_15,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_16,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_17,	/* IMXDPUV1_ID_SRC_FETCHWARP2 */
  	IMXDPUV1_CHAN_IDX_18,	/* IMXDPUV1_ID_SRC_FETCHDECODE3 */
  	IMXDPUV1_CHAN_IDX_19,	/* IMXDPUV1_ID_SRC_FETCHDECODE1 */
  	IMXDPUV1_CHAN_IDX_20,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_21,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_22,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_23,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_24,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_25,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_26,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_27,	/* IMXDPUV1_ID_SRC_FETCHLAYER1 */
  	IMXDPUV1_CHAN_IDX_28,	/* IMXDPUV1_ID_SRC_ECO0 */
  	IMXDPUV1_CHAN_IDX_29,	/* IMXDPUV1_ID_SRC_ECO1 */
  	IMXDPUV1_CHAN_IDX_30,	/* IMXDPUV1_ID_SRC_ECO2 */
  	IMXDPUV1_CHAN_IDX_IN_MAX,	/* Last fetch channel + 1 */
  
  	/* Store Channels */
  	IMXDPUV1_CHAN_IDX_OUT_FIRST = 32,
  	IMXDPUV1_CHAN_IDX_32 = 32,/* IMXDPUV1_ID_DST_STORE4 */
  	IMXDPUV1_CHAN_IDX_33,	/* IMXDPUV1_ID_DST_STORE5 */
  	IMXDPUV1_CHAN_IDX_OUT_MAX,/* Last fetch channel + 1 */
  	IMXDPUV1_CHAN_IDX_MAX = IMXDPUV1_CHAN_IDX_OUT_MAX,
  } imxdpuv1_chan_idx_t;
  
  typedef enum {
  	IMXDPUV1_SUB_NONE = 0,
  	IMXDPUV1_SUB_1 = 1U << 0,	/* IMXDPUV1_ID_FETCHLAYER0, layer 1 */
  	IMXDPUV1_SUB_2 = 1U << 1,	/* IMXDPUV1_ID_FETCHLAYER0, layer 2 */
  	IMXDPUV1_SUB_3 = 1U << 2,	/* IMXDPUV1_ID_FETCHLAYER0, layer 3 */
  	IMXDPUV1_SUB_4 = 1U << 3,	/* IMXDPUV1_ID_FETCHLAYER0, layer 4 */
  	IMXDPUV1_SUB_5 = 1U << 4,	/* IMXDPUV1_ID_FETCHLAYER0, layer 5 */
  	IMXDPUV1_SUB_6 = 1U << 5,	/* IMXDPUV1_ID_FETCHLAYER0, layer 6 */
  	IMXDPUV1_SUB_7 = 1U << 6,	/* IMXDPUV1_ID_FETCHLAYER0, layer 7 */
  	IMXDPUV1_SUB_8 = 1U << 7,	/* IMXDPUV1_ID_FETCHLAYER0, layer 8 */
  } imxdpuv1_chan_sub_idx_t;
  
  /*  IMXDPU Channel
   *	Consistist of four fields
   *	src - block id of source or destination
   *	sec - block id of secondary source for fetcheco
   *	sub - sub index of block for fetchlayer or fetchwarp
   *	idx - logical channel index
   *
   */
  #define make_channel(__blk_id, __eco_id, __sub, __idx) \
  (((__u32)(__idx)<<0)|((__u32)(__eco_id)<<8)|((__u32)(__sub)<<16)|((__u32)(__blk_id)<<24))
  
  #define get_channel_blk(chan) (((__u32)(chan) >> 24) & 0xff)
  #define get_channel_sub(chan) (((__u32)(chan) >> 16) & 0xff)
  #define get_eco_idx(chan)     (((__u32)(chan) >> 8) & 0xff)
  #define get_channel_idx(chan) (((__u32)(chan) >> 0) & 0xff)
  #define IMXDPUV1_SUBCHAN_LAYER_OFFSET 0x28
  
  typedef enum {
  #ifdef IMXDPUV1_VERSION_0
  	/* Fetch Channels */
  	IMXDPUV1_CHAN_00 = make_channel(IMXDPUV1_ID_FETCHDECODE2, IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 0),
  	IMXDPUV1_CHAN_01 = make_channel(IMXDPUV1_ID_FETCHDECODE0,             28, IMXDPUV1_SUB_NONE, 1),
  	IMXDPUV1_CHAN_02 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_1, 2),
  	IMXDPUV1_CHAN_03 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_2, 3),
  	IMXDPUV1_CHAN_04 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_3, 4),
  	IMXDPUV1_CHAN_05 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_4, 5),
  	IMXDPUV1_CHAN_06 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_5, 6),
  	IMXDPUV1_CHAN_07 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_6, 7),
  	IMXDPUV1_CHAN_08 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_7, 8),
  	IMXDPUV1_CHAN_09 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_8, 9),
  	IMXDPUV1_CHAN_10 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_1, 10),
  	IMXDPUV1_CHAN_11 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_2, 11),
  	IMXDPUV1_CHAN_12 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_3, 12),
  	IMXDPUV1_CHAN_13 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_4, 13),
  	IMXDPUV1_CHAN_14 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_5, 14),
  	IMXDPUV1_CHAN_15 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_6, 15),
  	IMXDPUV1_CHAN_16 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_7, 16),
  	IMXDPUV1_CHAN_17 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_8, 17),
  	IMXDPUV1_CHAN_18 = make_channel(IMXDPUV1_ID_FETCHDECODE3,             30, IMXDPUV1_SUB_NONE, 18),
  	IMXDPUV1_CHAN_19 = make_channel(IMXDPUV1_ID_FETCHDECODE1,             29, IMXDPUV1_SUB_NONE, 19),
  	IMXDPUV1_CHAN_20 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_1, 20),
  	IMXDPUV1_CHAN_21 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_2, 21),
  	IMXDPUV1_CHAN_22 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_3, 22),
  	IMXDPUV1_CHAN_23 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_4, 23),
  	IMXDPUV1_CHAN_24 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_5, 24),
  	IMXDPUV1_CHAN_25 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_6, 25),
  	IMXDPUV1_CHAN_26 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_7, 26),
  	IMXDPUV1_CHAN_27 = make_channel(IMXDPUV1_ID_FETCHLAYER1,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_8, 27),
  	IMXDPUV1_CHAN_28 = make_channel(IMXDPUV1_ID_FETCHECO0,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 28),
  	IMXDPUV1_CHAN_29 = make_channel(IMXDPUV1_ID_FETCHECO1,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 29),
  	IMXDPUV1_CHAN_30 = make_channel(IMXDPUV1_ID_FETCHECO2,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 30),
  	/* Store Channels */
  	IMXDPUV1_CHAN_32 = make_channel(IMXDPUV1_ID_STORE4, IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 32),
  	IMXDPUV1_CHAN_33 = make_channel(IMXDPUV1_ID_STORE5, IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 33),
  #else
  	/* Fetch Channels */
  	IMXDPUV1_CHAN_00 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_01 = make_channel(IMXDPUV1_ID_FETCHDECODE0,             28, IMXDPUV1_SUB_NONE, 1),
  	IMXDPUV1_CHAN_02 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_1, 2),
  	IMXDPUV1_CHAN_03 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_2, 3),
  	IMXDPUV1_CHAN_04 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_3, 4),
  	IMXDPUV1_CHAN_05 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_4, 5),
  	IMXDPUV1_CHAN_06 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_5, 6),
  	IMXDPUV1_CHAN_07 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_6, 7),
  	IMXDPUV1_CHAN_08 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_7, 8),
  	IMXDPUV1_CHAN_09 = make_channel(IMXDPUV1_ID_FETCHLAYER0,  IMXDPUV1_ID_NONE, IMXDPUV1_SUB_8, 9),
  	IMXDPUV1_CHAN_10 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_1, 10),
  	IMXDPUV1_CHAN_11 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_2, 11),
  	IMXDPUV1_CHAN_12 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_3, 12),
  	IMXDPUV1_CHAN_13 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_4, 13),
  	IMXDPUV1_CHAN_14 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_5, 14),
  	IMXDPUV1_CHAN_15 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_6, 15),
  	IMXDPUV1_CHAN_16 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_7, 16),
  	IMXDPUV1_CHAN_17 = make_channel(IMXDPUV1_ID_FETCHWARP2,               30, IMXDPUV1_SUB_8, 17),
  	IMXDPUV1_CHAN_18 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_19 = make_channel(IMXDPUV1_ID_FETCHDECODE1,             29, IMXDPUV1_SUB_NONE, 19),
  	IMXDPUV1_CHAN_20 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_21 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_22 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_23 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_24 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_25 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_26 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_27 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_28 = make_channel(IMXDPUV1_ID_FETCHECO0,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 28),
  	IMXDPUV1_CHAN_29 = make_channel(IMXDPUV1_ID_FETCHECO1,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 29),
  	IMXDPUV1_CHAN_30 = make_channel(IMXDPUV1_ID_FETCHECO2,    IMXDPUV1_ID_NONE, IMXDPUV1_SUB_NONE, 30),
  	/* Store Channels */
  	IMXDPUV1_CHAN_32 = make_channel(0, 0, 0, 0),
  	IMXDPUV1_CHAN_33 = make_channel(0, 0, 0, 0),
  #endif
  } imxdpuv1_chan_t;
  
  /* Aliases for Channels */
  #define IMXDPUV1_CHAN_VIDEO_0        IMXDPUV1_CHAN_01
  #define IMXDPUV1_CHAN_VIDEO_1        IMXDPUV1_CHAN_19
  
  #define IMXDPUV1_CHAN_INTEGRAL_0    IMXDPUV1_CHAN_00
  #define IMXDPUV1_CHAN_INTEGRAL_1    IMXDPUV1_CHAN_18
  
  #define IMXDPUV1_CHAN_FRACTIONAL_0_1 IMXDPUV1_CHAN_02
  #define IMXDPUV1_CHAN_FRACTIONAL_0_2 IMXDPUV1_CHAN_03
  #define IMXDPUV1_CHAN_FRACTIONAL_0_3 IMXDPUV1_CHAN_04
  #define IMXDPUV1_CHAN_FRACTIONAL_0_4 IMXDPUV1_CHAN_05
  #define IMXDPUV1_CHAN_FRACTIONAL_0_5 IMXDPUV1_CHAN_06
  #define IMXDPUV1_CHAN_FRACTIONAL_0_6 IMXDPUV1_CHAN_07
  #define IMXDPUV1_CHAN_FRACTIONAL_0_7 IMXDPUV1_CHAN_08
  #define IMXDPUV1_CHAN_FRACTIONAL_0_8 IMXDPUV1_CHAN_09
  
  #define IMXDPUV1_CHAN_FRACTIONAL_1_1 IMXDPUV1_CHAN_20
  #define IMXDPUV1_CHAN_FRACTIONAL_1_2 IMXDPUV1_CHAN_21
  #define IMXDPUV1_CHAN_FRACTIONAL_1_3 IMXDPUV1_CHAN_22
  #define IMXDPUV1_CHAN_FRACTIONAL_1_4 IMXDPUV1_CHAN_23
  #define IMXDPUV1_CHAN_FRACTIONAL_1_5 IMXDPUV1_CHAN_24
  #define IMXDPUV1_CHAN_FRACTIONAL_1_6 IMXDPUV1_CHAN_25
  #define IMXDPUV1_CHAN_FRACTIONAL_1_7 IMXDPUV1_CHAN_26
  #define IMXDPUV1_CHAN_FRACTIONAL_1_8 IMXDPUV1_CHAN_27
  
  #define IMXDPUV1_CHAN_WARP_2_1 IMXDPUV1_CHAN_10
  #define IMXDPUV1_CHAN_WARP_2_2 IMXDPUV1_CHAN_11
  #define IMXDPUV1_CHAN_WARP_2_3 IMXDPUV1_CHAN_12
  #define IMXDPUV1_CHAN_WARP_2_4 IMXDPUV1_CHAN_13
  #define IMXDPUV1_CHAN_WARP_2_5 IMXDPUV1_CHAN_14
  #define IMXDPUV1_CHAN_WARP_2_6 IMXDPUV1_CHAN_15
  #define IMXDPUV1_CHAN_WARP_2_7 IMXDPUV1_CHAN_16
  #define IMXDPUV1_CHAN_WARP_2_8 IMXDPUV1_CHAN_17
  
  #define IMXDPUV1_CHAN_CAPTURE_0        IMXDPUV1_CHAN_32
  #define IMXDPUV1_CHAN_CAPTURE_1        IMXDPUV1_CHAN_33
  
  
  /*  IMXDPU Pixel format definitions */
  /*  Four-character-code (FOURCC) */
  #ifdef fourcc
  #warning "fourcc is already defined ... redeifining it here!"
  #undef  fourcc
  #endif
  #define fourcc(a, b, c, d)\
  	 (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
  
  
  /*! @} */
  /*! @name Generic Formats */
  /*! @{ */
  #define IMXDPUV1_PIX_FMT_GENERIC fourcc('D', 'P', 'U', '0')	/*!< IPU Generic Data */
  #define IMXDPUV1_PIX_FMT_GENERIC_32 fourcc('D', 'P', 'U', '1')	/*!< IPU Generic Data */
  #define IMXDPUV1_PIX_FMT_GENERIC_16 fourcc('D', 'P', 'U', '2')	/*!< IPU Generic Data */
  
  /*! @} */
  /*! @name RGB Formats */
  /*! @{ */
  #define IMXDPUV1_PIX_FMT_RGB332  fourcc('R', 'G', 'B', '1')	/*!<  8  RGB-3-3-2    */
  #define IMXDPUV1_PIX_FMT_RGB555  fourcc('R', 'G', 'B', 'O')	/*!< 16  RGB-5-5-5    */
  #define IMXDPUV1_PIX_FMT_RGB565  fourcc('R', 'G', 'B', 'P')	/*!< 16  RGB-5-6-5    */
  #define IMXDPUV1_PIX_FMT_BGRA4444 fourcc('4', '4', '4', '4')	/*!< 16  RGBA-4-4-4-4 */
  #define IMXDPUV1_PIX_FMT_BGRA5551 fourcc('5', '5', '5', '1')	/*!< 16  RGBA-5-5-5-1 */
  #define IMXDPUV1_PIX_FMT_RGB666  fourcc('R', 'G', 'B', '6')	/*!< 18  RGB-6-6-6    */
  #define IMXDPUV1_PIX_FMT_BGR666  fourcc('B', 'G', 'R', '6')	/*!< 18  BGR-6-6-6    */
  #define IMXDPUV1_PIX_FMT_BGR24   fourcc('B', 'G', 'R', '3')	/*!< 24  BGR-8-8-8    */
  #define IMXDPUV1_PIX_FMT_RGB24   fourcc('R', 'G', 'B', '3')	/*!< 24  RGB-8-8-8    */
  #define IMXDPUV1_PIX_FMT_GBR24   fourcc('G', 'B', 'R', '3')	/*!< 24  GBR-8-8-8    */
  #define IMXDPUV1_PIX_FMT_BGR32   fourcc('B', 'G', 'R', '4')	/*!< 32  BGR-8-8-8-8  */
  #define IMXDPUV1_PIX_FMT_BGRA32  fourcc('B', 'G', 'R', 'A')	/*!< 32  BGR-8-8-8-8  */
  #define IMXDPUV1_PIX_FMT_RGB32   fourcc('R', 'G', 'B', '4')	/*!< 32  RGB-8-8-8-8  */
  #define IMXDPUV1_PIX_FMT_RGBA32  fourcc('R', 'G', 'B', 'A')	/*!< 32  RGB-8-8-8-8  */
  #define IMXDPUV1_PIX_FMT_ABGR32  fourcc('A', 'B', 'G', 'R')	/*!< 32  ABGR-8-8-8-8 */
  #define IMXDPUV1_PIX_FMT_ARGB32  fourcc('A', 'R', 'G', 'B')	/*!< 32  ARGB-8-8-8-8 */
  
  /*! @} */
  /*! @name YUV Interleaved Formats */
  /*! @{ */
  #define IMXDPUV1_PIX_FMT_YUYV    fourcc('Y', 'U', 'Y', 'V')	/*!< 16 YUV 4:2:2 */
  #define IMXDPUV1_PIX_FMT_UYVY    fourcc('U', 'Y', 'V', 'Y')	/*!< 16 YUV 4:2:2 */
  #define IMXDPUV1_PIX_FMT_YVYU    fourcc('Y', 'V', 'Y', 'U')	/*!< 16 YVYU 4:2:2 */
  #define IMXDPUV1_PIX_FMT_VYUY    fourcc('V', 'Y', 'U', 'Y')	/*!< 16 VYYU 4:2:2 */
  #define IMXDPUV1_PIX_FMT_Y41P    fourcc('Y', '4', '1', 'P')	/*!< 12 YUV 4:1:1 */
  #define IMXDPUV1_PIX_FMT_YUV444  fourcc('Y', '4', '4', '4')	/*!< 24 YUV 4:4:4 */
  #define IMXDPUV1_PIX_FMT_VYU444  fourcc('V', '4', '4', '4')	/*!< 24 VYU 4:4:4 */
  #define IMXDPUV1_PIX_FMT_AYUV    fourcc('A', 'Y', 'U', 'V')	/*!< 32 AYUV 4:4:4:4 */
  
  /* two planes -- one Y, one Cb + Cr interleaved  */
  #define IMXDPUV1_PIX_FMT_NV12    fourcc('N', 'V', '1', '2')	/* 12  Y/CbCr 4:2:0  */
  #define IMXDPUV1_PIX_FMT_NV16    fourcc('N', 'V', '1', '6')	/* 16  Y/CbCr 4:2:2  */
  
  #define IMXDPUV1_CAP_FMT_RGB24   fourcc('R', 'G', 'B', '3')
  #define IMXDPUV1_CAP_FMT_BT656   fourcc('B', '6', '5', '6')
  #define IMXDPUV1_CAP_FMT_YUYV    fourcc('Y', 'U', 'Y', 'V')
  
  struct imxdpuv1_soc;
  /*!
   * Definition of IMXDPU rectangle structure
   */
  typedef struct {
  	int16_t top;		/* y coordinate of top/left pixel */
  	int16_t left;		/* x coordinate top/left pixel */
  	int16_t width;
  	int16_t height;
  } imxdpuv1_rect_t;
  
  
  /*!
   * Union of initialization parameters for a logical channel.
   */
  typedef union {
  	struct {
  		imxdpuv1_chan_t chan;
  		uint32_t src_pixel_fmt;
  		uint16_t src_width;
  		uint16_t src_height;
  		int16_t clip_top;
  		int16_t clip_left;
  		uint16_t clip_width;
  		uint16_t clip_height;
  		uint16_t stride;
  		uint32_t dest_pixel_fmt;
  		uint8_t blend_mode;
  		uint8_t blend_layer;
  		uint8_t disp_id; /* capture id */
  		int16_t dest_top;
  		int16_t dest_left;
  		uint16_t dest_width;
  		uint16_t dest_height;
  		uint32_t const_color;
  		bool use_global_alpha;
  		bool use_local_alpha;
  	} common;
  	struct {
  		imxdpuv1_chan_t chan;
  		uint32_t src_pixel_fmt;
  		uint16_t src_width;
  		uint16_t src_height;
  		int16_t clip_top;
  		int16_t clip_left;
  		uint16_t clip_width;
  		uint16_t clip_height;
  		uint16_t stride;
  		uint32_t dest_pixel_fmt;
  		uint8_t blend_mode;
  		uint8_t blend_layer;
  		uint8_t capture_id; /* disp_id/capture id */
  		int16_t dest_top;
  		int16_t dest_left;
  		uint16_t dest_width;
  		uint16_t dest_height;
  		uint32_t const_color;
  		bool use_global_alpha;
  		bool use_local_alpha;
  		uint32_t h_scale_factor;    /* downscaling  out/in */
  		uint32_t h_phase;
  		uint32_t v_scale_factor;    /* downscaling  out/in */
  		uint32_t v_phase[2][2];
  		bool use_video_proc;
  		bool interlaced;
  	} store;
  	struct {
  		imxdpuv1_chan_t chan;
  		uint32_t src_pixel_fmt;
  		uint16_t src_width;
  		uint16_t src_height;
  		int16_t clip_top;
  		int16_t clip_left;
  		uint16_t clip_width;
  		uint16_t clip_height;
  		uint16_t stride;
  		uint32_t dest_pixel_fmt;
  		uint8_t blend_mode;
  		uint8_t blend_layer;
  		uint8_t disp_id;
  		int16_t dest_top;
  		int16_t dest_left;
  		uint16_t dest_width;
  		uint16_t dest_height;
  		uint32_t const_color;
  		bool use_global_alpha;
  		bool use_local_alpha;
  		uint32_t h_scale_factor;    /* downscaling  out/in */
  		uint32_t h_phase;
  		uint32_t v_scale_factor;    /* downscaling  out/in */
  		uint32_t v_phase[2][2];
  		bool use_video_proc;
  		bool interlaced;
  	} fetch_decode;
  	struct {
  		imxdpuv1_chan_t chan;
  		uint32_t src_pixel_fmt;
  		uint16_t src_width;
  		uint16_t src_height;
  		int16_t clip_top;
  		int16_t clip_left;
  		uint16_t clip_width;
  		uint16_t clip_height;
  		uint16_t stride;
  		uint32_t dest_pixel_fmt;
  		uint8_t blend_mode;
  		uint8_t blend_layer;
  		uint8_t disp_id; /* capture id */
  		int16_t dest_top;
  		int16_t dest_left;
  		uint16_t dest_width;
  		uint16_t dest_height;
  		uint32_t const_color;
  		bool use_global_alpha;
  		bool use_local_alpha;
  	} fetch_layer;
  	struct {
  		imxdpuv1_chan_t chan;
  		uint32_t src_pixel_fmt;
  		uint16_t src_width;
  		uint16_t src_height;
  		int16_t clip_top;
  		int16_t clip_left;
  		uint16_t clip_width;
  		uint16_t clip_height;
  		uint16_t stride;
  		uint32_t dest_pixel_fmt;
  		uint8_t blend_mode;
  		uint8_t blend_layer;
  		uint8_t disp_id; /* capture id */
  		int16_t dest_top;
  		int16_t dest_left;
  		uint16_t dest_width;
  		uint16_t dest_height;
  		uint32_t const_color;
  		bool use_global_alpha;
  		bool use_local_alpha;
  	} fetch_warp;
  } imxdpuv1_channel_params_t;
  
  /*!
   * Enumeration of IMXDPU video mode flags
   */
  enum imxdpuv1_mode_flags {
  	/* 1 is active high 0 is active low */
  	IMXDPUV1_MODE_FLAGS_HSYNC_POL     = 1 << 0,
  	IMXDPUV1_MODE_FLAGS_VSYNC_POL     = 1 << 1,
  	IMXDPUV1_MODE_FLAGS_DE_POL        = 1 << 2,
  
  	/* drive data on positive .edge */
  	IMXDPUV1_MODE_FLAGS_CLK_POL       = 1 << 3,
  
  	IMXDPUV1_MODE_FLAGS_INTERLACED    = 1 << 4 ,
  
  	/* Left/Right Synchronous display mode,  both display pipe are
  	   combined to make one display. All mode timings are divided by
  	   two for each half screen.
  	   Note: This may not be needed we may force this for any width
  	   over ~2048
  	 */
  	IMXDPUV1_MODE_FLAGS_LRSYNC        = 1 << 8,
  
  	/* Split mode each pipe is split into two displays  */
  	IMXDPUV1_MODE_FLAGS_SPLIT         = 1 << 9,
  
  	IMXDPUV1_MODE_FLAGS_32BIT          = 1 << 16,
  	IMXDPUV1_MODE_FLAGS_BT656_10BIT    = 1 << 17,
  	IMXDPUV1_MODE_FLAGS_BT656_8BIT     = 1 << 18,
  };
  
  struct imxdpuv1_videomode {
  	char name[64];		/* may not be needed */
  
  	uint32_t pixelclock;	/* Hz */
  
  	/* htotal (pixels) = hlen + hfp + hsync + hbp */
  	uint32_t hlen;
  	uint32_t hfp;
  	uint32_t hbp;
  	uint32_t hsync;
  
  	/* field0 - vtotal (lines) = vlen + vfp + vsync + vbp */
  	uint32_t vlen;
  	uint32_t vfp;
  	uint32_t vbp;
  	uint32_t vsync;
  
  	/* field1  */
  	uint32_t vlen1;
  	uint32_t vfp1;
  	uint32_t vbp1;
  	uint32_t vsync1;
  
  	uint32_t flags;
  	uint32_t format;
  	uint32_t dest_format; /*buffer format for capture*/
  	int16_t  clip_top;
  	int16_t  clip_left;
  	uint16_t clip_width;
  	uint16_t clip_height;
  
  };
  
  #define IMXDPUV1_ENABLE  1
  #define IMXDPUV1_DISABLE 0
  
  #define IMXDPUV1_TRUE    1
  #define IMXDPUV1_FALSE   0
  #define IMXDPUV1_OFFSET_INVALID 0x10000000	/* this should force an access error */
  #define IMXDPUV1_CHANNEL_INVALID 0x0	/* this should force an access error */
  
  #define IMXDPUV1_MIN(_X, _Y) ((_X) < (_Y) ? (_X) : (_Y))
  
  /* Native color type */
  #define IMXDPUV1_COLOR_CONSTALPHA_MASK 0xFFU
  #define IMXDPUV1_COLOR_CONSTALPHA_SHIFT 0U
  #define IMXDPUV1_COLOR_CONSTBLUE_MASK 0xFF00U
  #define IMXDPUV1_COLOR_CONSTBLUE_SHIFT 8U
  #define IMXDPUV1_COLOR_CONSTGREEN_MASK 0xFF0000U
  #define IMXDPUV1_COLOR_CONSTGREEN_SHIFT 16U
  #define IMXDPUV1_COLOR_CONSTRED_MASK  0xFF000000U
  #define IMXDPUV1_COLOR_CONSTRED_SHIFT 24U
  
  #define IMXDPUV1_IRQF_NONE    0x0
  #define IMXDPUV1_IRQF_ONESHOT 0x1
  #define IMXDPUV1_INTERRUPT_MAX  (66 + 1)	/* IMXDPUV1_FRAMECAP5_SYNC_OFF_IRQ
  					   (66) is last interrupt */
  
  int imxdpuv1_enable_irq(int8_t imxdpuv1_id, uint32_t irq);
  int imxdpuv1_disable_irq(int8_t imxdpuv1_id, uint32_t irq);
  int imxdpuv1_clear_all_irqs(int8_t imxdpuv1_id);
  int imxdpuv1_clear_irq(int8_t imxdpuv1_id, uint32_t irq);
  int imxdpuv1_init_irqs(int8_t imxdpuv1_id);
  int imxdpuv1_request_irq(int8_t imxdpuv1_id,
  	uint32_t irq,
  	int(*handler) (int, void *),
  	uint32_t irq_flags,
  	const char *devname, void *data) ;
  int imxdpuv1_free_irq(int8_t imxdpuv1_id, uint32_t irq, void *data);
  int imxdpuv1_uninit_interrupts(int8_t imxdpuv1_id);
  int imxdpuv1_handle_irq(int32_t imxdpuv1_id);
  struct imxdpuv1_soc *imxdpuv1_get_soc(int8_t imxdpuv1_id);
  int imxdpuv1_init(int8_t imxdpuv1_id);
  int imxdpuv1_init_sync_panel(int8_t imxdpuv1_id, int8_t disp,
  	uint32_t pixel_fmt,
  	struct imxdpuv1_videomode mode);
  int imxdpuv1_uninit_sync_panel(int8_t imxdpuv1_id, int8_t disp);
  int imxdpuv1_reset_disp_panel(int8_t imxdpuv1_id, int8_t disp);
  int imxdpuv1_disp_init(int8_t imxdpuv1_id, int8_t disp);
  int imxdpuv1_disp_setup_frame_gen(
  	int8_t imxdpuv1_id,
  	int8_t disp,
  	const struct imxdpuv1_videomode *mode,
  	uint16_t cc_red,	/* 10 bits */
  	uint16_t cc_green,	/* 10 bits */
  	uint16_t cc_blue,	/* 10 bits */
  	uint8_t cc_alpha,
  	bool test_mode_enable);
  int imxdpuv1_disp_enable_frame_gen(int8_t imxdpuv1_id,
  	int8_t disp,
  	bool enable);
  int imxdpuv1_disp_setup_constframe(int8_t imxdpuv1_id,
  	int8_t disp,
  	uint8_t bg_red,
  	uint8_t bg_green,
  	uint8_t bg_blue,
  	uint8_t bg_alpha);
  int imxdpuv1_disp_setup_layer(int8_t imxdpuv1_id,
  	const imxdpuv1_layer_t *layer,
  			    imxdpuv1_layer_idx_t layer_idx,
  			    bool is_top_layer);
  void imxdpuv1_disp_dump_mode(const struct imxdpuv1_videomode *mode);
  int imxdpuv1_bytes_per_pixel(uint32_t fmt);
  int imxdpuv1_init_channel_buffer(int8_t imxdpuv1_id,
  	imxdpuv1_chan_t chan,
  	uint32_t stride,
  	imxdpuv1_rotate_mode_t rot_mode,
  	dma_addr_t phyaddr_0,
  	uint32_t u_offset,
  	uint32_t v_offset);
  int32_t imxdpuv1_update_channel_buffer(int8_t imxdpuv1_id,
  	imxdpuv1_chan_t chan,
  	dma_addr_t phyaddr_0);
  int imxdpuv1_init_channel(int8_t imxdpuv1_id,
  	imxdpuv1_channel_params_t *params);
  int imxdpuv1_disp_set_layer_global_alpha(int8_t imxdpuv1_id,
  	imxdpuv1_layer_idx_t layer_idx,
  	uint8_t alpha);
  int imxdpuv1_disp_set_layer_position(int8_t imxdpuv1_id,
  	imxdpuv1_layer_idx_t layer_idx,
  	int16_t x, int16_t y);
  int imxdpuv1_disp_set_chan_position(int8_t imxdpuv1_id,
  	imxdpuv1_chan_t chan,
  	int16_t x, int16_t y);
  int imxdpuv1_disp_update_fgen_status(int8_t imxdpuv1_id, int8_t disp);
  int imxdpuv1_disp_show_fgen_status(int8_t imxdpuv1_id);
  void imxdpuv1_dump_int_stat(int8_t imxdpuv1_id);
  void imxdpuv1_dump_layerblend(int8_t imxdpuv1_id);
  int imxdpuv1_disp_force_shadow_load(int8_t imxdpuv1_id,
  	int8_t disp,
  	uint64_t mask);
  int imxdpuv1_disp_set_chan_crop(int8_t imxdpuv1_id,
  	imxdpuv1_chan_t chan,
  	int16_t  clip_top,
  	int16_t  clip_left,
  	uint16_t clip_width,
  	uint16_t clip_height,
  	int16_t  dest_top,
  	int16_t  dest_left,
  	uint16_t dest_width,
  	uint16_t dest_height);
  void imxdpuv1_dump_pixencfg_status(int8_t imxdpuv1_id);
  int imxdpuv1_dump_channel(int8_t imxdpuv1_id, imxdpuv1_chan_t chan);
  uint32_t imxdpuv1_get_planes(uint32_t fmt);
  
  int imxdpuv1_disp_setup_channel(int8_t imxdpuv1_id,
  			      imxdpuv1_chan_t chan,
  			      uint32_t src_pixel_fmt,
  			      uint16_t src_width,
  			      uint16_t src_height,
  			      int16_t clip_top,
  			      int16_t clip_left,
  			      uint16_t clip_width,
  			      uint16_t clip_height,
  			      uint16_t stride,
  			      uint8_t disp_id,
  			      int16_t dest_top,
  			      int16_t dest_left,
  			      uint16_t dest_width,
  			      uint16_t dest_height,
  			      uint32_t const_color,
  			      bool use_global_alpha,
  			      bool use_local_alpha,
  			      unsigned int disp_addr);
  int imxdpuv1_disp_check_shadow_loads(int8_t imxdpuv1_id, int8_t disp);
  
  int imxdpuv1_cap_setup_frame(
  	int8_t imxdpuv1_id,
  	int8_t src_id,
  	int8_t dest_id,
  	int8_t sync_count,
  	const struct imxdpuv1_videomode *cap_mode);
  int imxdpuv1_cap_setup_crop(
  	int8_t imxdpuv1_id,
  	int8_t src_id,
  	int16_t  clip_top,
  	int16_t  clip_left,
  	uint16_t clip_width,
  	uint16_t clip_height);
  
  int imxdpuv1_cap_enable(int8_t imxdpuv1_id, int8_t cap, bool enable);
  int imxdpuv1_cap_request_shadow_load(int8_t imxdpuv1_id, int8_t dest_id, uint32_t mask);
  
  /* FIXME: add api if needed */
  static inline int32_t imxdpuv1_csi_enable_mclk_if(int8_t imxdpuv1_id, int src, uint32_t cap,
  		bool flag, bool wait)
  {
  	printf("%s(): %s:%d stubbed feature
  ", __func__, __FILE__, __LINE__);
  	return 0;
  }
  #endif				/* IMXDPUV1_H */