/*
 * Copyright (C) 2018 Synaptics Incorporated. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND
 * SYNAPTICS EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE, AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY
 * INTELLECTUAL PROPERTY RIGHTS. IN NO EVENT SHALL SYNAPTICS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE, OR
 * CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION WITH THE USE
 * OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED AND
 * BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF
 * COMPETENT JURISDICTION DOES NOT PERMIT THE DISCLAIMER OF DIRECT
 * DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' TOTAL CUMULATIVE LIABILITY
 * TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. DOLLARS.
 */

#define _VPP_ISR_C_
#include "vpp_module.h"
#include "vpp_cfg.h"
#include "vpp_bcmbuf.h"
#include "api_avio_dhub.h"
#include "vpp_api.h"
#include "io.h"
#include "show_logoframe.h"
#include "vpp_bcm_cmds_isr.h"
#include <common.h>

#define avioDhubSemMap_vpp_vppCPCB0_intr avioDhubSemMap_vpp128b_vpp_inr0
#define avioDhubSemMap_vpp_vppOUT4_intr avioDhubSemMap_vpp128b_vpp_inr6
#define bTST(x, b) (((x) >> (b)) & 1)

#define VPP_BCMBUF_WRITE(a, d) VPP_BCMBUF_Write(vpp_obj->pVbiBcmBuf, a, d)
#define VPP_BCMBUF_WRITE_CLEARBUF(a, d) \
                VPP_BCMBUF_Write(vpp_obj->pVbiClearBcmBuf, a, d)

static VOID VPP_CPCB_ISR_service(VPP_OBJ *vpp_obj);
static VOID disp_callback_dummy(VOID *param);

voidfunc_t disp_isr_service = disp_callback_dummy;
voidfunc_t disp_after_isr_service = disp_callback_dummy;
voidfunc_t disp_dsr_service = disp_callback_dummy;

static VOID disp_callback_dummy(VOID *param)
{
    (void)param;
}

VOID VPP_RegisterInterruptService(voidfunc_t f1, voidfunc_t f2, voidfunc_t f3)
{
    if (NULL != f1)
        disp_isr_service = f1;
    if (NULL != f2)
        disp_after_isr_service = f2;
    if (NULL != f3)
        disp_dsr_service = f3;
    return;
}

void VPP_Enable_ISR_Interrupt(VPP_OBJ *vpp_obj, int cpcbID)
{
    vpp_obj->pSemHandle = dhub_semaphore(&VPP_dhubHandle.dhub);
    if (cpcbID == CPCB_1) {
        /* configure and enable CPCB0 interrupt */
        semaphore_cfg(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppCPCB0_intr,
                1, 0);
        semaphore_clr_full(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppCPCB0_intr);
        semaphore_intr_enable(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppCPCB0_intr, 0,
                1, 0, 0, 0);
        semaphore_cfg(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppOUT4_intr,
                1, 0);
        semaphore_clr_full(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppOUT4_intr);
        semaphore_intr_enable(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppOUT4_intr, 0,
                1, 0, 0, 0);
    }
}

void VPP_Disable_ISR_Interrupt(VPP_OBJ *vpp_obj, int cpcbID)
{
    vpp_obj->pSemHandle = dhub_semaphore(&VPP_dhubHandle.dhub);
    if (cpcbID == CPCB_1) {
        semaphore_clr_full(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppCPCB0_intr);
        semaphore_intr_enable(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppCPCB0_intr, 0,
                0, 0, 0, 0);
        semaphore_clr_full(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppOUT4_intr);
        semaphore_intr_enable(vpp_obj->pSemHandle,
                avioDhubSemMap_vpp_vppOUT4_intr, 0,
                0, 0, 0, 0);
    }
    return;
}

