download.cpp

AliEditor_Source code

// DownLoad.cpp : implementation file
//

#include "stdafx.h"
#include "AliEditor.h"
#include "DownLoad.h"

#include "fastCRC.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define PACKAGESIZE 1024
#define PACKAGEBIT 10

/*message*/
#define WM_PAGE2_ACTIVE  WM_USER+0x30
#define WM_PAGE3_ACTIVE  WM_USER+0x31
#define WM_DL_CANCEL	 WM_USER+0x32

/*m_STB*/
#define STB_MTW3327 0
#define STB_MTW3326 1

#define FLASH_SIZE    0x100000
#define BLOCK_HEADER_SIZE 128
#define BLOCK_BASIC_HEADER_SIZE 16

#define BLOCK_ID_OFFSET		0
#define BLOCK_LEN_OFFSET	4
#define BLOCK_OFFSET_OFFSET	8
#define BLOCK_CRC_OFFSET	12
#define BLOCK_NAME_OFFSET	16
#define BLOCK_VER_OFFSET	32
#define BLOCK_TIME_OFFSET	48
#define BLOCK_RES_OFFSET	64

#define ID_TYPE(x) (x>>16)
#define BOOTLOADER_ID 0
#define USERDB_ID 0x04FB
#define TEMPDB_ID 0x05FA

#define MAINCODE_ID 0x01FE0100
#define DEFAULT_DATABASE_ID 0x03FC0100
#define USER_DATABASE_ID 0x04FB0100
/////////////////////////////////////////////////////////////////////////////
// CDownLoad dialog

//#define TRANSFER_FORMAT2_SUPPORT

#define PACKAGESIZE 1024
#define PACKAGEBIT 10

#define TRANSFER_RETRY_TIMES 2

CDownLoad::CDownLoad(CWnd* pParent /*=NULL*/)
	: CDialog(CDownLoad::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDownLoad)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

	pThread = NULL;
	m_bootloader = 0;

	m_bDownLoadDdb = TRUE;
	m_bDownLoadUdb = FALSE;
}


void CDownLoad::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDownLoad)
	DDX_Control(pDX, IDC_STATIC_OK4, m_burn_ok);
	DDX_Control(pDX, IDC_STATIC_BURN_FLASH, m_start_burn);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDownLoad, CDialog)
	//{{AFX_MSG_MAP(CDownLoad)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDownLoad message handlers

LRESULT CDownLoad::OnCancelDownload(WPARAM wParam, LPARAM lParam)
{
	if(pThread!=NULL)
		pThread->SuspendThread();
	/* make read buffer empty */
	char VerBuff[50];
	while(m_SerPort.ReadData(VerBuff,50) != 0);

	char Cmd[9] = "TIXE_DMC";//CMD_EXIT
	m_SerPort.SendData(Cmd,8);
	return 1;
}

