llc_previewer.c

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

/*******************************************************************************
**+--------------------------------------------------------------------------+**
**|                            ****                                          |**
**|                            ****                                          |**
**|                            ******o***                                    |**
**|                      ********_///_****                                   |**
**|                      ***** /_//_/ ****                                   |**
**|                       ** ** (__/ ****                                    |**
**|                           *********                                      |**
**|                            ****                                          |**
**|                            ***                                           |**
**|                                                                          |**
**|         Copyright (c) 2006-2010 Texas Instruments Incorporated           |**
**|                        ALL RIGHTS RESERVED                               |**
**|                                                                          |**
**| Permission is hereby granted to licensees of Texas Instruments           |**
**| Incorporated (TI) products to use this computer program for the sole     |**
**| purpose of implementing a licensee product based on TI products.         |**
**| No other rights to reproduce, use, or disseminate this computer          |**
**| program, whether in part or in whole, are granted.                       |**
**|                                                                          |**
**| TI makes no representation or warranties with respect to the             |**
**| performance of this computer program, and specifically disclaims         |**
**| any responsibility for any damages, special or consequential,            |**
**| connected with the use of this program.                                  |**
**|                                                                          |**
**+--------------------------------------------------------------------------+**
*******************************************************************************/

/**
 *  \file   llc_previewer.c
 *
 *  \brief  Peviewer LLC layer Function dependencies
 *
 *  This file contains the implementation of LLC layer of the previewer driver.
 *
 *  (C) Copyright 2010, Texas Instruments, Inc
 *
 *
 *  \author     EI2
 *
 *  \version    0.1             Created
 *              1.0             First Release
 */

/******************************************************************************
  Header File Inclusion
 ******************************************************************************/
#include <tistdtypes.h>
#include <std.h>
#include <psp_common.h>
#include <csl_types.h>
#include <csl_error.h>
#include <cslr.h>
#include <soc.h>
#include <cslr_prev.h>
#include <cslr_vpss.h>

#include "psp_previewer.h"
#include "llc_previewer.h"

/******************************************************************************
  Data-Structures
 ******************************************************************************/
/**
 * \brief to access previewer registers
 */
CSL_PrevRegsOvly prevRegs;

/**
 * \brief to access vpss registers
 */
CSL_VpssRegsOvly vpssRegs;

#ifdef PREVIEWER_DEBUG
Uint32 llcPrevDebugErrorStatus = 0;
#endif /* PREVIEWER_DEBUG */

/******************************************************************************
  Functions
 ******************************************************************************/

/**
 *  LLC_prevResetPreviewer
 *  It will reset all register values in previewer.
 */
