downloadthread.cpp

free sources for gsm

// DownloadThread.cpp : implementation file
//

#include "stdafx.h"
#include "MdlSysol.h"
#include "DownloadThread.h"
#include "TFSDescritpion.h"
#include "FlashDescription.h"
#include "Flash.h"
#include "loader.h"
#include <direct.h>
#include "dwl87.h"
#include "dwl87_E330.h"
#include "dwl87_D488.h"

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

CTFSDescritpion			m_TFSDescritpion;
CFlashDescription		m_FlashDescription;
CFlashCharacteristic	*gp_FlashCharacteristic;

CString gl_strModel;
/////////////////////////////////////////////////////////////////////////////
// CDownloadThread

IMPLEMENT_DYNCREATE(CDownloadThread, CWinThread)

CDownloadThread::CDownloadThread()
{
}

CDownloadThread::~CDownloadThread()
{
}

BOOL CDownloadThread::InitInstance()
{
	// TODO:  perform and per-thread initialization here
	m_pWnd = NULL;
	m_bStop = FALSE;
	m_bPortInit = FALSE;
	m_pFileClaData = NULL;
	m_pFileTFSData = NULL;
	m_hEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
	
	SetRunFlag(TRUE);

	m_nThreadState = DL_THREAD_LOCKED;

	return TRUE;
}

int CDownloadThread::ExitInstance()
{
	// TODO:  perform any per-thread cleanup here
	SetRunFlag(FALSE);

	if(m_pFileClaData != NULL) delete m_pFileClaData;
	if(m_pFileTFSData != NULL) delete m_pFileTFSData;

	return CWinThread::ExitInstance();
}

BEGIN_MESSAGE_MAP(CDownloadThread, CWinThread)
	//{{AFX_MSG_MAP(CDownloadThread)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDownloadThread message handlers

BOOL CDownloadThread::SetOwner(CWnd *pView)
{
	m_pWnd = pView;
	return TRUE;
}

void CDownloadThread::ResetEvt()
{
	ResetEvent(m_hEvt);
}

void CDownloadThread::SetEvt()
{
	SetEvent(m_hEvt);
}

int CDownloadThread::GetThreadState()
{
	return m_nThreadState;
}

void CDownloadThread::CancelDload()
{
	m_bStop = TRUE;
}

HANDLE CDownloadThread::GetThreadHandle()
{
	return m_hThread;
}

void CDownloadThread::Destroy()
{
	delete this;
}

void CDownloadThread::SetRunFlag(BOOL bRun)
{
	m_bRun = bRun;
}

BOOL CDownloadThread::SetPort(int nPort)
{
	m_nPort = nPort;

	return TRUE;
}

BOOL CDownloadThread::SetBaud(int nBaud)
{
	m_nBaudRate = nBaud;

	switch(m_nBaudRate)
	{
	case 115200:
		m_nBaudRatePos = 0;
		break;
	case 230400:
		m_nBaudRatePos = 1;
		break;
	case 460800:
		m_nBaudRatePos = 2;
		break;
	}
	return TRUE;
}

BOOL CDownloadThread::SetDownloadMode(int nDownloadMode)
{
	m_nDownloadMode = nDownloadMode;

	return TRUE;
}

BOOL CDownloadThread::SetBinPathName(CString szBinPathName)
{
	m_strBinPathName = szBinPathName;

	return TRUE;
}

BOOL CDownloadThread::SetTfsPathName(CString szTfsPathName)
{
	m_strTfsPathName = szTfsPathName;

	return TRUE;
}