BOOL CDownLoad::SlaveReorg()
{
	//unsigned int addr;
	int i,j,k;

	slave_reorg_size = 0;
	slave_burn_size = 0;

	slave_reorg_number = slave_blocks_number;
	
	for(i=1;i<block_number;i++)
	{
		if(blocks[i].upg_flag == 1)
		{
			if(!IsInSlave(blocks[i].id))   // add chunk
				slave_reorg_number++;
		}
	}

	slave_reorg_blocks = (BLOCK_LIST2 *)malloc(sizeof(BLOCK_LIST2)*slave_reorg_number);
	memset((void *)slave_reorg_blocks,0,sizeof(BLOCK_LIST2)*slave_reorg_number);

	/*init slave_reorg_blocks*/
	for(i=0; i<slave_blocks_number; i++)
	{
		slave_reorg_blocks[i].type = 1;  //move
		slave_reorg_blocks[i].index= i;
		slave_reorg_blocks[i].offset = slave_blocks[i].offset;
	}
	for(i=slave_blocks_number; i<slave_reorg_number; i++)
	{
		slave_reorg_blocks[i].type = 0;
		slave_reorg_blocks[i].index= 0;
		slave_reorg_blocks[i].offset = 0;
	}

	k = slave_blocks_number;
	for(i=1; i<block_number; i++)
	{
		if(blocks[i].upg_flag == 1)
		{
			for(j=0; j<slave_blocks_number; j++)
			{
				if(slave_reorg_blocks[j].type == 1 && slave_blocks[slave_reorg_blocks[j].index].id == blocks[i].id)
				{	
					if(ID_TYPE(blocks[i].id)!=TEMPDB_ID || slave_status!=0)
					{
						slave_reorg_blocks[j].type = 2;  //transfer
						slave_reorg_blocks[j].index= i;
						slave_reorg_blocks[j].offset = blocks[i].offset;	
					}
					break;
				}
			}

			/*add chunk*/
			if(j>=slave_blocks_number)
			{
				slave_reorg_blocks[k].type = 2;  //transfer
				slave_reorg_blocks[k].index= i;
				slave_reorg_blocks[k].offset = blocks[i].offset;
				k++;
			}
		}
	}

	if(m_bootloader)
	{
		slave_reorg_blocks[0].type = 2;  //transfer
		slave_reorg_blocks[0].index= 0;
		slave_reorg_blocks[0].offset = blocks[0].offset;
	}

	if(m_bootloader) i = 0;
	else i = 1;

	for(; i<slave_reorg_number; i++)
	{
		if(slave_reorg_blocks[i].type  == 1) //move
		{
			if(slave_reorg_blocks[i].offset == 0)
				slave_burn_size += slave_blocks[slave_reorg_blocks[i].index].len+BLOCK_BASIC_HEADER_SIZE;
			else
				slave_burn_size += slave_reorg_blocks[i].offset;

			slave_reorg_size += slave_blocks[slave_reorg_blocks[i].index].len+BLOCK_BASIC_HEADER_SIZE;
		}
		else //transfer
		{		
			if(slave_reorg_blocks[i].offset == 0)
				slave_burn_size += blocks[slave_reorg_blocks[i].index].len+BLOCK_BASIC_HEADER_SIZE;
			else
				slave_burn_size += slave_reorg_blocks[i].offset;

//			if(i == slave_reorg_number-1)
//				blocks[slave_reorg_blocks[i].index].len = BLOCK_HEADER_SIZE-BLOCK_BASIC_HEADER_SIZE;
			slave_reorg_size += blocks[slave_reorg_blocks[i].index].len+BLOCK_BASIC_HEADER_SIZE;
		}
	}

	if(m_bootloader)
	{
		if(slave_burn_size > slave_Flash_type)
		return FALSE;
	}
	else
	{
		if(slave_burn_size+slave_reorg_blocks[0].offset > slave_Flash_type)
		return FALSE;
	}

	return TRUE;
}

BOOL CDownLoad::IsInSlave(unsigned int id)
{
	int i;

	for(i=0; i<slave_blocks_number; i++)
	{
		if(slave_blocks[i].id == id)
			return TRUE;
	}

	return FALSE;
}

BOOL CDownLoad::CheckVersion(char* sVer, char* hVer)
{
	char sVersion[16], hVersion[16];

	strcpy(sVersion, sVer);
	strcpy(hVersion, hVer);
	sVersion[8] = '\0';
	hVersion[8] = '\0';
	
	if(strcmp(sVersion, hVersion) != 0)
		return FALSE;

	return TRUE;
}

BOOL CDownLoad::Command_comtest()
{
	char *TestCommd = "comtest 10\r";
	int TestLen  = 10;
	char *TestStr = "ali  DVB-S";

	if(m_SerPort.IsOpened == FALSE)
		return FALSE;

	char TmpBuff[50];
	/* make read buffer empty */
	while(m_SerPort.ReadData(TmpBuff,50) != 0);

	/* send test info*/
	EnterCriticalSection(&m_cs);
	int len = strlen(TestCommd);
	if(!m_SerPort.Send2Back_tm(TestCommd,len,1000*100))
	//if(!m_SerPort.Send2Back(TestCommd,len))
	{
		LeaveCriticalSection(&m_cs);
		return FALSE;
	}
	m_bNodifyReset = true;
	len = strlen(TestStr);
	if(!m_SerPort.Send2Back_tm(TestStr,len,1000*50))
	{
		LeaveCriticalSection(&m_cs);
		return FALSE;
	}
	LeaveCriticalSection(&m_cs);

	return TRUE;
}

