drvadc.c

mstar 776 开发的车载dvd

////////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006-2007 MStar Semiconductor, Inc.
// All rights reserved.
//
// Unless otherwise stipulated in writing, any and all information contained
// herein regardless in any format shall remain the sole proprietary of
// MStar Semiconductor Inc. and be kept in strict confidence
// (¨MStar Confidential Information〃) by the recipient.
// Any unauthorized act including without limitation unauthorized disclosure,
// copying, use, reproduction, sale, distribution, modification, disassembling,
// reverse engineering and compiling of the contents of MStar Confidential
// Information is unlawful and strictly prohibited. MStar hereby reserves the
// rights to any and all damages, losses, costs and expenses resulting therefrom.
//
///
///@file drvADC.h
///@brief ADC
///@author MStarSemi Inc.
///
///Scaler Control Scaler up or down to display
///Scaler include
///
///Features:
///- Analog RGB Compliant Input ports
///- Auto-Configuration/Auto Detection
///
///
///@par Example:
///@code
///  // Set ADC auto tune enable/disable
///  void msAPI_ADC_SetAutoADC(BIT bEnable, BIT bIsYPbPrType)
///  {
///      MDrv_ADC_SetAutoADC(bEnable, bIsYPbPrType);
///  }
///@endcode
///

#define DRV_ADC_C

/******************************************************************************/
/*                    Header Files                                            */
/* ****************************************************************************/
#include "board.h"
#include "hwreg.h"

#include "drvvop.h"
#include "drvScaler.h"
#include "drvMode.h"
#include "drvADC.h"
#include "drvvd.h"
#include "drvsys.h"
#include "drvAnalog_inline.h"
#include "panel.h"
#include "msGPIO.h"
#include "drvAuto.h"

#define ADCMSG(x)   //x

// seven
#define  ADC_POWERINIT_MSK_04_L      (_BIT7 | _BIT6)// | _BIT0) // seven
#define  ADC_POWERINIT_MSK_04_H      0//(_BIT0)
#define  ADC_POWERINIT_MSK_05_L      0//(_BIT6 | _BIT5 | _BIT2)
#define  ADC_POWERINIT_MSK_06_L      0//(_BIT0)
#define  ADC_POWERINIT_MSK_06_H      0//(_BIT4 | _BIT2)
#define  ADC_POWERINIT_MSK_08_L      0//(_BIT4)
#define  ADC_POWERINIT_MSK_60_L      0//(_BIT6 | _BIT4)
#define  ADC_POWERINIT_MSK_60_H      0//(0x00)

code MS_REG_TYPE ADC_Init_Tbl[] =
{
    // PLL
    {BK_ADC_ATOP_0C_L, 0x01},    // VCO
    {BK_ADC_ATOP_12_L, 0x01},    // ADC_B VCO Saturn2 may not need to programming this because Saturn2 only has one ADC

//  seven 070927 {BK_ADC_ATOP_1C_L, 0x10},    // SOG trigger lenel

    {BK_ADC_ATOP_46_L, 0x80},    // DAC gain, 0x20
    {BK_ADC_ATOP_46_H, 0x10},    // LVDS/RSDS/TTL output logic regulator voltage contrl
    {BK_ADC_ATOP_2E_L, 0x00},    // I-clamp setting

    {BK_ADC_ATOP_60_L, 0x00},    //DVI
    {BK_ADC_ATOP_60_H, 0x00},

    {BK_ADC_DTOP_01_L, 0x01},    // PLL loop filer control // seven 070830_00
    {BK_ADC_DTOP_01_H, 0x09},    // PLL loop filer control
    {BK_ADC_DTOP_02_L, 0x03},    // PLL loop filer control
//  seven 070927 {BK_ADC_DTOP_04_L, 0x05},    // setting time
//  seven 070927 {BK_ADC_DTOP_04_H, 0x95},    // PLL control for composite sync input
//  seven 070927 {BK_ADC_DTOP_0B_L, 0x10},    // clamp placement
//  seven 070927 {BK_ADC_DTOP_0B_H, 0x08},    // clamp duration

    {_END_OF_TBL_, 0x00},
};

/******************************************************************************/
/*                     Local                                                  */
/* ****************************************************************************/

/******************************************************************************/
/*                   Local Function Prototypes                                */
/******************************************************************************/
/******************************************************************************/
/*                   Functions                                                */
/******************************************************************************/

