llc_previewer.c

the preview code includes auto focus, auto whitebalance. it is on TI DM6437 platform

            }

            CSL_FINS(prevRegs->CSUP, PREV_CSUP_CSUPTH,
                (Uint32)prevConfigParams->chromaSuppressionParam.threshold);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->CSUP, PREV_CSUP_CSUPTH);
            if ((Uint32)prevConfigParams->chromaSuppressionParam.threshold
                != x)
            {
                llcPrevDebugErrorStatus = 103;
            }
#endif /* PREVIEWER_DEBUG */
            CSL_FINS(prevRegs->CSUP, PREV_CSUP_CSUPG,
                (Uint32)prevConfigParams->chromaSuppressionParam.gain);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->CSUP, PREV_CSUP_CSUPG);
            if ((Uint32)prevConfigParams->chromaSuppressionParam.gain != x)
            {
                llcPrevDebugErrorStatus = 104;
            }
#endif /* PREVIEWER_DEBUG */
        }

        hwSetupReturnCode = CSL_SOK;
    }
    return hwSetupReturnCode;
}



/**
 *  LLC_prevOneShotPreviewer
 *  It is used to trigger previewer when source is SDRAM.
 */
CSL_Status LLC_prevOneShotPreviewer(
    PSP_previewerChannelCreateMode *prevChannelCreateMode,
    PSP_preview *prevPreviewParams,
    Ptr regs
    )
{
    CSL_Status oneShotReturnCode = CSL_ESYS_INVPARAMS;
#ifdef PREVIEWER_DEBUG
    Uint32 x;
#endif /* PREVIEWER_DEBUG */

    /* parameter validation */
    if (((NULL == regs) || (NULL == prevChannelCreateMode))
        || (NULL == prevPreviewParams))
    {
        oneShotReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        vpssRegs = (CSL_VpssRegsOvly)CSL_VPSS_0_REGS;

        /* set channel mode to one shot mode */
        CSL_FINS(prevRegs->PCR, PREV_PCR_ONESHOT,
            (Uint32)CSL_PREV_PCR_ONESHOT_ONESHOTMODE);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->PCR, PREV_PCR_ONESHOT);
        if ((Uint32)CSL_PREV_PCR_ONESHOT_ONESHOTMODE != x)
        {
            llcPrevDebugErrorStatus = 105;
        }
#endif /* PREVIEWER_DEBUG */
        /* Set previewer source */
        CSL_FINS(prevRegs->PCR, PREV_PCR_SOURCE,
            (Uint32)(prevChannelCreateMode->chanSource.source));
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->PCR, PREV_PCR_SOURCE);
        if ((Uint32)(prevChannelCreateMode->chanSource.source) != x)
        {
            llcPrevDebugErrorStatus = 106;
        }
#endif /* PREVIEWER_DEBUG */

        /* write source address */
        CSL_FINS(prevRegs->RSDR_ADDR, PREV_RSDR_ADDR_RADR,
            ((Uint32)prevPreviewParams->inBuf));
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->RSDR_ADDR, PREV_RSDR_ADDR_RADR);
        if (((Uint32)prevPreviewParams->inBuf) != x)
        {
            llcPrevDebugErrorStatus = 107;
        }
#endif /* PREVIEWER_DEBUG */

        /* write desti address */
        CSL_FINS(prevRegs->WSDR_ADDR, PREV_WSDR_ADDR_ADDR,
            ((Uint32)prevPreviewParams->outBuf));
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WSDR_ADDR, PREV_WSDR_ADDR_ADDR);
        if (((Uint32)prevPreviewParams->outBuf) != x)
        {
            llcPrevDebugErrorStatus = 108;
        }
#endif /* PREVIEWER_DEBUG */

        /* clear buffer memory overflow bit */
        CSL_FINS(vpssRegs->PCR, VPSS_PCR_PRV_WBL_O,
            CSL_VPSS_PCR_PRV_WBL_O_NOOVERFLOW);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(vpssRegs->PCR, VPSS_PCR_PRV_WBL_O);
        if (CSL_VPSS_PCR_PRV_WBL_O_NOOVERFLOW != x)
        {
            llcPrevDebugErrorStatus = 109;
        }
#endif /* PREVIEWER_DEBUG */

        /* trigger previewer */
        CSL_FINS(prevRegs->PCR, PREV_PCR_ENABLE,
            (Uint32)CSL_PREV_PCR_ENABLE_PREV_ENABLE);

        oneShotReturnCode = CSL_SOK;
    }
    return oneShotReturnCode;
}



/**
 *  LLC_prevChannelStatus
 *  It reads previewer status.
 */
CSL_Status LLC_prevChannelStatus(
    Uint8 *channelStatus,
    Ptr regs
    )
{
    CSL_Status chanStatusReturnCode = CSL_ESYS_INVPARAMS;
    Uint32 prevChannelStatus = PSP_PREVIEWER_CHANNEL_BUSY;


    /* parameter validation */
    if ((NULL == regs) || (NULL == channelStatus))
    {
        chanStatusReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        prevChannelStatus = CSL_FEXT(prevRegs->PCR, PREV_PCR_BUSY);
        if (CSL_PREV_PCR_BUSY_NOTBUSY == prevChannelStatus)
        {
            *channelStatus = PSP_PREVIEWER_CHANNEL_FREE;
        }
        else
        {
            *channelStatus = PSP_PREVIEWER_CHANNEL_BUSY;
        }
        chanStatusReturnCode = CSL_SOK;
    }
    return chanStatusReturnCode;
}



/**
 *  LLC_prevPreviewerStatus
 *  It is used to read whether previwer is enabled or not.
 */