BOOL CDownLoad::Command_version()
{
	unsigned char VerBuff[BLOCK_HEADER_SIZE*50],crc_txt[4];
	char * VerCmmd = "version\r";
	int len = strlen(VerCmmd);
	int i;
	unsigned int crc,verify_crc;
	unsigned int buffer_len;
	unsigned char *p, *pblock;
	char sVer[16], hVer[16];

	/* make read buffer empty */
	while(m_SerPort.ReadData(VerBuff,BLOCK_HEADER_SIZE) != 0);

	Sleep(100);

	/* send version command */
	if(!m_SerPort.Send2Back_tm(VerCmmd,len,1000*50))
	{
		AfxMessageBox("failed 1");
		
		return FALSE;
	}
	Sleep(1500);

	memset((void *)VerBuff,0,BLOCK_HEADER_SIZE*50);
	if(!m_SerPort.ReadData_tm(VerBuff,2,1000*500))
	{
		AfxMessageBox("failed 2");

		return FALSE;
	}
	buffer_len = 0;
	buffer_len = (VerBuff[0]<<8)+VerBuff[1];

	Sleep(1500);
	
	if(!m_SerPort.ReadData_tm(VerBuff,buffer_len,1000*500))
	{
		AfxMessageBox("failed 3");

		return FALSE;
	}

	Sleep(300);

	if(!m_SerPort.ReadData_tm(crc_txt,4,1000*500))
	{
		AfxMessageBox("failed 4");

		return FALSE;
	}

	crc = 0;
	crc = (crc_txt[0]<<24)+(crc_txt[1]<<16)+(crc_txt[2]<<8)+(crc_txt[3]<<0);

	verify_crc = MG_Table_Driven_CRC(0xFFFFFFFF,VerBuff,buffer_len);
	//verify_crc = gen_CRC32(0xFFFFFFFF,VerBuff,buffer_len);

	if(verify_crc != crc)
	{
		MessageBox("STB information transfer error","Error",MB_OK);
		return FALSE;
	}

	switch((unsigned int)VerBuff[0])
	{
		case 1:
		case 2:
		case 7:
		case 10:
			slave_Flash_type = 0x80000;
			break;
		case 3:
		case 4:
		case 8:
		case 9:
		case 11:
		case 13:
			slave_Flash_type = 0x100000;
			break;
		case 5:
		case 6:
		case 12:
		case 14:
		case 15:
		case 16:
			slave_Flash_type = 0x200000;
			break;
		case 17:
		case 18:
		case 19:
			slave_Flash_type = 0x400000;
			break;
		default:
		{
			MessageBox("STB flash type unknown","Error",MB_OK);
			return FALSE;
		}
	}

	slave_status = (unsigned int)VerBuff[1];

	slave_blocks_number = (buffer_len-2)/BLOCK_HEADER_SIZE;
	slave_blocks = (BLOCK_HEADER *)malloc(sizeof(BLOCK_HEADER)*slave_blocks_number);
	memset((void *)slave_blocks,0,sizeof(BLOCK_HEADER)*slave_blocks_number);

	pblock = &VerBuff[2];
	for(i=0; i<slave_blocks_number; i++)
	{
		p = pblock + BLOCK_ID_OFFSET;
		slave_blocks[i].id = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);

		if( slave_blocks[i].id == USER_DATABASE_ID )
		{
			memcpy(m_usr_block_header, pblock, BLOCK_HEADER_SIZE);
		}

		p = pblock + BLOCK_LEN_OFFSET;
		slave_blocks[i].len = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);

		p = pblock + BLOCK_OFFSET_OFFSET;
		slave_blocks[i].offset = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);

		p = pblock + BLOCK_CRC_OFFSET;
		slave_blocks[i].crc = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);

		p = pblock + BLOCK_NAME_OFFSET;
		strcpy((char *)slave_blocks[i].name, (char *)p);
		
		p = pblock + BLOCK_VER_OFFSET;
		strcpy((char *)slave_blocks[i].version, (char *)p);

		p = pblock + BLOCK_TIME_OFFSET;
		strcpy((char *)slave_blocks[i].time, (char *)p);

		pblock += BLOCK_HEADER_SIZE;
	}

	if(m_bootloader) return TRUE;

	/* open file */
	if(!m_File.Open(m_Path,CFile::shareDenyRead,NULL))
	{
		return FALSE;
	}
	m_File.Seek(BLOCK_VER_OFFSET, CFile::begin);
	if(16 != m_File.Read(hVer,16))
	{
		m_File.Close();
		return FALSE;
	}
	m_File.Close();

	strcpy(sVer, (char*)slave_blocks[0].version);

	if(CheckVersion(sVer, hVer) != TRUE)
	{
		MessageBox("STB version is not compatible","Error",MB_OK);
		return FALSE;
	}

	return TRUE;
}

