hdevice.c

ct952 source code use for Digital Frame Photo

#include "winav.h"
#include "ctkav.h"
#include "ctkav_mcu.h"
#include "hio.h"
#include "hdevice.h"
#include "spflash.h"
#include "disp.h"    // because of DISP_TVMODE define
#include "romld.h"

typedef enum tagSET_REG_ID {
    SET_TVE_GAIN_YC,
    SET_TVE_GAIN_CAV,
} SET_REG_ID;

BOOL    _blDisableSVideo = FALSE;

// LLY2.77, porting Chuan's code to keep if force disable TV output off
BYTE    _bForce_TVOut_Off = FALSE;

DWORD   __dwREG_TVE_MV0 = 0x00000000; //kevin1.02, set MV0[4] within V-SYNC; otherwise, TVE output is abnormal (CT909S IC will fix it)
DWORD   __dwOffset ;
void    _ProgramACLK(BYTE bSampleFreq);
void    _ProgTVEGain(SET_REG_ID bSetID, DWORD dwRegValue, int nGainOffset);



// LLY2.55, declare the table for different solution's GAIN_YC & GAIN_CAV value.
// Notice: the layout must be same as following.
// Interlace mode
// { {NTSC-SVideo, NTSC-YUV, NTSC-RGB},
//   {PAL-SVideo,  PAL-YUV,  PAL-RGB },
//   {PALM-SVideo, PALM-YUV, PALM-RGB},
//   {PALN-SVideo, PALN-YUV, PALN-RGB} }
// P-Scan mode
// { {NTSC-SVideo, NTSC-YUV, NTSC-RGB, NTSC-VGA},
//   {PAL-SVideo,  PAL-YUV,  PAL-RGB , PAL-VGA },
//   {PALM-SVideo, PALM-YUV, PALM-RGB, PALM-VGA},
//   {PALN-SVideo, PALN-YUV, PALN-RGB, PALM-VGA} }


//  *******************************************************************************
//  Function    :   HAL_InitSerialFlash
//  Description :   Initialize serial flash to find the desired bank location.
//  Arguments   :   None
//  Return      :   None
//*********************************************************************************
void    HAL_InitSerialFlash(void)
{
    BYTE    *pbTmp;
    PSECTION_ENTRY ENTRY;

    // LLY2.17, remove it since it's only to slow speed for parallel flash
    //REG_PLAT_PROMCFG = 0x24D08;

//    SPF_ReadID(4);
    SPF_INFO *pSPF_INFO1;

    pSPF_INFO1 = (SPF_INFO*)(*((DWORD*)8)); //wingwu 7/28 for support no ID check
    SPF_INFO1 = *pSPF_INFO1;
    ENTRY= ROMLD_GetSectionByName (0,"SETD");
    dwROM_RANGE_START  =  ENTRY->dwRMA;
    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "SETD[%lx]",dwROM_RANGE_START);

    switch  (SPF_INFO1.bBoot)
    {
        case BOOT_ALL: //address is 4k *n
             if(dwROM_RANGE_START%0x1000)
             {
                 dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
             }
            break;

        case BOOT_NO: //not  support
            dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
            break;

        case BOOT_BOTTOM :
             if(dwROM_RANGE_START != 0x01000)
             {
                dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
             }
            break;

        case BOOT_TOP:
            switch  (SPF_INFO1.bSize)
            {
                case FLASH_SIZE_8M : //8M FLASH
                    if(dwROM_RANGE_START  != 0x0FF000 )
                    {
                       dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
                    }
                   break;

                case FLASH_SIZE_4M : // 4M FLASH
                    if( dwROM_RANGE_START != 0x07F000 )
                    {
                       dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
                    }
                   break;

                default :
                      dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
                    break;
            }
            break;

        default :
            dwROM_RANGE_START = NOT_SUPPORT_FLASH ;
            break;
    }
    if(ENTRY->dwLSize == 0x1000)
    {//do check    4K size
        __dwOffset = dwROM_RANGE_START;
        dwROM_RANGE_START = dwROM_RANGE_START;
        dwROM_RANGE_MID = dwROM_RANGE_START+0x1000;
        dwROM_RANGE_END =dwROM_RANGE_START+0x1000;
    }
    else if(ENTRY->dwLSize == 0x2000)
    {//do check    8K size
        __dwOffset = dwROM_RANGE_START;
        dwROM_RANGE_START = dwROM_RANGE_START;
        dwROM_RANGE_MID = dwROM_RANGE_START+0x1000;
        dwROM_RANGE_END =dwROM_RANGE_MID+0x1000;
    }
    else
    {
        dwROM_RANGE_START = NOT_SUPPORT_FLASH;
         __dwOffset = dwROM_RANGE_START;
        dwROM_RANGE_START = dwROM_RANGE_START;
        dwROM_RANGE_MID = dwROM_RANGE_START+0x1000;
        dwROM_RANGE_END =dwROM_RANGE_MID+0x1000;
    }
    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "Flash ad[%lx,%lx,%lx]",dwROM_RANGE_START,dwROM_RANGE_MID,dwROM_RANGE_END);

    pbTmp  =  (BYTE *)__dwOffset;

    for(;pbTmp<(BYTE *) dwROM_RANGE_END ;pbTmp+=ROM_BANK_SIZE)
    {
        if(pbTmp[0] != 0xff)
        {
            for(pbTmp += ROM_BANK_SIZE
            		;pbTmp< (BYTE *)dwROM_RANGE_END
            				;pbTmp += ROM_BANK_SIZE)
            {
                if(pbTmp[0] == 0xff)
                {
                    // LLY2.53, porting Wing's code to support > 256 bytes setup info.
                    //__dwOffset= pbTmp - (BYTE*)ROM_BANK_SIZE;
                    __dwOffset=(DWORD) pbTmp - (DWORD) ROM_BANK_SIZE;
                    //DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "last data<%lx> \n",__dwOffset);
                    // LLY2.35, porting Wing's code to fix data can't find in SPI sometime.
                    //pbTmp = (BYTE *) dwROM_RANGE_END ; //end find
                    //break;
                    return;
                }
            }
        }
    }

    // LLY2.35, porting Wing's code to fix data can't find in SPI sometime.
    __dwOffset= dwROM_RANGE_END - ROM_BANK_SIZE;
    //DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "last data<%lx> \n",__dwOffset);
    return;

}


