adv7123.c

dm642下的adv7123芯片的驱动程序

/*
 *  Copyright 2003 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 *  
 */
/* "@(#) DDK 1.10.00.23 07-02-03 (ddk-b12)" */
/********************************************************************************/
/* ADV7123edc.c file */
/********************************************************************************/
#include <std.h>        
#include <csl_stdinc.h>
#include <csl_i2c.h>
#include <edc.h>
#include "../../ADV7123.h"

#include "_iic.h"
#include "_ADV7123.h"   
                                                
/* local functions declaration */
static void clearHDSyncEngine(void);
static void configADV7123(ADV7123_Mode videoMode, Bool slaveModeEnable, 
    ADV7123_AnalogFormat outMode, ADV7123_InputFormat inFormat, Bool enableBT656Sync);
static void enableColorBars(Bool enable);
static void enableSlaveMode(Bool enable);
static void initADV7123Def(void);
static void loadCursor(ADV7123_Cursor* cursorTable);
static void loadHDSyncEngine(Uns mode);
static void powerdownADV7123(Bool powerDownEnable);
static void resetADV7123(void);
static void setOutputMode(ADV7123_AnalogFormat outMode);
static void setADV7123SyncMode(ADV7123_Mode displayType,Bool enableBT656Sync); 
static void setVideoDisplay(ADV7123_Mode displayType, 
    ADV7123_AnalogFormat outMode, ADV7123_InputFormat inFormat, Bool enableBT656Sync);
static void startHDSyncEngine(ADV7123_Mode displayType);

static Int ADV7123_close(EDC_Handle handle);
static Int ADV7123_ctrl(EDC_Handle handle, ADV7123_Cmd cmd, Arg param);
static EDC_Handle ADV7123_open(String devName, Arg optArg);


EDC_Fxns ADV7123_Fxns = {
    ADV7123_open,
    ADV7123_close,
    ADV7123_ctrl
};

/* local variables and arrays */
static I2C_Handle hI2C = INV;
static const Int outputModeTbl[3][5] = {
    {1, 1, 0, 0, 1},
    {0, 0, 0, 0, 0},
    {0, 1, 1, 1, 0}
};

static const Int modeTbl[8][9] = {
 /* NTSC */{248, 14, 1715, 720, 242, ADV7123_IFMT_YCBCR422_INTERLACED,
 0, 0, 0x20},
 /* PAL */{232, 19, 1727, 720, 290, ADV7123_IFMT_YCBCR422_INTERLACED,
 0, 0, 0x20},
 /*VGA */{64, 33, 799, 640, 480, ADV7123_IFMT_RGB565,
 0xc3, 0xd4, 0x1d},
 /*SVGA */{64, 23, 1055, 800, 600, ADV7123_IFMT_RGB565,
 0x4b, 0x68, 0x2f},
 /* XGA */{64, 29, 1343, 1024, 768, ADV7123_IFMT_RGB565,
 0x7b, 0x09, 0x4d},  
 /*HD480P */{64, 30, 857, 720, 480, ADV7123_IFMT_YCBCR422_NONEINTERLACED,
 0, 0, 0x20},
 /*HD720P */{64, 20, 1643, 1280, 720, ADV7123_IFMT_YCBCR422_NONEINTERLACED, 
 0, 0, 0x58},
 /*HD1080I*/{64, 10, 2193, 1920, 540, ADV7123_IFMT_YCBCR422_NONEINTERLACED, 
 0, 0, 0x58}
};                                              



/*
 * ======== clearHDSyncEngine ========
 */
static void clearHDSyncEngine(void)
{
    Uint8 *charPtr;


    _ADV7123_hdSyncGen0.lcAddress = 0;
    charPtr = (Uint8 *)&_ADV7123_hdSyncGen0.lcAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD0,charPtr,31);
    _ADV7123_hdSyncGen0.ltAddress = 0;
    charPtr = (Uint8 *)&_ADV7123_hdSyncGen0.ltAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD1,charPtr,61);
    _ADV7123_hdSyncGen0.lpAddress = 0;
    charPtr = (Uint8 *)&_ADV7123_hdSyncGen0.lpAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD2,charPtr,57);
    _ADV7123_hdSyncGen0.svAddress = 0;
    charPtr = (Uint8 *)&_ADV7123_hdSyncGen0.svAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD3,charPtr,17);
    return;
}