BOOL CDownLoad::Command_address()
{
	char bufsz[128];
//	char *AddrCommd = "address";
//	char Address[10];
	char TmpBuff[50];
	unsigned int addr;
	unsigned char Answer;

	/*address 0x10000\r*/

	if(m_bootloader)
		addr = 0;
	else
		addr = 0x10000; //getAddress();

//	sprintf(Address, "%u",addr);

	addr = 0x10000; //getAddress();

	sprintf(bufsz, "address %u\r", addr);

	/* make read buffer empty */
	while(m_SerPort.ReadData(TmpBuff,50) != 0);

	if(m_SerPort.Send2Back_tm(bufsz, strlen(bufsz), 1000*50) != TRUE)
	{
		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}
/*

	if(m_SerPort.Send2Back_tm(AddrCommd, strlen(AddrCommd), 1000*50) != TRUE)
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(" ",1,1000*50)!=TRUE)
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(Address,strlen(Address),1000*50)!=TRUE)
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm("\r",1,1000*50)!=TRUE)
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}
*/
	Answer = 0;
	if(m_SerPort.ReadData_tm(&Answer,1,1000*500)!=TRUE)
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}	

	if(Answer != 'O')
	{
//		MessageBox("Send flash address failed","Error",MB_OK);
		return FALSE;
	}

	return TRUE;
}

BOOL CDownLoad::Command_move(int index,unsigned int offset)
{
	char *MoveCommd = "move";
	unsigned int id;
	char Id[10], Offset[10];
	char TmpBuff[50];
	unsigned char Answer;
	int progress;
	CString per;

	CProgressCtrl *pPrgrss = (CProgressCtrl *)GetDlgItem(IDC_PROGRESS_SDRAM);
	CWnd *pWnd = GetDlgItem(IDC_STATIC_SDRAM_PERCENT);

	id = slave_blocks[index].id;
	
	sprintf(Id, "%u", id);
	sprintf(Offset, "%u", offset);

	/* make read buffer empty */
	while(m_SerPort.ReadData(TmpBuff,50) != 0);

	if(m_SerPort.Send2Back_tm(MoveCommd,strlen(MoveCommd),1000*50)!=TRUE)
	{
//		MessageBox("Move block failed1","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(" ",1,1000*50)!=TRUE)
	{
//		MessageBox("Move block failed2","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(Id,strlen(Id),1000*50)!=TRUE)
	{
//		MessageBox("Move block failed3","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(" ",1,1000*50)!=TRUE)
	{
//		MessageBox("Move block failed4","Error",MB_OK);
		return FALSE;
	}
	if(m_SerPort.Send2Back_tm(Offset,strlen(Offset),1000*50)!=TRUE)
	{
//		MessageBox("Move block failed5","Error",MB_OK);
		return FALSE;