/*
 *  Copyright 2004 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.
 *  
 */
/* August 2004 */
/********************************************************************************/
/* saa7105edc.c file */
/********************************************************************************/
#include <std.h>        
#include <csl_stdinc.h>
#include <csl_i2c.h>
#include "edc.h"
#include "saa7105.h"

#include "iic.h"
#include "_saa7105.h"   
                                                
/* local functions declaration */
static void clearHDSyncEngine(void);
void configSAA7105(SAA7105_Mode videoMode, Bool slaveModeEnable, 
    SAA7105_AnalogFormat outMode, SAA7105_InputFormat inFormat, Bool enableBT656Sync);
static void enableColorBars(Bool enable);
static void enableSlaveMode(Bool enable);
static void initSAA7105Def(void);
static void loadCursor(SAA7105_Cursor* cursorTable);
static void loadHDSyncEngine(Uns mode);
static void loadLUT(SAA7105_LookUpTable* lutTable);
static void powerdownSAA7105(Bool powerDownEnable);
void resetSAA7105(void);
static void setOutputMode(SAA7105_AnalogFormat outMode);
void setSAA7105SyncMode(SAA7105_Mode displayType,Bool enableBT656Sync); 
static void setVideoDisplay(SAA7105_Mode displayType, 
    SAA7105_AnalogFormat outMode, SAA7105_InputFormat inFormat, Bool enableBT656Sync);
static void startHDSyncEngine(SAA7105_Mode displayType);

static Int SAA7105_close(EDC_Handle handle);
static Int SAA7105_ctrl(EDC_Handle handle, SAA7105_Cmd cmd, Arg param);
static EDC_Handle SAA7105_open(String devName, Arg optArg);


EDC_Fxns SAA7105_Fxns = {
    SAA7105_open,
    SAA7105_close,
    SAA7105_ctrl
};

/* local variables and arrays */
//static I2C_Handle hI2C = INV;
extern  I2C_Handle hI2C;
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][8] = {
 /* NTSC */{248, 14, 1715, 720, 242, 0, 0, 0x20},
 /* PAL */{232, 19, 1727, 720, 290, 0, 0, 0x20},
 /*VGA */{64, 33, 799, 640, 480, 0xc3, 0xd4, 0x1d},
 /*SVGA */{64, 23, 1055, 800, 600, 0x4b, 0x68, 0x2f},
 /* XGA */{64, 29, 1343, 1024, 768, 0x7b, 0x09, 0x4d},  
 /*HD480P */{64, 30, 857, 720, 480, 0, 0, 0x20},
 /*HD720P */{64, 20, 1643, 1280, 720, 0, 0, 0x58},
 /*HD1080I*/{64, 10, 2193, 1920, 540, 0, 0, 0x58}
};                                              



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


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

/*
 * ======== configSAA7105 ========
 */
void configSAA7105(SAA7105_Mode videoMode, Bool slaveModeEnable, 
               SAA7105_AnalogFormat outMode, SAA7105_InputFormat inFormat, Bool enableBT656Sync)
{


/***************************************************************/
/* Enable master/slave mode                                    */
/***************************************************************/
    *(volatile Uint8 *)(0x90080010) = 0x1; //reset OSD     
    initSAA7105Def();
    setVideoDisplay(videoMode, outMode, inFormat, enableBT656Sync);
    enableSlaveMode(slaveModeEnable);
    loadCursor(NULL);
    enableColorBars(FALSE);

}



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

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

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

    
    regPtr = &_SAA7105_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 *)&_SAA7105_settingsDef;
    _IIC_write(hI2C, _SAA7105_IICADDR,0x96,&charPtr[0x96],2);
    _IIC_write(hI2C, _SAA7105_IICADDR,0x84,&charPtr[0x84],1);
    return;
}

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

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

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


