dvb_ssu.c

DVB软件,基于CT216软件的开发源程序.

/**************************************************************************

        (C)Copyright Cheertek Inc. 2002-2004,
           K000, all right reserved.

        Product : STB Firmware

****************************************************************************/
#include <string.h>
#include "dvb_type.h"
#include "dvb_flash.h" 
#include "dvb_av.h"
#include "dvb_sys.h"
#include "dvb_ssu.h"
#include "dvb_upd.h"
#include "mpegcrc32.h"
#include "ct_drammap.h"
#include "ct_sys.h"
#include "dvb_file.h"

#ifdef DBTOOL_ENABLE //Modified by WangTao 03/04/2008
	#include "DBTL_SSU_def.h"
#endif

#define Header_Offset						60 //crd_struct_info size 
#define CRD_Length_Offset					4
#define CARDUPDATE_BUFFER_DRAM_START_ADDR   (FRASHSRV_DRAM_BUFFER_START_ADDR) //Abuffer address
static u32  u32CRDDramBufferStartAddr = CARDUPDATE_BUFFER_DRAM_START_ADDR;
#ifdef CARDREADER_ENABLE
EN_DEVICE_TYPE _enSSUDeviceType = EN_CARDREADER_DEVICE;
#else
EN_DEVICE_TYPE _enSSUDeviceType = EN_USB_DEVICE;
#endif


#if 1
#define SSU_MSG(p) 		
#else
#define SSU_MSG(p) 		printf p
#endif


#if 1
#define SSU_DEBUG(p) 		
#else
#define SSU_DEBUG(p) 		printf p
#endif

#ifdef DBTOOL_ENABLE //Modified by WangTao 02/29/2008
	u8	au8VenderByCus[16] = {"Cheertek"};
	u8  au8ChipByCus[8] = {"ct216s"};
	u8	au8ProductModelByCus[16] = {"DR216S_Z_V30"};
	u8	au8VersionByCus[8] = {"01.00/08"};
#else
u8	au8VenderByCus[16] = {"cheertek"};
u8  au8ChipByCus[8] = {"216"};
u8	au8ProductModelByCus[16] = {"callisto"};
u8	au8VersionByCus[8] = {"0.01a"};
#endif

PF_DVB_SSU_CB _pfSSUCallback;

/**************************************************************************************/
void DVB_SSU_Set_DeviceType(EN_DEVICE_TYPE enDeviceType)
{
	_enSSUDeviceType = enDeviceType;
}
EN_DEVICE_TYPE DVB_SSU_Get_DeviceType(void)
{
	return _enSSUDeviceType;	
}

#ifdef DBTOOL_ENABLE //Modified by WangTao 02/29/2008
void DVB_SSU_Init(void )
{

	memset(au8VenderByCus, 0, 16);
	strcpy(au8VenderByCus, VENDER);

	memset(au8ChipByCus, 0, 8);
	strcpy(au8ChipByCus, CHIP);

	memset(au8ProductModelByCus, 0, 16);
	strcpy(au8ProductModelByCus, PRODUCTMODEL);	

	memset(au8VersionByCus, 0, 8);
	strcpy(au8VersionByCus, VERSION);	
	
	_pfSSUCallback = NULL;
}
#else
void DVB_SSU_Init(u8 *pu8VenderName, u8* pu8ChipName)
{
	if(pu8VenderName)
	{
		memset(au8VenderByCus, 0, 16);
		strcpy(au8VenderByCus, pu8VenderName);
	}

	if(pu8ChipName)
	{
		memset(au8ChipByCus, 0, 8);
		strcpy(au8ChipByCus, pu8ChipName);
	}

	_pfSSUCallback = NULL;
}
#endif

EN_CRD_UPDATE_ERROR_TYPE DVB_SSU_UpdateByFS(u8 *pu8filename)
{
	static u8	au8SSUFileName[13] = {0};
	static u32 u32SSUFileHandle = 0;

	u32 u32size = 0;

	//Disable AV Decoder

	DVB_AVDemuxDisable();
	DVB_VideoScreenEnable(FALSE);
	DVB_VideoScreenShow(FALSE);
	DVB_AudioVideoStop();
    
	memcpy(au8SSUFileName, pu8filename/*"wice.crd"*/, 12);
	SSU_DEBUG(("\n\r au8SSUFileName:%s",au8SSUFileName));
	//Get File Handle
	u32SSUFileHandle = DVB_FILECTRL_FileOpen(_enSSUDeviceType, au8SSUFileName, 'r');
	SSU_DEBUG(("\n\ru32SSUFileHandle"));
	if(u32SSUFileHandle == 0)
	{
		SSU_DEBUG(("\n\ru32SSUFileHandle == NULL"));
      	return EN_CRD_UPDATE_FILE_HANDLE_ERR;
    }
	//Calculate File Size
	u32size = DVB_FILECTRL_GetFileSize(_enSSUDeviceType, u32SSUFileHandle);

	SSU_DEBUG(("\nu32Filesize: %lu",u32size));
	//File Read Data to appointed memory address
	if( DVB_FILECTRL_FileRead(_enSSUDeviceType, u32SSUFileHandle, u32size , (u8*)u32CRDDramBufferStartAddr/*pu8FileBuffer*/) != u32size)
	{
		DVB_FILECTRL_FileClose(_enSSUDeviceType, u32SSUFileHandle);

		SSU_DEBUG(("\nFile Read Fail"));
		return EN_CRD_UPDATE_FILE_READ_ERR;
	}
	DVB_FILECTRL_FileClose(_enSSUDeviceType, u32SSUFileHandle);
	
	/*Verify and Burn*/
	u32 u32Status = DVB_SSU_VerifyAndBurn (u32size);
	switch(u32Status)
	{
		case EN_CRD_UPDATE_CRC_CHECK_ERR:
			SSU_DEBUG(("\n\r VerifyorBurn CRC check error\n"));
			break;
		case EN_CRD_UPDATE_HEADER_CHECK_ERR:
			SSU_DEBUG(("\n\r VerifyorBurn header check error\n"));
			break;
		default:
			SSU_DEBUG(("\n\r VerifyorBurn update error\n"));
			break;
	} 
	
	return (u32Status);
}