CSL_Status LLC_prevResetPreviewer(Ptr regs)
{
    CSL_Status resetPrevReturnCode = CSL_ESYS_INVPARAMS;

    /* parameter validation */
    if (NULL == regs)
    {
        resetPrevReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;
        prevRegs->PCR = (Uint32)CSL_PREV_PCR_RESETVAL;
        prevRegs->HORZ_INFO = (Uint32)CSL_PREV_HORZ_INFO_RESETVAL;
        prevRegs->VERT_INFO = (Uint32)CSL_PREV_VERT_INFO_RESETVAL;
        prevRegs->RSDR_ADDR = (Uint32)CSL_PREV_RSDR_ADDR_RESETVAL;
        prevRegs->RADR_OFFSET = (Uint32)CSL_PREV_RADR_OFFSET_RESETVAL;
        prevRegs->DSDR_ADDR = (Uint32)CSL_PREV_DSDR_ADDR_RESETVAL;
        prevRegs->DRKF_OFFSET = (Uint32)CSL_PREV_DRKF_OFFSET_RESETVAL;
        prevRegs->WSDR_ADDR = (Uint32)CSL_PREV_WSDR_ADDR_RESETVAL;
        prevRegs->WADD_OFFSET = (Uint32)CSL_PREV_WADD_OFFSET_RESETVAL;
        prevRegs->AVE = (Uint32)CSL_PREV_AVE_RESETVAL;
        prevRegs->HMED = (Uint32)CSL_PREV_HMED_RESETVAL;
        prevRegs->NF = (Uint32)CSL_PREV_NF_RESETVAL;
        prevRegs->WB_DGAIN = (Uint32)CSL_PREV_WB_DGAIN_RESETVAL;
        prevRegs->WBGAIN = (Uint32)CSL_PREV_WBGAIN_RESETVAL;
        prevRegs->WBSEL = (Uint32)CSL_PREV_WBSEL_RESETVAL;
        prevRegs->CFA = (Uint32)CSL_PREV_CFA_RESETVAL;
        prevRegs->BLKADJOFF = (Uint32)CSL_PREV_BLKADJOFF_RESETVAL;
        prevRegs->RGB_MAT1 = (Uint32)CSL_PREV_RGB_MAT1_RESETVAL;
        prevRegs->RGB_MAT2 = (Uint32)CSL_PREV_RGB_MAT2_RESETVAL;
        prevRegs->RGB_MAT3 = (Uint32)CSL_PREV_RGB_MAT3_RESETVAL;
        prevRegs->RGB_MAT4 = (Uint32)CSL_PREV_RGB_MAT4_RESETVAL;
        prevRegs->RGB_MAT5 = (Uint32)CSL_PREV_RGB_MAT5_RESETVAL;
        prevRegs->RGB_OFF1 = (Uint32)CSL_PREV_RGB_OFF1_RESETVAL;
        prevRegs->RGB_OFF2 = (Uint32)CSL_PREV_RGB_OFF2_RESETVAL;
        prevRegs->CSC0 = (Uint32)CSL_PREV_CSC0_RESETVAL;
        prevRegs->CSC1 = (Uint32)CSL_PREV_CSC1_RESETVAL;
        prevRegs->CSC2 = (Uint32)CSL_PREV_CSC2_RESETVAL;
        prevRegs->CSC_OFFSET = (Uint32)CSL_PREV_CSC_OFFSET_RESETVAL;
        prevRegs->CNT_BRT = (Uint32)CSL_PREV_CNT_BRT_RESETVAL;
        prevRegs->CSUP = (Uint32)CSL_PREV_CSUP_RESETVAL;
        prevRegs->SETUP_YC = (Uint32)CSL_PREV_SETUP_YC_RESETVAL;

        resetPrevReturnCode = CSL_SOK;
    }
    return resetPrevReturnCode;
}



/**
 *  LLC_prevHardwareSetup
 *  It configure previewer parameters in previewer registers.
 */