/******************************************************************************/
///This function will reset ADC gain and offset
/******************************************************************************/
void MDrv_ADC_ResetGainOffset ( void )
{
    MDrv_WriteByte(BK_ADC_DTOP_08_L, 0x80);
    MDrv_WriteByte(BK_ADC_DTOP_08_H, 0x80);
    MDrv_WriteByte(BK_ADC_DTOP_09_L, 0x80);
    MDrv_WriteByte(BK_ADC_DTOP_09_H, 0x80);
    MDrv_WriteByte(BK_ADC_DTOP_0A_L, 0x80);
    MDrv_WriteByte(BK_ADC_DTOP_0A_H, 0x80);
}

void MDrv_ADC_SetPllMul( U8 u8Value)
{
    MDrv_WriteByteMask(BK_ADC_ATOP_0C_L, u8Value, _BIT2|_BIT1|_BIT0);
}

/******************************************************************************/
///This function will set ADC registers for different port
///@param *penMsSysInfo \b IN: pointer to display system information
/******************************************************************************/
void MDrv_ADC_SetVcoControl (MS_INPUT_SOURCE_TYPE enInputSourceType, U8 u8InputClock)
{
    MDrv_WriteRegBit(BK_ADC_ATOP_58_L, ENABLE, _BIT7); // enable test mode, ToDo

    // For complier happy
    enInputSourceType = enInputSourceType;

    {
        // VCO range/Settling time
        if (u8InputClock > 150) // high
        {
            MDrv_ADC_SetPllMul( 0x02);
        }
        else if (u8InputClock > 20) // middle
        {
            MDrv_ADC_SetPllMul( 0x01);
        }
        else // low
        {
            MDrv_ADC_SetPllMul( 0x00);
        }
    }

    MDrv_WriteRegBit(BK_ADC_ATOP_58_L, DISABLE, _BIT7); // disable test mode
}

/******************************************************************************/
///This function will adjust backlight
///@param u8Backlight \b IN backlight value
/******************************************************************************/
//*************************************************************************
//Function name:    MDrv_ADC_AdjustBacklight
//Passing parameter:    U8 u8Backlight
//Return parameter: none
//Description:          set back light
//*************************************************************************
void MDrv_ADC_AdjustBacklight ( U8 u8Backlight )
{
    //lachesis_070220
    Panel_Backlight_PWM_ADJ(u8Backlight);

    // TODO: add code
    if ( u8Backlight )
    {
    }

    // Check with H/W designer how to control Backlight, Venus using PWM to control BKL
}

/******************************************************************************/
///This function will set PLL for different pixel clock
///@param u8PixelClk \b IN: pixel clock
/******************************************************************************/
void MDrv_ADC_SetADCPLL ( U8 u8PixelClk )
{
    U8 u8AdcBW;

    if (u8PixelClk >= ADC_BANDWIDTH_CLK_THRSHLD15)
        u8AdcBW = 0x00;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD15 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD14)
        u8AdcBW = 0x10;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD14 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD13)
        u8AdcBW = 0x20;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD13 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD12)
        u8AdcBW = 0x30;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD12 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD11)
        u8AdcBW = 0x40;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD11 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD10)
        u8AdcBW = 0x50;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD10 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD9)
        u8AdcBW = 0x60;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD9 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD8)
        u8AdcBW = 0x70;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD8 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD7)
        u8AdcBW = 0x80;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD7 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD6)
        u8AdcBW = 0x90;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD6 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD5)
        u8AdcBW = 0xA0;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD5 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD4)
        u8AdcBW = 0xB0;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD4 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD3)
        u8AdcBW = 0xC0;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD3 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD2)
        u8AdcBW = 0xD0;
    else if (u8PixelClk<ADC_BANDWIDTH_CLK_THRSHLD2 && u8PixelClk>=ADC_BANDWIDTH_CLK_THRSHLD1)
        u8AdcBW = 0xE0;
    else
        u8AdcBW = 0xF0;

    MDrv_WriteByteMask(BK_ADC_ATOP_1C_H, u8AdcBW, 0xf0);
}