static void updateFEChannelCurrentFrame(VPP_OBJ *vpp_obj)
{
    VBUF_INFO *pinfo;

    if (vpp_obj->dvstatus == STATUS_DISP_VIDEO) {
        /* recycle only when new frame is popped */
        if (vpp_obj->prev_curr_frame != vpp_obj->curr_frame &&
                vpp_obj->prev_curr_frame)
            frmq_push(&vpp_obj->outputq, vpp_obj->prev_curr_frame);

        vpp_obj->prev_curr_frame = vpp_obj->curr_frame;
        vpp_obj->curr_frame = NULL;
        /* try to get a new frame descriptor from frame queue */
        while (frmq_pop(&vpp_obj->inputq, (void **)&pinfo)) {
            frmq_pop_commit(&vpp_obj->inputq);
            /* recycle current frame descriptor */
            if (vpp_obj->curr_frame) {
                frmq_push(&vpp_obj->outputq,
                    vpp_obj->curr_frame);
            }
            vpp_obj->curr_frame = pinfo;
        }
        /*repeat the old frame if no one is not popped*/
        if (!vpp_obj->curr_frame)
            vpp_obj->curr_frame = vpp_obj->prev_curr_frame;
        vpp_obj->frm_count++;
    }
}

static int startChannelDataLoader(VPP_OBJ *vpp_obj)
{
    VBUF_INFO *pinfo;
    UINT32 *cfgQ, *cfgQ_shadow;
    UINT32 *cfgQ_len;

    cfgQ_shadow = vpp_obj->curr_cpcb_vbi_dma_cfgQ->addr;
    cfgQ_len = &(vpp_obj->curr_cpcb_vbi_dma_cfgQ->len);

    if (vpp_obj->dvstatus == STATUS_DISP_VIDEO)
        pinfo = vpp_obj->curr_frame;
    else
        return MV_VPP_OK;
    if (pinfo == NULL)
        return MV_VPP_OK;
    cfgQ = cfgQ_shadow + *cfgQ_len * 2;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
    *cfgQ_len += START_2NDDMA(&VPP_dhubHandle, vpp_obj->dmaRID,
            (UINT32)pinfo->m_pbuf_start,
            pinfo->m_buf_stride, pinfo->m_buf_stride, 1,
            pinfo->m_buf_stride, pinfo->m_active_height, (T64b *) cfgQ);
#pragma GCC diagnostic pop
    return MV_VPP_OK;
}

