/*******************************************************************************
* Copyright (C) Marvell International Ltd. and its affiliates
*
* Marvell GPL License Option
*
* If you received this File from Marvell, you may opt to use, redistribute and/or
* modify this File in accordance with the terms and conditions of the General
* Public License Version 2, June 1991 (the "GPL License"), a copy of which is
* available along with the File in the license.txt file or by writing to the Free
* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
* on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
* WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
* DISCLAIMED.  The GPL License provides additional details about this warranty
* disclaimer.
********************************************************************************/

#ifndef _VPP_MODULE_H_
#define _VPP_MODULE_H_

#include "api_avio_dhub.h"
#include "thinvpp_common.h"
#include "thinvpp_api.h"
#include "thinvpp_bcmbuf.h"

#ifdef __cplusplus
extern "C" {
#endif

#define THINVPP_MALLOC(s) UtilMemAlloc(s)
#define THINVPP_MEMSET UtilMemSet
#define THINVPP_MEMCPY UtilMemCpy
#define THINVPP_FREE(x)


/* helper MACROs */
#define CPCB_OF_CHAN(vpp_obj, chanID)      (vpp_obj->chan[chanID].dvID)
#define CPCB_OF_VOUT(vpp_obj, voutID)      (vpp_obj->vout[voutID].dvID)

#if BOOTLOADER_SHOWLOGO
#define START_1DDMA(dhubID, dmaID, start_addr, size, cfgQ, ptr) \
    dhub_channel_big_write_cmd(&(((HDL_dhub2d *)dhubID)->dhub), dmaID, (int)start_addr, size, 0, 0, 0, 1, cfgQ, ptr)

#define START_2DDMA(dhubID, dmaID, start_addr, stride, width, height, cfgQ) \
    dhub2d_channel_cfg((HDL_dhub2d *)dhubID, dmaID, start_addr, stride, width, height, 1, 0, 0, 0, 0, 1, cfgQ)
#endif

#define VPP_REG_WRITE32(reg, val) THINVPP_BCMBUF_Write(vpp_obj->pVbiBcmBuf, vpp_obj->base_addr+(reg), (val))
#define VPP_REG_WRITE8(reg, val) THINVPP_BCMBUF_Write(vpp_obj->pVbiBcmBuf, vpp_obj->base_addr+((reg)<<2), (val))

#define GLB_REG_WRITE32(reg, val) *(volatile int *)(reg) = (val)
#define GLB_REG_READ32(reg)  (*(volatile int *)(reg))
#define VPP_REG_READ32_RAW(reg) (*(volatile int *)(vpp_obj->base_addr+(reg)))
#define VPP_REG_READ8_RAW(reg)  (*(volatile int *)(vpp_obj->base_addr+((reg)<<2)))
#define VPP_REG_WRITE32_RAW(reg, val) *(volatile int *)(vpp_obj->base_addr+(reg)) = (val)
#define VPP_REG_WRITE8_RAW(reg, val)  *(volatile int *)(vpp_obj->base_addr+((reg)<<2)) = (val)

/***************************************************************
* DESCR: get the one byte of a unsigned int
* PARAMS: uint32 - an unsigned int
****************************************************************/
#define GET_LOWEST_BYTE(uint32) ((uint32) & 0xFF)
#define GET_SECOND_BYTE(uint32) (((uint32) & 0xFF00) >> 8)
#define GET_THIRD_BYTE(uint32) (((uint32) & 0xFF0000) >> 16)

/***************************************************************
* DESCR: load register default value by name
* PARAMS: RegName - register name in maddr.h
*               DefValues - register default value
****************************************************************/
#define WRITE_REG_DEFAULT_VAL(RegName, DefValues)\
do{\
    THINVPP_BCMBUF_Write(vpp_obj->pVbiBcmBuf, vpp_obj->base_addr + (RegName << 2), DefValues.VPP_##RegName);\
}while(0)

#define WRITE_REG_DEFAULT_VAL_32BITS(RegName, DefValues)\
do{\
    THINVPP_BCMBUF_Write(vpp_obj->pVbiBcmBuf, vpp_obj->base_addr + RegName, DefValues.VPP_##RegName);\
}while(0)

/*Enum for maintaining CPCB 0,1 and 2 at Backend*/
typedef enum VPP_CPCB_UNIT_NUM/////////////////////////////////temp put here
{
    VPP_CPCB0  = 0,
    VPP_CPCB1,
    VPP_CPCB2,
    VPP_CPCB_MAX
}VPP_CPCB_UNIT_NUM, *PVPP_CPCB_UNIT_NUM;

/* default window attributes */
#define DEFAULT_BGCOLOR     0 // green
#define DEFAULT_ALPHA       0xff // opaque

/* definition of video resolution type */
enum {
    TYPE_SD = 0,
    TYPE_HD = 1,
};

/* definition of video scan mode */
enum {
    SCAN_PROGRESSIVE = 0,
    SCAN_INTERLACED  = 1,
};

/* definition of video frame-rate */
enum {
    FRAME_RATE_23P98 = 0,
    FRAME_RATE_24    = 1,
    FRAME_RATE_25    = 2,
    FRAME_RATE_29P97 = 3,
    FRAME_RATE_30    = 4,
    FRAME_RATE_47P96 = 5,
    FRAME_RATE_48    = 6,
    FRAME_RATE_50    = 7,
    FRAME_RATE_59P94 = 8,
    FRAME_RATE_60    = 9,
    FRAME_RATE_100   = 10,
    FRAME_RATE_119P88 = 11,
    FRAME_RATE_120   = 12,
};

/* definition of EE working mode */
enum {
    EE_MODE_OFF   = 0, /* disable EE */
    EE_MODE_ON    = 1, /* enable EE*/
};

/* definition of VPP in-line and off-line modes */
enum {
    MODE_INLINE     = 0,
    MODE_OFFLINE    = 1,
};

/* definition of HV scaling coeff selection */
enum {
    MODE_COEFF_SEL_AUTO      = 0,
    MODE_COEFF_SEL_FORCE_H   = 1,
    MODE_COEFF_SEL_FORCE_V   = 2,
    MODE_COEFF_SEL_FORCE_HV  = 3,
};

/* definition of stages of a pipeline */
enum {
    STAGE_FE    = 0,
    STAGE_SCL   = 1,
    STAGE_CPCB  = 2,
    STAGE_BE    = 3,
    MAX_NUM_STAGES = 4
};

enum {
    SENSIO_DISABLE     = 0,
    SENSIO_SCALE_ONLY  = 1,
    SENSIO_FILTER_ONLY = 2,
    SENSIO_FULL        = 3,
};

typedef struct EVENT_CALLBACK_T{
    volatile int status;         // registered or not
    FUNCPTR cb_func;    // callback function
    int params[MAX_NUM_PARAMS];     // function parameters
} EVENT_CALLBACK;

typedef struct OFFLINE_BUFF_DESCR_T{
    void *addr; // offline buffer address
    int size; // data size in byte
    VPP_WIN disp_win; // display window in end display for content in this offline buffer
    VPP_WIN content_win; // content window in end display for content in this offline buffer
}OFFLINE_BUFF_DESCR;

typedef struct PLANE_T {
    volatile int status;         // active or not
    int mode;           // off-line or in-line mode, only valid for main & PIP video
    int srcfmt;         // video component data format in input frame buffer
    int order;          // video component data order in input frame buffer

    int wpl;            // beat per line of current frame

    int dmaRID;         // plane inline read DMA channel ID
    int dmaRdhubID;     // ID of Dhub on which inline read DMA channel is connected

    /* offline write-back/read-back DMAs are only available for Berlin Main/PIP/AUX plane */
    int offline_dmaWID;  // plane offline write-back DMA channel ID
    int offline_dmaWdhubID;     // ID of Dhub on which offline write-back DMA channel is connected
    int offline_dmaRID;  // plane offline read-back DMA channel ID
    int offline_dmaRdhubID;     // ID of Dhub on which offline read-back DMA channel is connected

    VPP_WIN actv_win;   // plane display content location and size in reference window
                        // this information is a copy from frame descriptor for register updating purpose.
    VPP_WIN ref_win;   // plane display reference window
#if BOOTLOADER_SHOWLOGO
    VBUF_INFO * pinfo;
#endif
} PLANE;


typedef struct CHAN_T {
    volatile int status;          // active or not
    int dvID;            // ID of the DV, which this channel belongs to
    int dvlayerID;       // ID of DV layer, which this channel connects to
    int zorder;          // Z-order of DV plane, which this channel connects to
    int scl_in_out_mode;

    VPP_WIN disp_win;                // channel display window in end display
    VPP_WIN_ATTR disp_win_attr;      // channel display window attribute: bgcolor and alpha
} CHAN;

typedef struct DV_T {
    volatile int status;      // active or not
    int num_of_chans;   // number of the channels, which belong to this channel
    int chanID[MAX_NUM_CHANS]; // ID of the channels, which belong to this DV
    int num_of_vouts;   // number of the VOUTs, which belong to this channel
    int voutID[MAX_NUM_VOUTS]; // ID of the VOUTs, which belong to this DV
    int output_res;            // ID of CPCB(for Berlin) or DV(for Galois) output resolution, i.e. end display resolution

#if BOOTLOADER_SHOWLOGO
    DHUB_CFGQ vbi_dma_cfgQ[2];
    DHUB_CFGQ *curr_cpcb_vbi_dma_cfgQ;
    DHUB_CFGQ vbi_bcm_cfgQ[2];
    DHUB_CFGQ *curr_cpcb_vbi_bcm_cfgQ;
#endif

    volatile int vbi_num;     // VBI interrupt counter
} DV;

typedef struct VOUT_T {
    volatile int status;      // active or not
    int dvID;        // ID of the DV, which this VOUT belongs to
} VOUT;

/************************************************/
/************** FE data structures **************/
/************************************************/

/* structure of FE block */
typedef struct FE_T {
    /* NR register local copy */
    unsigned int NrCtrl;
    unsigned int NrMode;
    unsigned int NrYMode;
    unsigned int NrCMode;

    unsigned int CarCtrl1Regs;
    unsigned int CarCtrl2Regs;
    unsigned int NeFbCtrl;
} FE;

/************************************************/
/************** SCL data structures **************/
/************************************************/

/* structure of SCL block */
typedef struct SCL_T {
    /*FRC scaler local buffer*/
#if (BERLIN_CHIP_VERSION >= BERLIN_C_2)
    unsigned int VppFrcSclAlphaCtrl0;
    unsigned int VppFrcSclAlphaCtrl1;
#if (BERLIN_CHIP_VERSION >= BERLIN_BG2)
    unsigned int VppFrcSclAlphaCtrl2;
#endif
#endif
#if (BERLIN_CHIP_VERSION >= BERLIN_B_0)
    unsigned int VppFrcSclBeSwitch0;
    unsigned int VppFrcSclBeSwitch1;
#else
    unsigned int VppFrcSclBeSwitch;
#endif
} SCL;

/************************************************/
/************** CPCB data structures **************/
/************************************************/

/* structure of CPCB block */
typedef struct CPCB_T {
    /*CPCB interlacer local buffer*/
    unsigned int VppCpcb0IntCtrl;
#if (BERLIN_CHIP_VERSION >= BERLIN_B_0)
    unsigned int Cpcb1SrcAlphaPol;
    unsigned int Cpcb1BgAlphaPol;
    unsigned int Cpcb2SrcAlphaPol;
    unsigned int Cpcb2BgAlphaPol;
    unsigned int VppCpcb2IntCtrl;
#else
    unsigned int VppCpcb1IntCtrl;
#endif
#if (BERLIN_CHIP_VERSION >= BERLIN_BG2)
    unsigned int QtcCtrl1;
#endif
    unsigned int *GmBcmBuf[2];
    unsigned int GmBcmBufWIdx;
    unsigned int GmBcmBufRIdx;
} CPCB;

/************************************************/
/************** BE data structures **************/
/************************************************/

typedef struct ENC_T {
   // DACs control
   unsigned int SdDacMode;
   unsigned int HdDacMode;

#if (BERLIN_CHIP_VERSION >= BERLIN_BG2_B0)
    /* BE Encoder DACs Ctrl0 */
    unsigned int DacCtrl0_a;
    unsigned int DacCtrl0_b;
    unsigned int DacCtrl0_c;
    unsigned int DacCtrl0_d;
#endif

   // SD/HD WSS/CGMS control
   unsigned int SdWssCgmsCtrl;
   unsigned int HdWssCgmsCtrl;

   // mute control
   unsigned int EncIOMuteCtrl;

   // HD Output control0
   unsigned int HdCtrl0;
} ENC;

typedef struct HDMI_TX_DRV_T
{
    unsigned char       acrCtrl;
    unsigned char       audCtrl;
    unsigned char       i2sCtrl;
    unsigned char       gcpCfg0;
    unsigned char       gcpCfg1;
    unsigned char       videoCtrl;
    unsigned char       hdmiCtrl;
    unsigned char       avMuteCtrl;
    unsigned char       hostPktCtrl0;
    unsigned char       hostPktCtrl1;
    unsigned char       hostPktData[6][32];
    unsigned int      hostPktCfg[6];
} HDMI_TX_DRV;
typedef struct HDMI_HDCP_DRV_T
{
    unsigned char       ctrlReg;
    unsigned char       stsReg;
    unsigned int      srmData;
} HDMI_HDCP_DRV;

/* structure of BE block */
typedef struct BE_T {
    ENC enc;
#if (BERLIN_CHIP_VERSION >= BERLIN_BG2_Z2)
    unsigned char* VppBeVopLVDSMappingTab;
    unsigned int VppBeVopLVDSFrmtCtrl;
#endif
#if (BERLIN_CHIP_VERSION >= BERLIN_BG2_A0)
    unsigned short *VppBeVopLVDSGammaLUT[3];
    unsigned int VppBeVopLVDSDeGammaLUTSt;
    unsigned int VppBeVopLVDSGammaLUTSt;
    unsigned int VppBeVopLVDSDeGammaBypass;
    unsigned int VppBeVopLVDSDeGammaCtrl;
    unsigned int VppBeVopLVDSGammaCtrl;
    unsigned int *LvdsGmBcmBuf[2];
    unsigned int LvdsGmBcmBufWIdx;
    unsigned int LvdsGmBcmBufRIdx;
#endif
    // Addr of Hdmi Tx data store
    unsigned int hdmiTx;

    // CEC enable control
    int        enableCec;
    // CEC feature configuration
    unsigned int      cecFeatureSupportCfg;
    // Addr of Hdmi Cec data store
    unsigned int      hdmiCec;
    // HDMI Tx driver data
    HDMI_TX_DRV     hdmiTxDrv;

    // HDCP driver data
    HDMI_HDCP_DRV   hdmiHdcpDrv;

    // HDMI Interrupt Status for DSR handling
    unsigned char           hdmiIntSts;
    unsigned char           hdmiFrmIntrTrig;

    // Task control flag
    unsigned char           hdmiTaskExit;
    unsigned char           cecTaskExit;

    // CPCB0 Interrupt status for DSR handling
    unsigned char           cpcb0IntSts;
} BE;


/************************************************/
/*********** VPP object data structures *********/
/************************************************/
typedef struct THINVPP_OBJ_T {
    volatile int    status;                 // active or not

    PLANE  plane[MAX_NUM_PLANES];  // CURSOR, OSD, IG, PG, PIP, MAIN, BG
    CHAN   chan[MAX_NUM_CHANS];    // OSD, PG, PIP, MAIN and BG
    DV     dv[MAX_NUM_CPCBS];        // CPCB-0, CPCB-1, and CPCB-2
    VOUT   vout[MAX_NUM_VOUTS];    // HDMI, Component, S-Video and CVBS
    EVENT_CALLBACK event_cb[MAX_NUM_EVENTS]; // event callbacks

    unsigned int base_addr;       // VPP object hardware base address
    HDL_semaphore *pSemHandle; // semaphore handler of CPCB semaphores

    FE fe;               // FE hardware related settings
    SCL scl;             // SCL hardware related settings
    CPCB cpcb;           // CPCB hardware related settings
    BE be;               // BE hardware related settings

#if (BERLIN_CHIP_VERSION != BERLIN_BG2CD_A0)
    int dhub_cmdQ[avioDhubChMap_vpp_TT_R];
#else // (BERLIN_CHIP_VERSION != BERLIN_BG2CD_A0)
    UINT32 dhub_cmdQ[avioDhubChMap_vpp_SPDIF_W];
#endif // (BERLIN_CHIP_VERSION != BERLIN_BG2CD_A0)

#if BOOTLOADER_SHOWLOGO
    BCMBUF vbi_bcm_buf[2];
    BCMBUF *pVbiBcmBufCpcb[VPP_CPCB_MAX];
#else
    BCMBUF vbi_bcm_buf[1];
#endif
    BCMBUF *pVbiBcmBuf;    //pointer to the VBI BCM buffer in use
    unsigned options;

} THINVPP_OBJ;


/************************************************/
/*********** global VPP container ***************/
/************************************************/
#ifdef _THINVPP_API_C_
THINVPP_OBJ *thinvpp_obj = NULL;
#else
extern THINVPP_OBJ *thinvpp_obj;
#endif

/**************************************************************************/
/****************** Common VPP object Function Calls **********************/
/**************************************************************************/

#ifdef __cplusplus
}
#endif

#endif