/*
 * ======== configADV7123 ========
 */
static void configADV7123(ADV7123_Mode videoMode, Bool slaveModeEnable, 
               ADV7123_AnalogFormat outMode, ADV7123_InputFormat inFormat, Bool enableBT656Sync)
{


/***************************************************************/
/* Enable master/slave mode                                    */
/***************************************************************/    
    enableSlaveMode(slaveModeEnable);
    initADV7123Def();
    loadCursor(NULL);
    enableColorBars(FALSE);
    setVideoDisplay(videoMode, outMode, inFormat, enableBT656Sync);

}



/*
 * ======== enableColorBars ========
 */
static void enableColorBars(Bool enable)
{
    _ADV7123_Regs *regPtr;
    Uint8 *charPtr;

    
    regPtr = &_ADV7123_settingsDef;
    regPtr->colorBarsEnable = enable;
    charPtr = (Uint8 *)&_ADV7123_settingsDef;
    _IIC_write(hI2C, _ADV7123_IICADDR,0x3A,&charPtr[0x3A],1);
    return;
}

/*
 * ======== enableSlaveMode ========
 */
static void enableSlaveMode(Bool enable)
{
    _ADV7123_Regs *regPtr;
    Uint8 *charPtr;

    
    regPtr = &_ADV7123_settingsDef;
    if(!enable){
        regPtr->masterSlaveMode = FALSE;
        regPtr->vSyncOutput = TRUE;
        regPtr->hSyncOutput = TRUE;     
        regPtr->fieldOutput = TRUE;     
        regPtr->bypassInputFIFO = FALSE;        
    }else{
        regPtr->masterSlaveMode = TRUE;
        regPtr->vSyncOutput = FALSE;
        regPtr->hSyncOutput = FALSE;        
        regPtr->fieldOutput = FALSE;        
        regPtr->bypassInputFIFO = TRUE;
    }
    charPtr = (Uint8 *)&_ADV7123_settingsDef;
    _IIC_write(hI2C, _ADV7123_IICADDR,0x96,&charPtr[0x96],2);
    _IIC_write(hI2C, _ADV7123_IICADDR,0x84,&charPtr[0x84],1);
    return;
}

/*
 * ======== initADV7123Def ========
 * initialize the ADV7123 in default setup 
 */
static void initADV7123Def(void)
{
    Uint8 *charPtr,subAddress;

    
/***************************************************************/
/* Load registers from ROM to RAM */
/***************************************************************/
    charPtr = (Uint8 *)&_ADV7123_settingsDef;
    subAddress = 0xD0;
    _IIC_write(hI2C, _ADV7123_IICADDR,subAddress,&charPtr[subAddress],13);
    subAddress = 0xF0;
    _IIC_write(hI2C, _ADV7123_IICADDR,subAddress,&charPtr[subAddress],14);
    return;
}

/*
 * ======== loadCursor ========
 * load Hardware cursor
 */
static void loadCursor(ADV7123_Cursor* cursorTable)
{
    Uns i;


/***************************************************************/
/* Load Hardware Cursor Bit Map with transparency */
/***************************************************************/
    if(cursorTable == NULL){
        cursorTable = &_ADV7123_cursorData;
        cursorTable->address = 0;
        for(i = 0; i < 256; i ++){
            cursorTable->cursorBlock[i] = 0xAA;
        }
    }
    _IIC_write(hI2C, _ADV7123_IICADDR,0xFE, (void *)cursorTable,256+1);
    return;
}
/*
 * ======== loadHDSyncEngine ========
 */