int VPP_ISR_Handler(UINT32 msg_id, UINT32 msg_para, VPP_OBJ *vpp_obj)
{
    int instat;
    HRESULT rc;
    unsigned int EmptySts;

    if (vpp_obj->status != STATUS_ACTIVE)
        return 0;

    if (VPP_CC_MSG_TYPE_VPP == msg_id) {
        instat = msg_para;
        /* CPCB-0 VBI interrupt */
        if (bTST(instat, avioDhubSemMap_vpp_vppCPCB0_intr)) {
            BCM_SCHED_GetEmptySts(0, &EmptySts);

            if (EmptySts == 0) {
                vpp_obj->skip_vde_int = 1;
                return 0;
            } else {
                vpp_obj->skip_vde_int = 0;
            }

            disp_dsr_service((void *)vpp_obj);

            /* current VBI BCM cfgQ */
            vpp_obj->curr_vbi_bcm_cfgQ =
                vpp_obj->curr_cpcb_vbi_bcm_cfgQ;

            /* reset vbi bcm & dma cfgQ length */
            vpp_obj->curr_cpcb_vbi_bcm_cfgQ->len = 0;
            vpp_obj->curr_cpcb_vbi_dma_cfgQ->len = 0;
            /* select BCM buffer for the CPCB */
            vpp_obj->pVbiBcmBuf =
                vpp_obj->pVbiBcmBufCpcb[CPCB_1];

            /* select BCM sub-buffer to dump register settings */
            VPP_BCMBUF_Select(vpp_obj->pVbiBcmBuf, CPCB_1);

            /* select CLEAR BCM buffer for the CPCB */
            vpp_obj->pVbiClearBcmBuf =
                vpp_obj->pVbiClearBcmBufCpcb[CPCB_1];

            VPP_BCMBUF_Select(vpp_obj->pVbiClearBcmBuf, CPCB_1);

            disp_isr_service(vpp_obj);

            VPP_CPCB_ISR_service(vpp_obj);
            /* generate CPCB-0 CLEAR BCM DHUB cmdQ and,*/
            rc = VPP_BCMBUF_To_CFGQ(vpp_obj->pVbiClearBcmBuf,
                    vpp_obj->curr_vbi_bcm_cfgQ);

            if (rc == MV_VPP_OK) {
                if (vpp_obj->pVbiClearBcmBufCpcb[CPCB_1] ==
                        &vpp_obj->vbi_clear_bcm_buf[0])
                    vpp_obj->pVbiClearBcmBufCpcb[CPCB_1] =
                        &vpp_obj->vbi_clear_bcm_buf[1];
                else
                    vpp_obj->pVbiClearBcmBufCpcb[CPCB_1] =
                        &vpp_obj->vbi_clear_bcm_buf[0];
            }

            /* generate CPCB-0 BCM DHUB cmdQ and,*/
            rc = VPP_BCMBUF_To_CFGQ(vpp_obj->pVbiBcmBuf,
                    vpp_obj->curr_vbi_bcm_cfgQ);
            VPP_CFGQ_To_CFGQ(vpp_obj->curr_cpcb_vbi_dma_cfgQ,
                    vpp_obj->curr_vbi_bcm_cfgQ);

            if (rc == MV_VPP_OK) {
                /* switch BCM buffer for the CPCB */
                if (vpp_obj->pVbiBcmBufCpcb[CPCB_1] ==
                        &vpp_obj->vbi_bcm_buf[0])
                    vpp_obj->pVbiBcmBufCpcb[CPCB_1] =
                        &vpp_obj->vbi_bcm_buf[1];
                else
                    vpp_obj->pVbiBcmBufCpcb[CPCB_1] =
                        &vpp_obj->vbi_bcm_buf[0];
            }

            rc = VPP_BCMDHUB_CFGQ_Commit(vpp_obj->curr_vbi_bcm_cfgQ,
                    CPCB_1, 0);

            if (vpp_obj->curr_cpcb_vbi_dma_cfgQ ==
                        &vpp_obj->vbi_dma_cfgQ[0])
                vpp_obj->curr_cpcb_vbi_dma_cfgQ =
                        &(vpp_obj->vbi_dma_cfgQ[1]);
            else
                vpp_obj->curr_cpcb_vbi_dma_cfgQ =
                        &(vpp_obj->vbi_dma_cfgQ[0]);

            if (vpp_obj->curr_cpcb_vbi_bcm_cfgQ ==
                        &vpp_obj->vbi_bcm_cfgQ[0])
                vpp_obj->curr_cpcb_vbi_bcm_cfgQ =
                        &(vpp_obj->vbi_bcm_cfgQ[1]);
            else
                vpp_obj->curr_cpcb_vbi_bcm_cfgQ =
                        &(vpp_obj->vbi_bcm_cfgQ[0]);
        }

    }
    return MV_VPP_OK;
}