// LLY2.51, porting Wing's code to add a API to write data to SPI Flash
//  *********************************************************************
//  Function    :   HAL_WriteSPF
//  Description :   Write data to serial flash
//  Arguments   :   dwAddr: desired serial flash adress
//                  pbValue: ptr to the to be written value
//                  dwCnt: # of bytes, can't exceed 64K bytes
//  Return      :   TRUE : write OK
//              :   FALSE : wrute faile
//  Notice      :   dwAddr must be 64K byte align.
//*********************************************************************
BYTE HAL_WriteSPF(DWORD dwAddr, BYTE* pbVal, DWORD dwCnt)
{
    BYTE bBuff;

//    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF,
//        "Addr: %lx, pbVal: %lx, dwCnt: %lx\n", dwAddr, pbVal, dwCnt);

    // check dwAddr if 64K bytes align
    if((dwAddr%0x10000) !=0)
    {
        DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "Err: WriteSPF fail since desired address not 64K align\n");
         return FALSE;
    }

    // check if desired count > 64K bytes
    if(dwCnt > 0x10000)
    {
        DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "Err: WriteSPF fail since desired size exceed 64K byte\n");
        return FALSE;
    }

    // Must turn on TFT mode and delay two vsync before SPI Flash action
    // Since, SPI Flash Erase/ Write action will disable all interrupt
    //DISP_DisplayCtrl(DISP_TFT_MODE, TRUE);
    //DISP_DelayVSYNC(2);

    if(SPF_INFO1.bBoot == BOOT_ALL)
    {
        for( bBuff =0 ;bBuff < 16 ;bBuff++)
        {
            SPF_EraseSector(dwAddr+0x1000*bBuff);
        }
    }
    else
    {
        SPF_EraseSector(dwAddr);
    }


//    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF,
//        "%lx, %lx, %lx, %lx\n", pbVal[0], pbVal[1], pbVal[2], pbVal[3]);

    //糶