/******************************************************************************/
///This function will set PLL clock divider ratio
///@param u16Value \b IN: PLL clock divider ratio
/******************************************************************************/
void MDrv_ADC_SetADCClk ( U16 u16Value )
{
    u16Value -= 3; // actual - 3
//    MDrv_WriteByte(BK_ADC_DTOP_00_H,(u16Value >> 8));  //ADC PLL divider ratio (htotal-3), (write sequence MSB -> LSB)

    // Don't know why, if write low byte only, the low byte can't be written, so write 16 bit directly
    //MDrv_WriteByte(BK_ADC_DTOP_00_L, (u16Value & 0xFF));
   ADCMSG( printf("\r\nSet ADC"));

    switch(stSystemInfo.enInputPortType)
    {
    	case INPUT_PORT_ADC_A_RGB:
    	case INPUT_PORT_ADC_A_YPBPR:
            ADCMSG(printf("--> RGB-A Htotal=%x", u16Value));
            MDrv_Write2Byte(BK_ADC_DTOP_00_L, u16Value);
    	break;

    	case INPUT_PORT_ADC_B_RGB:
    	case INPUT_PORT_ADC_B_YPBPR:
            ADCMSG(printf("--> RGB-B Htotal=%x", u16Value));
            MDrv_Write2Byte(BK_ADC_DTOP_20_L, u16Value);
    	break;
    }
}

/******************************************************************************/
///This function will set PLL phase
///@param u8Value \b IN: PLL phase divider ratio
/******************************************************************************/
void MDrv_ADC_SetADCPhase ( U8 u8Value )
{
    MDrv_WriteByte(BK_ADC_DTOP_03_L, u8Value);
}

/******************************************************************************/
///This function will set ADC offset
///@param *pstADCSetting \b IN: pointer to ADC settings
/******************************************************************************/
void MDrv_ADC_SetOffset ( MS_ADC_SETTING *pstADCSetting  )
{
    MDrv_WriteByte(BK_ADC_DTOP_08_H, ~(pstADCSetting->u8RedOffset));
    MDrv_WriteByte(BK_ADC_DTOP_09_H, ~(pstADCSetting->u8GreenOffset));
    MDrv_WriteByte(BK_ADC_DTOP_0A_H, ~(pstADCSetting->u8BlueOffset));
}

/******************************************************************************/
///This function will set ADC gain
///@param *pstADCSetting \b IN: pointer to ADC settings
/******************************************************************************/
void MDrv_ADC_SetGain ( MS_ADC_SETTING *pstADCSetting  )
{
    MDrv_WriteByte(BK_ADC_DTOP_08_L, ~(pstADCSetting->u8RedGain));
    MDrv_WriteByte(BK_ADC_DTOP_09_L, ~(pstADCSetting->u8GreenGain));
    MDrv_WriteByte(BK_ADC_DTOP_0A_L, ~(pstADCSetting->u8BlueGain));
}

/******************************************************************************/
///This function will turn on/off output DoubleBuffer
///@param bEnable \b IN:
///- Enable: Turn on ADC DoubleBuffer
///- Disable: Turn off ADC DoubleBuffer
/******************************************************************************/
void MDrv_ADC_SetDoubleBuffer(BOOLEAN bEnable)
{
    if ( bEnable )
    {
        MDrv_WriteByteMask(BK_ADC_DTOP_07_L, 0x01, 0x01);    //Set ADC_DTOP_7L[0] to enable DoubleBuffer
    }
    else
    {
        MDrv_WriteByteMask(BK_ADC_DTOP_07_L, 0x01, 0x01);    //Clear ADC_DTOP_7L[0] to disable DoubleBuffer
    }
}

/******************************************************************************/
///This function will recalibration ADC offset, must be called when mode change.
///@param bFlag \b IN:
///- 0: Turn on
///- 1: Turn off
/******************************************************************************/
void MDrv_ADC_SetAutoADC(BIT bEnable, BIT bIsYPbPrFlag)
{
    if(bIsYPbPrFlag)
    {
        MDrv_WriteRegBit(BK_ADC_DTOP_10_H, ENABLE, _BIT7); // Use code 16 as offset CAL target
    }
    else
    {
        MDrv_WriteRegBit(BK_ADC_DTOP_10_H, DISABLE, _BIT7); // Use code 0 as offset CAL target
    }

    if(bEnable)
    {
#if (COMPONENT_AUTO_SW_MODE)
        MDrv_WriteByte(BK_ADC_DTOP_10_L, 0x00); //normal procedure
#else
        MDrv_WriteByte(BK_ADC_DTOP_10_L, 0x50); //normal procedure
#endif
    }
    else
    {
        MDrv_WriteByte(BK_ADC_DTOP_10_L, 0x00); //used when doing YPbPr calibration with software mode