void DVB_SSU_SetProgressCallback(PF_DVB_SSU_CB pfSSUCallback)
{
	if(pfSSUCallback)
		_pfSSUCallback = pfSSUCallback;
}

u16* DVB_SSU_GetDirName(u32 u32FileIndex, u8 *pu8DirName)
{
	return DVB_FILECTRL_GetFilenameWithIndex(_enSSUDeviceType, EN_FILE_TYPE_DIR, u32FileIndex, pu8DirName);
}

u16* DVB_SSU_GetFileName(u32 u32FileIndex, u8 *pu8FileName)
{
	return DVB_FILECTRL_GetFilenameWithIndex(_enSSUDeviceType, EN_FILE_TYPE_SSU, u32FileIndex, pu8FileName);
}

u32 DVB_SSU_GetFileCount(void)
{
	return DVB_FILECTRL_GetFileCount(_enSSUDeviceType, EN_FILE_TYPE_SSU);
}

u32 DVB_SSU_GetDirCount(void)
{
	return DVB_FILECTRL_GetFileCount(_enSSUDeviceType, EN_FILE_TYPE_DIR);
}

EN_DVB_UPDATE_ERROR_TYPE DVB_SSU_UpdateByMem(u8 *pu8src,u32 u32size)
{
	//Disable AV Decoder

	DVB_AVDemuxDisable();
	DVB_VideoScreenEnable(FALSE);
	DVB_VideoScreenShow(FALSE);
	DVB_AudioVideoStop();

	memcpy((u8 *)u32CRDDramBufferStartAddr, pu8src, u32size);	
    /*Verify and Burn*/
	if(FALSE == DVB_SSU_VerifyAndBurn (u32size))
	{
		SSU_DEBUG(("\n\r VerifyorBurn Error"));
		return (EN_DVB_UPDATE_ERR);
	}
	return (EN_DVB_UPDATE_NO_ERROR);

}

EN_CRD_UPDATE_ERROR_TYPE DVB_SSU_VerifyAndBurn(u32 u32size)
{
	crd_struct_info *pHeaderInfo;
#ifdef DBTOOL_ENABLE	  //(GFG-002)
	u8 i = 0, u8Bank = 0;
	u32 u32tempbank = 0, u32DramAdr = 0;
#else       //(GFG-002)
	u32 u32tmpvalue = 0, u32tmpcrcvalue = 0, u32tempbank = 0, u32DramAdr = 0, u32crcvalue = 0;
	u8 *pu8tmp;
	u8 i = 0, u8Bank = 0;
      	bool8 b8check;
#endif	  //(GFG-002)
	 //Get Header Info
    {
		pHeaderInfo = (crd_struct_info *)u32CRDDramBufferStartAddr;
    }

#ifdef DBTOOL_ENABLE
	EN_SSU_ERR_TYPE enErrType;
    	u8* au8tempArray = DBTL_SSU_TempBufferPointer();
	enErrType = DBTL_SSU_Check_SSUFile((u8*)u32CRDDramBufferStartAddr);
	
	if( enErrType != EN_SSU_ERR_NO )
	{
		return (EN_CRD_UPDATE_HEADER_CHECK_ERR);
	}	
#else  
	//Calculate CRC Value of CRD file from buffer except latest four bytes.
	CRC_MPEG32_Start();
	CRC_MPEG32_AddData((u8 *)u32CRDDramBufferStartAddr, (u32size - 4));
	u32crcvalue = CRC_MPEG32_GetCRC();
	SSU_DEBUG(("\nu Source CRC value: 0x%lx\n",u32crcvalue));

	//Get CRC value from latest four bye of buffer
	pu8tmp = (u8 *)u32CRDDramBufferStartAddr;
	u32tmpvalue = pu8tmp[u32size - 4];
	u32tmpcrcvalue	= (u32tmpvalue<<24);
	u32tmpvalue = pu8tmp[u32size - 3];
	u32tmpcrcvalue	+= (u32tmpvalue<<16);
	u32tmpvalue = pu8tmp[u32size - 2];
	u32tmpcrcvalue	+= (u32tmpvalue<<8);
	u32tmpvalue = pu8tmp[u32size - 1];
	u32tmpcrcvalue += u32tmpvalue;

	SSU_DEBUG(("\nu32tmpcrcvalue: 0x%lx\n",u32tmpcrcvalue));

	if(u32crcvalue == u32tmpcrcvalue)
		SSU_DEBUG(("\nCrc Check Succeed\n"));
	else
	{
		SSU_DEBUG(("\nCrc Check Fail\n"));
		return (EN_CRD_UPDATE_CRC_CHECK_ERR);
	}

	//Verify Header Information
	//盢Dramい