static void loadHDSyncEngine(Uns mode)
{
    _ADV7123_HDSyncGen *ptrHDSyncGen;
    Uint8 *charPtr;

    
    switch(mode)
    {
        case ADV7123_MODE_HD480P60F:
            ptrHDSyncGen = &_ADV7123_hdSyncGen480P;
            break;
        case ADV7123_MODE_HD720P60F:
            ptrHDSyncGen = &_ADV7123_hdSyncGen720P;
            break;
        case ADV7123_MODE_HD1080I30F:
            ptrHDSyncGen = &_ADV7123_hdSyncGen1080I;
            break;
        case ADV7123_MODE_VGA:
            ptrHDSyncGen = &_ADV7123_hdSyncGenVGA;
            break;
        case ADV7123_MODE_SVGA:
            ptrHDSyncGen = &_ADV7123_hdSyncGenSVGA;
            break;
        case ADV7123_MODE_XGA:
            ptrHDSyncGen = &_ADV7123_hdSyncGenXGA;
            break;
            
        default:
            break;
    }
    ptrHDSyncGen->lcAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->lcAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD0,charPtr,31);
    ptrHDSyncGen->lpAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->lpAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD2,charPtr,57);
    ptrHDSyncGen->ltAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->ltAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD1,charPtr,61);
    ptrHDSyncGen->svAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->svAddress + 3;
    _IIC_write(hI2C, _ADV7123_IICADDR,0xD3,charPtr,17);
}


/*
 * ======== powerdownADV7123 ========
 */

static void powerdownADV7123(Bool powerDownEnable)
{
    Uint8 *charPtr = (Uint8 *)&_ADV7123_settingsDef;


    /*Put _ADV7123 in power down mode */
    _ADV7123_settingsDef.downA = powerDownEnable;
    _ADV7123_settingsDef.downD = powerDownEnable;
    _IIC_write(hI2C, _ADV7123_IICADDR,0x61,&charPtr[0x61],1);
}


/*
 * ======== resetADV7123 ========
 */
static void resetADV7123(void)
{
/***************************************************************/
/* power-up ADV7123                                            */
/***************************************************************/
    powerdownADV7123(FALSE);
    return;
}

/*
 * ======== setOutputMode ========
 */
static void setOutputMode(ADV7123_AnalogFormat outMode)
{
    _ADV7123_Regs *regPtr;
    Uint8 *charPtr;

    
    regPtr = &_ADV7123_settingsDef;
    regPtr->vbsEn = outputModeTbl[outMode][0];
    regPtr->cvbsEn0 = outputModeTbl[outMode][1];
    regPtr->cvbsEn1 = outputModeTbl[outMode][2];
    regPtr->cvbsEn2 = outputModeTbl[outMode][3];
    regPtr->cEn = outputModeTbl[outMode][4];    
    charPtr = (Uint8 *)&_ADV7123_settingsDef;
    _IIC_write(hI2C, _ADV7123_IICADDR,0x2D,&charPtr[0x2D],1);
    return;
}


/*
 * ======== setADV7123SyncMode ========
 */
static void setADV7123SyncMode(ADV7123_Mode displayType,Bool enableBT656Sync)
{
    Uint8 *charPtr = (Uint8 *)&_ADV7123_settingsDef;


    if(enableBT656Sync) {
        _ADV7123_settingsDef.syncVia656 = 1;
        if(displayType == ADV7123_MODE_PAL720) {
            //_ADV7123_settingsDef.hTriggerMSBs = 0; 
            //_ADV7123_settingsDef.hTrigger = 235;        
        }   
        else {        
//            _ADV7123_settingsDef.hTriggerMSBs = 0; 
//            _ADV7123_settingsDef.hTrigger = 235;  
        }
        _ADV7123_settingsDef.xOfs = 0;
        _ADV7123_settingsDef.xOfsMsb = 0;
    }else {
        _ADV7123_settingsDef.syncVia656 = 0;
    }    
    _IIC_write(hI2C, _ADV7123_IICADDR,0x3A,&charPtr[0x3A],1);       
    _IIC_write(hI2C, _ADV7123_IICADDR,0x99,&charPtr[0x99],1);       
    _IIC_write(hI2C, _ADV7123_IICADDR,0x90,&charPtr[0x90],1);       
    _IIC_write(hI2C, _ADV7123_IICADDR,0x94,&charPtr[0x94],1);       
    _IIC_write(hI2C, _ADV7123_IICADDR,0x6C,&charPtr[0x6C],1);