BOOL CDownloadThread::InitFlashDescription()
{
	UINT i;
	UINT j;
	UINT k;
	UINT l;

	UINT vl_SectorStart = 0;
	UINT vl_SectorEnd = 0;

	UINT vl_SizeSector = 0;
	BYTE vl_BankSector = 0;

	char al_ValueString[DWL_SECTOR_DESC_LENGTH];

  	BYTE vl_TmpChar = '\0';

	m_FlashDescription.m_nStartFlashAddr = DWL_ADDR_BASE;

	m_FlashDescription.m_byNbFlash = sizeof(a_FlashDescription) / sizeof(t_dwl_FlashInformation);

	if(m_FlashDescription.m_byNbFlash > DWL_NB_MAX_FLASHS)
	{
		return FALSE;
	}

	for(i=0;i<m_FlashDescription.m_byNbFlash;i++)
	{
		m_FlashDescription.m_aFlashCharacteristic[i].m_strManufacturerName = a_FlashDescription[i].a_ManufacturerName;
		m_FlashDescription.m_aFlashCharacteristic[i].m_strDeviceName = a_FlashDescription[i].a_DeviceName;
		m_FlashDescription.m_aFlashCharacteristic[i].m_byManufacturerId = a_FlashDescription[i].v_ManufacturerId;
		m_FlashDescription.m_aFlashCharacteristic[i].m_byDeviceId = a_FlashDescription[i].v_DeviceId;
		m_FlashDescription.m_aFlashCharacteristic[i].m_byNbBanks = a_FlashDescription[i].v_NbBanks;
		m_FlashDescription.m_aFlashCharacteristic[i].m_nNbSectors = a_FlashDescription[i].v_NbSectors;
		if(m_FlashDescription.m_aFlashCharacteristic[i].m_nNbSectors > DWL_NB_MAX_SECTORS)
		{
			return FALSE;
		}

		j = 0;
		while(a_FlashDescription[i].a_SectorDescription[j][0] != 0)
		{
			memset(al_ValueString,0x00,DWL_SECTOR_DESC_LENGTH);
			memcpy(al_ValueString,a_FlashDescription[i].a_SectorDescription[j],DWL_SECTOR_DESC_LENGTH);

			/* Look for the sector start */
			for(k=0;al_ValueString[k] !='-' && al_ValueString[k] !='*';k++)
			{
				/* Do nothing Only Count*/
			}
			if (al_ValueString[k] =='*')
			{
				vl_TmpChar = '*';
			}
			al_ValueString[k] = '\0';
			vl_SectorStart = atoi(al_ValueString);
			/* Check if there a problem */
			if(vl_SectorStart > m_FlashDescription.m_aFlashCharacteristic[i].m_nNbSectors)
			{
				return FALSE;
			}

			/* Look for the sector end */
			if(vl_TmpChar != '*')
			{
				l=k+1;
				for(k = l; al_ValueString[k] !='*';k++)
				{
					/* Do nothing */
				}
				al_ValueString[k] = '\0';
				vl_SectorEnd = atoi(&al_ValueString[l]);
				/* Check if there a problem */
				if(vl_SectorEnd > m_FlashDescription.m_aFlashCharacteristic[i].m_nNbSectors)
				{
					/* Error it is not possible */
					return FALSE;
				}
			}
			else
			{
				 vl_SectorEnd = vl_SectorStart;
			}
			/* Look for the size of sectors */
			l=k+1;
			for(k = l; al_ValueString[k] !='*';k++)
			{
				/* Do nothing */
			}

			al_ValueString[k] = '\0';
			vl_SizeSector = atoi(&al_ValueString[l]);
			/* Look for the bank of sectors */
			l=k+1;
			for(k = l; al_ValueString[k] != 0x00;k++)
			{
				/* Do nothing */
			}

			al_ValueString[k] = '\0';
			vl_BankSector = atoi(&al_ValueString[l]);
			/* Fill the structure with the parameters*/
			for (k= vl_SectorStart; k<= vl_SectorEnd;k++)
			{
				m_FlashDescription.m_aFlashCharacteristic[i].m_aSector[k].m_byBank = vl_BankSector;
				m_FlashDescription.m_aFlashCharacteristic[i].m_aSector[k].m_nSizeSector = vl_SizeSector;
			}

			/* initilalisation variable */			
			vl_TmpChar = '\0';

			j++;
		}
		
		m_FlashDescription.m_aFlashCharacteristic[i].m_nFlashSize = 0 ;
		/* Calculate the size of the flash */
		for (j =0; j<m_FlashDescription.m_aFlashCharacteristic[i].m_nNbSectors;j++)
		{
			m_FlashDescription.m_aFlashCharacteristic[i].m_nFlashSize =
				m_FlashDescription.m_aFlashCharacteristic[i].m_aSector[j].m_nSizeSector +
				m_FlashDescription.m_aFlashCharacteristic[i].m_nFlashSize;
		}
	}

	return TRUE;
}