CSL_Status LLC_prevHardwareSetup(
    PSP_previewerChannelCreateMode *prevChannelCreateMode,
    PSP_previewerParams *prevConfigParams,
    Ptr regs
    )
{
    CSL_Status hwSetupReturnCode = CSL_ESYS_INVPARAMS;
    Uint32 i = 0;
    Uint32 tempVar = 0;
#ifdef PREVIEWER_DEBUG
    Uint32 x;
#endif /* PREVIEWER_DEBUG */

    /* parameter validation */
    if (((NULL == regs) || (NULL == prevChannelCreateMode))
        || (NULL == prevConfigParams))
    {
        hwSetupReturnCode = CSL_ESYS_INVPARAMS;
    }
    else
    {
        prevRegs = (CSL_PrevRegsOvly)regs;

        /* 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 = 2;
        }
#endif /* PREVIEWER_DEBUG */

        /* set channel mode */
        if (PSP_PREVIEWER_CHANNEL_CCDC
            == prevChannelCreateMode->chanSource.source)
        {
            /* Set continuous mode */
            CSL_FINS(prevRegs->PCR, PREV_PCR_ONESHOT,
                (Uint32)CSL_PREV_PCR_ONESHOT_CONTINUOUS_VIA_VPORT);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_ONESHOT);
            if ((Uint32)CSL_PREV_PCR_ONESHOT_CONTINUOUS_VIA_VPORT != x)
            {
                llcPrevDebugErrorStatus = 3;
            }
#endif /* PREVIEWER_DEBUG */
        }
        else
        {
            /* Set 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 = 4;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* Set pixel width */
        if (PSP_PREVIEWER_INWIDTH_8BIT == prevConfigParams->sizeParam.pixelSize)
        {
            CSL_FINS(prevRegs->PCR, PREV_PCR_WIDTH,
                (Uint32)(CSL_PREV_PCR_WIDTH_8_BITWIDE));
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_WIDTH);
            if ((Uint32)(CSL_PREV_PCR_WIDTH_8_BITWIDE) != x)
            {
                llcPrevDebugErrorStatus = 5;
            }
#endif /* PREVIEWER_DEBUG */
        }
        else
        {
            CSL_FINS(prevRegs->PCR, PREV_PCR_WIDTH,
                (Uint32)CSL_PREV_PCR_WIDTH_10_BITWIDE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_WIDTH);
            if ((Uint32)CSL_PREV_PCR_WIDTH_10_BITWIDE != x)
            {
                llcPrevDebugErrorStatus = 6;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* set offset value for input image */
        if (PSP_PREVIEWER_CHANNEL_SDRAM
            == prevChannelCreateMode->chanSource.source)
        {
            CSL_FINS(prevRegs->RADR_OFFSET, PREV_RADR_OFFSET_OFFSET,
                (Uint32)prevConfigParams->sizeParam.inPitch);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->RADR_OFFSET, PREV_RADR_OFFSET_OFFSET);
            if ((Uint32)prevConfigParams->sizeParam.inPitch != x)
            {
                llcPrevDebugErrorStatus = 7;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* set offset value for output image */
        CSL_FINS(prevRegs->WADD_OFFSET, PREV_WADD_OFFSET_OFFSET,
            (Uint32)prevConfigParams->sizeParam.outPitch);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WADD_OFFSET, PREV_WADD_OFFSET_OFFSET);
        if ((Uint32)prevConfigParams->sizeParam.outPitch != x)
        {
            llcPrevDebugErrorStatus = 8;
        }
#endif /* PREVIEWER_DEBUG */
        /* set horizontal info */
        CSL_FINS(prevRegs->HORZ_INFO, PREV_HORZ_INFO_SPH,
            (Uint32)prevConfigParams->sizeParam.sph);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->HORZ_INFO, PREV_HORZ_INFO_SPH);
        if ((Uint32)prevConfigParams->sizeParam.sph != x)
        {
            llcPrevDebugErrorStatus = 9;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->HORZ_INFO, PREV_HORZ_INFO_EPH,
            (Uint32)prevConfigParams->sizeParam.eph);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->HORZ_INFO, PREV_HORZ_INFO_EPH);
        if ((Uint32)prevConfigParams->sizeParam.eph != x)
        {
            llcPrevDebugErrorStatus = 10;
        }
#endif /* PREVIEWER_DEBUG */
        /* set vertical info */
        CSL_FINS(prevRegs->VERT_INFO, PREV_VERT_INFO_SLV,
            (Uint32)prevConfigParams->sizeParam.slv);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->VERT_INFO, PREV_VERT_INFO_SLV);
        if ((Uint32)prevConfigParams->sizeParam.slv != x)
        {
            llcPrevDebugErrorStatus = 11;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->VERT_INFO, PREV_VERT_INFO_ELV,
            (Uint32)prevConfigParams->sizeParam.elv);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->VERT_INFO, PREV_VERT_INFO_ELV);
        if ((Uint32)prevConfigParams->sizeParam.elv != x)
        {
            llcPrevDebugErrorStatus = 12;
        }
#endif /* PREVIEWER_DEBUG */
        /* Enable writing to DDRAM */
        CSL_FINS(prevRegs->PCR, PREV_PCR_SDRPORT,
            (Uint32)CSL_PREV_PCR_SDRPORT_ENABLE);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->PCR, PREV_PCR_SDRPORT);
        if ((Uint32)CSL_PREV_PCR_SDRPORT_ENABLE != x)
        {
            llcPrevDebugErrorStatus = 13;
        }
#endif /* PREVIEWER_DEBUG */
        /* diable RSZPORT port */
        CSL_FINS(prevRegs->PCR, PREV_PCR_RSZPORT,
            CSL_PREV_PCR_RSZPORT_DISABLE);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->PCR, PREV_PCR_RSZPORT);
        if (CSL_PREV_PCR_RSZPORT_DISABLE != x)
        {
            llcPrevDebugErrorStatus = 14;
        }
#endif /* PREVIEWER_DEBUG */

        /* set contrast and brightness */
        CSL_FINS(prevRegs->CNT_BRT, PREV_CNT_BRT_CNT,
            (Uint32)prevConfigParams->contrast);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->CNT_BRT, PREV_CNT_BRT_CNT);
        if ((Uint32)prevConfigParams->contrast != x)
        {
            llcPrevDebugErrorStatus = 15;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->CNT_BRT, PREV_CNT_BRT_BRT,
            (Uint32)prevConfigParams->brightness);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->CNT_BRT, PREV_CNT_BRT_BRT);
        if ((Uint32)prevConfigParams->brightness != x)
        {
            llcPrevDebugErrorStatus = 16;
        }
#endif /* PREVIEWER_DEBUG */


        /* set output format in PCR */