/***************************************************************/
/* Load Hardware Cursor Bit Map with transparency */
/***************************************************************/
    if(cursorTable == NULL){
        cursorTable = &_SAA7105_cursorData;
        cursorTable->address = 0;
        for(i = 0; i < 256; i ++){
            cursorTable->cursorBlock[i] = 0xAA;
        }
    }
    _IIC_write(hI2C, _SAA7105_IICADDR,0xFE, (void *)cursorTable,256+1);
    return;
}

static void loadLUT(SAA7105_LookUpTable* lutTable)
{
    Uns i;


/***************************************************************/
/* Load Hardware Cursor Bit Map with transparency */
/***************************************************************/
    if(lutTable == NULL){
        lutTable = &_SAA7105_lookUpTable;
        lutTable->address = 0;
        for(i = 0; i < 256; i ++){
            lutTable->tables[i][0] = i;
            lutTable->tables[i][1] = i;
            lutTable->tables[i][2] = i;
        }
    }
    _IIC_write(hI2C, _SAA7105_IICADDR,0xFF, (void *)lutTable,256 * 3 + 1);
    return;
}


/*
 * ======== loadHDSyncEngine ========
 */
static void loadHDSyncEngine(Uns mode)
{
    _SAA7105_HDSyncGen *ptrHDSyncGen;
    Uint8 *charPtr;

    
    switch(mode)
    {
        case SAA7105_MODE_HD480P60F:
            ptrHDSyncGen = &_SAA7105_hdSyncGen480P;
            break;
        case SAA7105_MODE_HD720P60F:
            ptrHDSyncGen = &_SAA7105_hdSyncGen720P;
            break;
        case SAA7105_MODE_HD1080I30F:
            ptrHDSyncGen = &_SAA7105_hdSyncGen1080I;
            break;
        case SAA7105_MODE_VGA:
            ptrHDSyncGen = &_SAA7105_hdSyncGenVGA;
            break;
        case SAA7105_MODE_SVGA:
            ptrHDSyncGen = &_SAA7105_hdSyncGenSVGA;
            break;
        case SAA7105_MODE_XGA:
            ptrHDSyncGen = &_SAA7105_hdSyncGenXGA;
            break;
            
        default:
            break;
    }
    ptrHDSyncGen->lcAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->lcAddress + 3;
    _IIC_write(hI2C, _SAA7105_IICADDR,0xD0,charPtr,31);
    ptrHDSyncGen->lpAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->lpAddress + 3;
    _IIC_write(hI2C, _SAA7105_IICADDR,0xD2,charPtr,57);
    ptrHDSyncGen->ltAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->ltAddress + 3;
    _IIC_write(hI2C, _SAA7105_IICADDR,0xD1,charPtr,61);
    ptrHDSyncGen->svAddress = 0;
    charPtr = (Uint8 *)&ptrHDSyncGen->svAddress + 3;
    _IIC_write(hI2C, _SAA7105_IICADDR,0xD3,charPtr,17);
}


/*
 * ======== powerdownSAA7105 ========
 */

static void powerdownSAA7105(Bool powerDownEnable)
{
    Uint8 *charPtr = (Uint8 *)&_SAA7105_settingsDef;


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


/*
 * ======== resetSAA7105 ========
 */
void resetSAA7105(void)
{
/***************************************************************/
/* power-up SAA7105                                            */
/***************************************************************/
    powerdownSAA7105(FALSE);
    return;
}

/*
 * ======== setOutputMode ========
 */
static void setOutputMode(SAA7105_AnalogFormat outMode)
{
    _SAA7105_Regs *regPtr;
    Uint8 *charPtr;

    
    regPtr = &_SAA7105_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 *)&_SAA7105_settingsDef;
    _IIC_write(hI2C, _SAA7105_IICADDR,0x2D,&charPtr[0x2D],1);
    return;
}


/*
 * ======== setSAA7105SyncMode ========
 */
void setSAA7105SyncMode(SAA7105_Mode displayType,Bool enableBT656Sync)
{
    Uint8 *charPtr = (Uint8 *)&_SAA7105_settingsDef;


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

}