BOOL CDownloadThread::InitTFSDescription(CString TfsFileName)
{
	u32 vl_FileLength=0;
	u32 vl_ReadCounter=0;

	u32 vl_Result;
	u32 vl_Result_1;
	u32 i;
	u32 j;
	u8 al_ValueString[20];

	CFile File;
	BYTE * pl_FileData;

	CString TfsCfgFileName;
	if(TfsFileName.IsEmpty())
	{
		return FALSE;
	}
	TfsCfgFileName = TfsFileName.Left(TfsFileName.GetLength()-3) + "cfg";
	if( !File.Open(TfsCfgFileName,CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone) )
	{
		AfxMessageBox("TFS Cfg File Open error");
		return FALSE;
	}
	vl_FileLength = File.GetLength();
	pl_FileData = new BYTE[vl_FileLength];
	File.ReadHuge( pl_FileData, vl_FileLength );
	File.Close();
	
	m_TFSDescritpion.Empty();
	
	/* Read the file and extract the information */
	while ( vl_ReadCounter < vl_FileLength)
	{
		if ( pl_FileData[vl_ReadCounter] == '#' || pl_FileData[vl_ReadCounter] == 0x0D ) //gyuhong : timeout
		{
			while (pl_FileData[vl_ReadCounter++] != 0x0A)
			{
				/* Do nothing increment the counter */
			}
		}
		else
		{
			/*TFSVERSION : */
			vl_Result = strncmp("TFSVERSION : ", (const char*)&pl_FileData[vl_ReadCounter], strlen("TFSVERSION : "));
			if( vl_Result == 0 )
			{
				vl_ReadCounter= vl_ReadCounter + strlen("TFSVERSION : ");
				for( i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++ )
				{					
					m_TFSDescritpion.m_aTFSVersion[i] = pl_FileData[vl_ReadCounter];
				}
				
				m_TFSDescritpion.m_aTFSVersion[i] = '\0';
				vl_ReadCounter= vl_ReadCounter + 2;
			}
			else if( vl_Result == 0 )
			{			
				delete pl_FileData;
				AfxMessageBox("TFS CFG : TFSVERSION Error");
				return FALSE;
			}
			/*NUM_DIR :*/
			vl_Result=strncmp("NUM_DIR : ",(const char*)&pl_FileData[vl_ReadCounter],strlen("NUM_DIR : "));
			if( vl_Result == 0 )
			{
				vl_ReadCounter= vl_ReadCounter + strlen("NUM_DIR : ");
				memset(al_ValueString,0x0,20);
				for( i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++)
				{
					al_ValueString[i]=pl_FileData[vl_ReadCounter];
				}
				al_ValueString[i++]='\0';				
				
				m_TFSDescritpion.m_NbPath = atoi ((const char*)al_ValueString);

				m_TFSDescritpion.EmptyPath();
				
				vl_ReadCounter = vl_ReadCounter + 2;
			}
			else
			{
				delete pl_FileData;
				AfxMessageBox("TFS CFG : NUM_DIR Error");
				return FALSE;
			}

			/*MAXFILES : */
			vl_Result=strncmp("MAXFILES : ",(const char*)&pl_FileData[vl_ReadCounter],strlen("MAXFILES : "));
			if( vl_Result == 0 )
			{
				vl_ReadCounter= vl_ReadCounter + strlen("MAXFILES : ");
				memset(al_ValueString,0x0,20);
				for(i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++)
				{
					al_ValueString[i]=pl_FileData[vl_ReadCounter];
				}
				al_ValueString[i++]='\0';
				
				m_TFSDescritpion.m_MaxNBFile = atoi((const char*)al_ValueString);
				
				m_TFSDescritpion.EmptyFile();
				
				vl_ReadCounter= vl_ReadCounter + 2;
			}
			else
			{
				delete pl_FileData;
				AfxMessageBox("TFS CFG : MAXFILES Error");
				return FALSE;
			}
			/*SET_DIR */			
			vl_Result=strncmp("SET_DIR",(const char*)&pl_FileData[vl_ReadCounter],strlen("SET_DIR"));
			j=0;
			if( vl_Result == 0 )
			{
				vl_ReadCounter= vl_ReadCounter + strlen("SET_DIR")+2;
				do
				{
					/*DIR_NAME : */
					vl_Result_1=strncmp("DIR_NAME : ",(const char*)&pl_FileData[vl_ReadCounter],strlen("DIR_NAME : "));
					if( vl_Result_1 == 0 )
					{						
						vl_ReadCounter= vl_ReadCounter + strlen("DIR_NAME : ");
						for(i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++)
						{							
							m_TFSDescritpion.m_aPath[j][i] = pl_FileData[vl_ReadCounter];
						}
						m_TFSDescritpion.m_aPath[j][i] = '\0';
						j++;
						vl_ReadCounter= vl_ReadCounter + 2;
					}
					else
					{
						delete pl_FileData;
						
						m_TFSDescritpion.Empty();
						AfxMessageBox("TFS CFG : DIR_NAME Error");
						return FALSE;
					}
				} while(strncmp("END_DIR",(const char*)&pl_FileData[vl_ReadCounter],strlen("END_DIR")));
				vl_ReadCounter= vl_ReadCounter + strlen("END_DIR")+2;
				if( j != m_TFSDescritpion.m_NbPath )
				{
					delete pl_FileData;
					m_TFSDescritpion.Empty();
					AfxMessageBox("TFS CFG : END_DIR Error");
					return FALSE;
				}
			}
			else
			{
				delete pl_FileData;
				m_TFSDescritpion.Empty();
				AfxMessageBox("TFS CFG : SET_DIR Error");
				return FALSE;
			}
			/*SET_FILE*/
			vl_Result=strncmp("SET_FILE",(const char*)&pl_FileData[vl_ReadCounter],strlen("SET_FILE"));
			j=0;
			if( vl_Result == 0 )
			{
				vl_ReadCounter= vl_ReadCounter + strlen("SET_FILE")+2;
				do
				{
					/*FILE_NAME : */
					vl_Result_1=strncmp("FILE_NAME : ",(const char*)&pl_FileData[vl_ReadCounter],strlen("FILE_NAME : "));
					if( vl_Result_1 == 0 )
					{
						vl_ReadCounter= vl_ReadCounter + strlen("FILE_NAME : ");
						for(i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++)
						{
							m_TFSDescritpion.m_aFile[j].v_TFSFName[i] = pl_FileData[vl_ReadCounter];
						}
						m_TFSDescritpion.m_aFile[j].v_TFSFName[i] = '\0';
						if(i>FNAMESUM)
						{
							delete pl_FileData;
							m_TFSDescritpion.Empty();
							AfxMessageBox("TFS CFG : FNAMESUM Error");
							return false;
						}
						vl_ReadCounter= vl_ReadCounter + 2;
					}
					else
					{
						delete pl_FileData;
						m_TFSDescritpion.Empty();
						AfxMessageBox("TFS CFG : FILE_NAME Error");
						return FALSE;
					}
					/*FILE_SIZE : */
					vl_Result_1=strncmp("FILE_SIZE : ",(const char*)&pl_FileData[vl_ReadCounter],strlen("FILE_SIZE : "));
					if( vl_Result_1 == 0 )
					{
						vl_ReadCounter= vl_ReadCounter + strlen("FILE_SIZE : ");
						memset(al_ValueString,0x0,20);
						for(i=0; pl_FileData[vl_ReadCounter] != 0xD; i++,vl_ReadCounter++)
						{							
							al_ValueString[i]=pl_FileData[vl_ReadCounter];
						}
						al_ValueString[i++]='\0';
						m_TFSDescritpion.m_aFile[j].v_Flength = atoi((const char*)al_ValueString); 
						vl_ReadCounter= vl_ReadCounter + 2;
						j++;						
					}
					else
					{
						delete pl_FileData;
						m_TFSDescritpion.Empty();
						AfxMessageBox("TFS CFG : FILE_SIZE Error");
						return FALSE;
					}
				}while(strncmp("END_FILE",(const char*)&pl_FileData[vl_ReadCounter],strlen("END_FILE")));
				vl_ReadCounter= vl_ReadCounter + strlen("END_FILE")+2;
				if( j > m_TFSDescritpion.m_MaxNBFile )
				{
					delete pl_FileData;
					m_TFSDescritpion.Empty();
					AfxMessageBox("TFS CFG : END_FILE Error");
					return FALSE;
				}
				m_TFSDescritpion.m_NbFile = j ;
			}
			else
			{
				delete pl_FileData;
				m_TFSDescritpion.Empty();
				AfxMessageBox("TFS CFG : SET_FILE Error");
				return FALSE;
			}
			/*END_TFS*/			
			vl_Result=strncmp("END_TFS",(const char*)&pl_FileData[vl_ReadCounter],strlen("END_TFS"));
			if(vl_Result==0)
			{
				vl_ReadCounter= vl_ReadCounter + strlen("END_TFS")+2;
			
				m_TFSDescritpion.m_TFSTotalSize = 0;
				for( i=0; i < j; i++ )
				{
					m_TFSDescritpion.m_TFSTotalSize += m_TFSDescritpion.m_aFile[i].v_Flength;
				}					
			}
			else
			{
				delete pl_FileData;
				m_TFSDescritpion.Empty();
				AfxMessageBox("TFS CFG : END_TFS Error");
				return FALSE;
			}
		}
	}

	delete pl_FileData;

	CFile tempFile;
	if( !tempFile.Open(TfsFileName,CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone) )
	{
		m_TFSDescritpion.Empty();
		AfxMessageBox("TFS CFG : TFS Open Failed!");
		return FALSE;
	}
	
	DWORD Filelength = tempFile.GetLength();
	tempFile.Close();
	CString strTemp;
	if( Filelength != m_TFSDescritpion.m_TFSTotalSize)
	{
		AfxMessageBox("TFS CFG : CFG File is not matched");
		strTemp.Format("CFG( %d) : TFS( %d)",m_TFSDescritpion.m_TFSTotalSize,Filelength);
		AfxMessageBox(strTemp);
		m_TFSDescritpion.Empty();
		return FALSE;
	}

	TRACE("InitTFSDescription OK\n");

	return TRUE;
}

int CDownloadThread::Run()
{
	DWORD dwExitCode = 0;

	do
	{
		m_bStop = FALSE;

		m_nThreadState = DL_THREAD_LOCKED;

		WaitForSingleObject(m_hEvt, INFINITE);
		
		m_nThreadState = DL_THREAD_WORKING;

		char strPath[1024] = {'\n',};
		CString strFileName;

		getcwd(strPath, 1024);
		strFileName.Format("%s\\Trace%d.txt", strPath, m_nPort);
		
		m_FileTrace.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary, NULL);