void VPP_CPCB_ISR_service(VPP_OBJ *vpp_obj)
{
    static unsigned int x = 0;
    static unsigned int y = 0;
    static unsigned int w = 0;
    static unsigned int h = 0;

    unsigned int main_TG_PL_X, main_TG_PL_Y;
    unsigned int crop_TG_PL_X, crop_TG_PL_Y, total_pixels;
    unsigned int dlr_plane_size, dlr_client_size;

    static int first_time_init = 1;
    static VBUF_INFO *pinfo;
#ifdef BOOTLOGO_ANIM
    static int ix = 0, iy = 0;
#endif

    vpp_obj->vbi_num++;
    if ((vpp_obj->dvstatus == STATUS_INACTIVE) ||
                (vpp_obj->vbi_num <= 2))
        return;

    if (vpp_obj->dvstatus != STATUS_INACTIVE) {

    if(frmq_pop(&vpp_obj->inputq, (void **)&pinfo))
    {
        x = pinfo->m_active_left;
        y = pinfo->m_active_top;
        w = pinfo->m_active_width;
        h = pinfo->m_active_height;
    }
#ifdef BOOTLOGO_ANIM
        ix += 2;
        iy += 2;
        if((ix + pinfo->m_active_width) > MV_SYSTEM_XRES ||
            (iy + pinfo->m_active_height) > MV_SYSTEM_YRES)
        {
            ix = 0;
            iy = 0;
        }
        x = ix;
        y = iy;
#endif

        main_TG_PL_X = ((x & 0x1fff) | (((x+w) << 13) & 0x3ffe000));
        main_TG_PL_Y = ((y & 0xfff) | (((y+h) << 12) & 0xfff000));
        crop_TG_PL_X = ((x & 0x1fff) | (((x+w) << 13) & 0x3ffe000));
        crop_TG_PL_Y = ((y & 0xfff) | (((y+h) << 12) & 0xfff000));
        total_pixels = w * h;
        dlr_plane_size = w * h;
        dlr_client_size = ((((w+(w%8)) * 16 + 127) / 128) * h);

        if(first_time_init == 1)
        {
            cmd_ISR_PRE_DL_1[82] = dlr_plane_size;
            cmd_ISR_PRE_DL_1[94] = dlr_client_size;
            cmd_ISR_PRE_DL_1[692] = main_TG_PL_X;
            cmd_ISR_PRE_DL_1[694] = main_TG_PL_Y;
            cmd_ISR_PRE_DL_1[696] = crop_TG_PL_X;
            cmd_ISR_PRE_DL_1[698] = crop_TG_PL_Y;
            cmd_ISR_PRE_DL_1[700] = total_pixels;
            cmd_ISR_PRE_DL_1[702] = main_TG_PL_X;
            cmd_ISR_PRE_DL_1[704] = main_TG_PL_Y;

            VPP_BCMBUF_WriteBlock(vpp_obj->pVbiBcmBuf, cmd_ISR_PRE_DL_1, sizeof(cmd_ISR_PRE_DL_1));
        }
        else
        {
            cmd_ISR_PRE_DL_2[0] = dlr_plane_size;
            cmd_ISR_PRE_DL_2[2] = dlr_client_size;
            cmd_ISR_PRE_DL_2[4] = main_TG_PL_X;
            cmd_ISR_PRE_DL_2[6] = main_TG_PL_Y;
            cmd_ISR_PRE_DL_2[8] = crop_TG_PL_X;
            cmd_ISR_PRE_DL_2[10] = crop_TG_PL_Y;
            cmd_ISR_PRE_DL_2[12] = total_pixels;
            cmd_ISR_PRE_DL_2[14] = main_TG_PL_X;
            cmd_ISR_PRE_DL_2[16] = main_TG_PL_Y;

            VPP_BCMBUF_WriteBlock(vpp_obj->pVbiBcmBuf, cmd_ISR_PRE_DL_2, sizeof(cmd_ISR_PRE_DL_2));
        }
        updateFEChannelCurrentFrame(vpp_obj);
        startChannelDataLoader(vpp_obj);
        if(first_time_init == 1)
        {
            VPP_BCMBUF_WriteBlock(vpp_obj->pVbiBcmBuf, cmd_ISR_PRE_DL_3, sizeof(cmd_ISR_PRE_DL_3));
        }
        else
        {
            VPP_BCMBUF_WriteBlock(vpp_obj->pVbiBcmBuf, cmd_ISR_PRE_DL_4, sizeof(cmd_ISR_PRE_DL_4));
        }
    }
    first_time_init = 0;
    return;
}

VOID MV_VPP_EnableISR(VPP_OBJ *pVpp_obj)
{
    VPP_Enable_ISR_Interrupt(pVpp_obj, CPCB_1);
}

VOID MV_VPP_DisableISR(VPP_OBJ *pVpp_obj)
{
    VPP_Disable_ISR_Interrupt(pVpp_obj, CPCB_1);
}