CSL_Status LLC_prevPreviewerStatus(
    Uint8 *previewerStatus,
    Ptr regs)
{
    CSL_Status previewerStatusReturnCode = CSL_ESYS_INVPARAMS;

    /* parameter validation */
    if ((NULL == regs) || (NULL == previewerStatus))
    {
        previewerStatusReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        *previewerStatus = CSL_FEXT(prevRegs->PCR, PREV_PCR_ENABLE);
        previewerStatusReturnCode = CSL_SOK;
    }
    return previewerStatusReturnCode;
}



/**
 *  \LLC_prevDarkFrameStatus
 *  It reads dark frame subtract failure status.
 */
CSL_Status LLC_prevDarkFrameStatus(
    Uint8 *darkFrameStatus,
    Ptr regs
    )
{
    CSL_Status darkStatusReturnCode = CSL_ESYS_INVPARAMS;
    Uint32 prevDarkFrameStatus = PSP_PREVIEWER_DARK_FRAME_FAILED;

    /* parameter validation */
    if ((NULL == regs) || (NULL == darkFrameStatus))
    {
        darkStatusReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        prevDarkFrameStatus = CSL_FEXT(prevRegs->PCR, PREV_PCR_DRK_FAIL);
        if (CSL_PREV_PCR_DRK_FAIL_FAIL == prevDarkFrameStatus)
        {
            *darkFrameStatus = PSP_PREVIEWER_DARK_FRAME_FAILED;
        }
        else
        {
            *darkFrameStatus = PSP_PREVIEWER_DARK_FRAME_WORKING;
        }
        darkStatusReturnCode = CSL_SOK;
    }
    return darkStatusReturnCode;
}

/**
 *  LLC_prevSetReadReqExpand
 *  It sets read request expand.
 */
CSL_Status LLC_prevSetReadReqExpand(Uint16 prevExp, Ptr regs)
{
    CSL_Status setReadReqReturnCode = CSL_ESYS_INVPARAMS;
#ifdef PREVIEWER_DEBUG
    Uint32 x;
#endif /* PREVIEWER_DEBUG */

    /* parameter validation */
    if ((NULL == regs) || (NULL == prevExp))
    {
        setReadReqReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        vpssRegs = (CSL_VpssRegsOvly)regs;

        CSL_FINS(vpssRegs->SDR_REQ_EXP, VPSS_SDR_REQ_EXP_PRV_EXP,
            (Uint32)prevExp);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(vpssRegs->SDR_REQ_EXP, VPSS_SDR_REQ_EXP_PRV_EXP);
        if ((Uint32)prevExp != x)
        {
            llcPrevDebugErrorStatus = 110;
        }
#endif /* PREVIEWER_DEBUG */
        setReadReqReturnCode = CSL_SOK;
    }
    return setReadReqReturnCode;
}

/**
 *  LLC_prevGetWriteBufMemOverflow
 *  It gets write buffer memory overflow.
 */
CSL_Status LLC_prevGetWriteBufMemOverflow(Uint8 *prevWBLO, Ptr regs)
{
    CSL_Status getMemOverFlowReturnCode = CSL_ESYS_INVPARAMS;

    /* parameter validation */
    if ((NULL == regs) || (NULL == prevWBLO))
    {
        getMemOverFlowReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        vpssRegs = (CSL_VpssRegsOvly)regs;
        *prevWBLO = CSL_FEXT(vpssRegs->PCR, VPSS_PCR_PRV_WBL_O);
        getMemOverFlowReturnCode = CSL_SOK;
    }
    return getMemOverFlowReturnCode;
}

/**
 *  \LLC_prevSetDFC
 *  It is used to set dark frame capture parameter.
 */
CSL_Status LLC_prevSetDFC(Uint8 DFCState, Uint16 outPitch, Ptr regs)
{
    CSL_Status setDFCReturnCode = CSL_ESYS_INVPARAMS;
#ifdef PREVIEWER_DEBUG
    Uint32 x;
#endif /* PREVIEWER_DEBUG */

    /* parameter validation */
    if (NULL == regs)
    {
        setDFCReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        if (PSP_PREVIEWER_DARK_FRAME_CAPTURE_ENABLE == DFCState)
        {
            /* enable dark frame subtract in PCR */
            CSL_FINS(prevRegs->PCR, PREV_PCR_DRKFCAP,
                (Uint32)CSL_PREV_PCR_DRKFCAP_CAPT_DK_FRM);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_DRKFCAP);
            if ((Uint32)CSL_PREV_PCR_DRKFCAP_CAPT_DK_FRM != x)
            {
                llcPrevDebugErrorStatus = 111;
            }
#endif /* PREVIEWER_DEBUG */
        }
        else
        {
            /* enable dark frame subtract in PCR */
            CSL_FINS(prevRegs->PCR, PREV_PCR_DRKFCAP,
                (Uint32)CSL_PREV_PCR_DRKFCAP_NORMAL);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_DRKFCAP);
            if ((Uint32)CSL_PREV_PCR_DRKFCAP_NORMAL != x)
            {
                llcPrevDebugErrorStatus = 112;
            }
#endif /* PREVIEWER_DEBUG */
        }
        /* set offset value for output image */
        CSL_FINS(prevRegs->WADD_OFFSET, PREV_WADD_OFFSET_OFFSET,
            (Uint32)outPitch);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WADD_OFFSET, PREV_WADD_OFFSET_OFFSET);
        if ((Uint32)outPitch != x)
        {
            llcPrevDebugErrorStatus = 113;
        }
#endif /* PREVIEWER_DEBUG */

        setDFCReturnCode = CSL_SOK;
    }
    return setDFCReturnCode;
}