downloadthread.cpp

free sources for gsm

	}
	else
	{ 
		WriteFileTrace("Format fail!!");
        if ((u8)vl_Ack != 0x9d)
        {
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
        }

		return FALSE;
	}
	
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if(vl_Ack==0x22) //Creating Version code file OK
	{
		WriteFileTrace("Creating Version code file OK");
	}
	else
	{
		WriteFileTrace("Create Version Code Fail"); //mount err==0x33
        if ((u8)vl_Ack != 0x9d)
        {
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
		}
		
		return FALSE;
	}
	
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if(vl_Ack==0x23) //Writing Version code file OK
	{
		WriteFileTrace("Writing Version code file OK");
	}
	else
	{
		WriteFileTrace("Writing Version Code Fail!!");
        if ((u8)vl_Ack != 0x9d)
        {
			ReadCharFromUart( TIMEOUT, &vl_Ack);
        }
		
		return FALSE;
	}

	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if(vl_Ack == 0x20) //end precedure
	{
		WriteFileTrace("Flash is Formated!!");
	}
	else
	{
		WriteFileTrace("End Precedure Fail!");
		return FALSE;
	}

	WriteFileTrace("NAND Format Completed!!");	

	return TRUE;
}

BOOL CDownloadThread::DownloadTFSSoftware()
{
	u8 vl_Err;
	u32 vl_NbrCharSent = 0;	
	u32 vl_CheckSum = 0;
	u32 vl_CheckSumReceived = 0;

	u32 i;

	CString strTemp;

	WriteFileTrace("Starting TFS OGM Downloading..");
	m_pWnd->PostMessage(DL_MSG_DLLOADER, DL_FLASH_TFS_LOADING, m_nPort);

	if(!TFS_Init())
	{
		WriteFileTrace("TFS Init Error");
		m_pWnd->PostMessage(DL_MSG_ERR, TFS_INIT_ERR, m_nPort);
		return FALSE;
	}
	else
	{
		WriteFileTrace("TFS Init OK");
	}

	if(!TFS_WriteVersion())
	{
		WriteFileTrace("TFS Write Version Error");
		m_pWnd->PostMessage(DL_MSG_ERR, TFS_WRITE_VER_ERR, m_nPort);
		return FALSE;
	}
	else
	{
		WriteFileTrace("TFS Write Version OK");
	}
		
	for( i = 0; i < m_TFSDescritpion.m_NbPath; i++)
	{
		if(!TFS_WritePath(i))
		{
			WriteFileTrace("TFS Write Path Error");
			m_pWnd->PostMessage(DL_MSG_ERR, TFS_WRITE_PATH_ERR, m_nPort);
			return FALSE;
		}		
	}

	WriteFileTrace("TFS Write Paths OK");

	m_nPercent = 0;

	u32 FileCheckSum;
	for( i  =0; i < m_TFSDescritpion.m_NbFile; i++ )
	{
		FileCheckSum = 0;
		if(!TFS_WriteFile(i, &vl_CheckSum, &vl_NbrCharSent))
		{
			WriteFileTrace("TFS Write File Error");
			m_pWnd->PostMessage(DL_MSG_ERR, TFS_WRITE_FILE_ERR, m_nPort);
			return FALSE;
		}
		vl_CheckSum += FileCheckSum;
	}
	WriteFileTrace("TFS Writes File OK");
	
	WriteCharToUart( DWL_CMD_ENDFILEINFO );

	ReadCharFromUart( TIMEOUT, &vl_Err);

	if(vl_Err != DWL_ACK_ENDFILEINFO)
	{
		strTemp.Format( "DWL_SOFT_TFS_ENDFILEINFO_ERR(Error : 0x%x)", vl_Err);
		WriteFileTrace(strTemp);
		return FALSE;
	}
	else
	{
		/* Check the check sum of the block */
#if 0	  	
		if( 4 != m_CommPort.ReadComm((u8*)&vl_CheckSumReceived ,4))
		{
			WriteFileTrace("TFS Checksum received Error") ;
			return FALSE;
		}
#else
		u8 vl_Ack;
		vl_CheckSumReceived = 0;
		if(!ReadCharFromUart( TIMEOUT, &vl_Ack ))
		{
			WriteFileTrace("TFS Checksum received Error") ;
			return FALSE;
		}
		vl_CheckSumReceived = vl_Ack;
		if(!ReadCharFromUart( TIMEOUT, &vl_Ack ))
		{
			WriteFileTrace("TFS Checksum received Error") ;
			return FALSE;
		}
		vl_CheckSumReceived |= vl_Ack<<8;
		if(!ReadCharFromUart( TIMEOUT, &vl_Ack ))
		{
			WriteFileTrace("TFS Checksum received Error") ;
			return FALSE;
		}
		vl_CheckSumReceived |= vl_Ack<<16;
		if(!ReadCharFromUart( TIMEOUT, &vl_Ack ))
		{
			WriteFileTrace("TFS Checksum received Error") ;
			return FALSE;
		}
		vl_CheckSumReceived |= vl_Ack<<24;
#endif
		if( vl_CheckSumReceived != vl_CheckSum)
	  	{
			strTemp.Format( "DWL_SOFT_DOWNLOAD_SECTOR_CHECKSUM_ERR : 0x%X", vl_CheckSumReceived);
			WriteFileTrace(strTemp ) ;
			return FALSE;		
	
		}
		else /* The checksum is rigth, Download the next sector*/
		{
			WriteFileTrace("TFS OGM File Download Successfully Completed!!");
		}
	}

	/* Return code : No problem*/
	return TRUE;
}

BOOL CDownloadThread::TFS_Init()
{
	BYTE vl_Ack;
	CString strTemp;
	WriteCharToUart( DWL_CMD_DOWNLOAD_TFS );
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if( vl_Ack != DWL_ACK_DOWNLOAD_TFS)
	{
		strTemp.Format("DWL_ACK_DOWNLOAD_TFS Error (error : 0x%x)",vl_Ack);
		WriteFileTrace(strTemp);
		return FALSE;
	}
	 /* Get the result of the TFS progam initialization */
	WriteCharToUart(  DWL_CMD_TFS_INIT );
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if( vl_Ack == 0x77 ) 
	{		
		WriteFileTrace("TFS OK");
	}
	else if( vl_Ack == 0xA1 ) 
	{				
		ReadCharFromUart( TIMEOUT, &vl_Ack);
		strTemp.Format("Mount ERR: 0x%x",vl_Ack);
		WriteFileTrace( strTemp );
		
		return FALSE;
	}
	else if( vl_Ack == 0xA5 ) 
	{		
		ReadCharFromUart( TIMEOUT, &vl_Ack);
		strTemp.Format("SetDrv ERR: 0x%x",vl_Ack);
		WriteFileTrace( strTemp );
	
		return FALSE;
	}
	else
	{
		strTemp.Format("UnknowAck : 0x%x",vl_Ack);
		WriteFileTrace( strTemp );
		
		return FALSE;
	}
	return TRUE;
}

BOOL CDownloadThread::TFS_WriteVersion()
{
	u8 vl_Err;
	CString strTemp;

	WriteCharToUart(  DWL_CMD_TFSVERSION  );

	if( DWL_TFS_VERSION_LENGTH != m_CommPort.WriteComm( m_TFSDescritpion.m_aTFSVersion, DWL_TFS_VERSION_LENGTH))
	{
		WriteFileTrace("TFS Version Write Error");
		return FALSE;
	}

	ReadCharFromUart( TIMEOUT, &vl_Err);

	if( vl_Err != DWL_ACK_TFSVERSION )
	{
		strTemp.Format("DWL_ACK_TFSVERSION Error (error : 0x%x)",vl_Err);
		WriteFileTrace(strTemp);
		return FALSE;
	}

	return TRUE;
}

BOOL CDownloadThread::TFS_WritePath(int PathNum)
{
	BYTE vl_Err;
	CString strTemp;
	if( m_bStop )
	{
		m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
		return FALSE;
	}

	WriteCharToUart( DWL_CMD_TFS_PATH  );

	ReadCharFromUart( TIMEOUT, &vl_Err);
	if( DWL_ACK_TFS_PATH != vl_Err)
	{
		WriteFileTrace("DWL_ACK_TFS_PATH Error");
		return FALSE;
	}
	
	UINT PathLen = strlen((const char*)(m_TFSDescritpion.m_aPath[PathNum]));

	WriteCharToUart( (BYTE)(PathLen >> 24) );
	WriteCharToUart( (BYTE)(PathLen >> 16) );
	WriteCharToUart( (BYTE)(PathLen >> 8) );
	WriteCharToUart( (BYTE)(PathLen) );

	if( PathLen != m_CommPort.WriteComm( m_TFSDescritpion.m_aPath[PathNum], PathLen ))
	{
		strTemp.Format( "TFS PATH Write Error : 0x%x", PathNum);
		WriteFileTrace(strTemp);
		return FALSE;
	}
	u8 CheckSumPath = 0 ;
	for( u16 m = 0; m < PathLen ; m++)
	{
		CheckSumPath = CheckSumPath + m_TFSDescritpion.m_aPath[PathNum][m] ;
	}
	while(m_CommPort.GetOutQLen() != 0);	

	ReadCharFromUart( TIMEOUT, &vl_Err);
	if( CheckSumPath != vl_Err)
	{
		WriteFileTrace("TFS Path Data Checksum Error");
		return FALSE;
	}

	ReadCharFromUart( TIMEOUT, &vl_Err);

	if( vl_Err == DWL_ACK_PATHDATA )
	{
		strTemp.Format("%s OK", m_TFSDescritpion.m_aPath[PathNum]);
		WriteFileTrace(strTemp);
	}
	else
	{
		strTemp.Format( "DWL_SOFT_TFS_PATHDATA_ERR(index : 0x%x, Ack : 0x%x)", PathNum, vl_Err);
		WriteFileTrace(strTemp);
		return FALSE;
	}
	return TRUE;
}

BOOL CDownloadThread::TFS_WriteFile(int FileNum, UINT *pCheckSum, UINT *pNbrCharSent)
{
	u8 vl_Err;
	u32 j, k;
	CString strTemp;

	u8 vl_Param[4];

	u8 a_Buffer[DWL_BLOCK];
	if( m_bStop )
	{
		m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
		return FALSE;
	}

	WriteCharToUart( DWL_CMD_TFS_FILE  );
	ReadCharFromUart( TIMEOUT, &vl_Err);
	if( vl_Err != DWL_ACK_STARTDATA )
	{
		strTemp.Format("DWL_ACK_STARTDATA Error (error : 0x%x)",vl_Err);
		WriteFileTrace(strTemp);
		return FALSE;
	}

	UINT FileNameLen = strlen((const char*)(m_TFSDescritpion.m_aFile[FileNum].v_TFSFName));

	WriteCharToUart( (BYTE)(FileNameLen >> 24) );
	WriteCharToUart( (BYTE)(FileNameLen >> 16) );
	WriteCharToUart( (BYTE)(FileNameLen >> 8) );
	WriteCharToUart( (BYTE)(FileNameLen) );

	if( FileNameLen != m_CommPort.WriteComm( m_TFSDescritpion.m_aFile[FileNum].v_TFSFName, FileNameLen))
	{
		WriteFileTrace("FileName Write Error");
		return FALSE;
	}

	vl_Param[0] = (m_TFSDescritpion.m_aFile[FileNum].v_Flength)>>24;
	vl_Param[1] = (m_TFSDescritpion.m_aFile[FileNum].v_Flength)>>16;
	vl_Param[2] = (m_TFSDescritpion.m_aFile[FileNum].v_Flength)>>8;
	vl_Param[3] = (m_TFSDescritpion.m_aFile[FileNum].v_Flength);
	
	if( 4 != m_CommPort.WriteComm( vl_Param, 4))
	{
		WriteFileTrace("FileLength Write Error");
		return FALSE;
	}

	u8 CheckSumFileName = 0 ;
	for( u16 m = 0; m < FileNameLen ; m++)
	{
		CheckSumFileName = CheckSumFileName + m_TFSDescritpion.m_aFile[FileNum].v_TFSFName[m];
	}

	CheckSumFileName = CheckSumFileName + vl_Param[0];
	CheckSumFileName = CheckSumFileName + vl_Param[1];
	CheckSumFileName = CheckSumFileName + vl_Param[2];
	CheckSumFileName = CheckSumFileName + vl_Param[3];

	while(m_CommPort.GetOutQLen() != 0);	

	ReadCharFromUart( TIMEOUT, &vl_Err);
	if( CheckSumFileName != vl_Err)
	{
		WriteFileTrace("TFS File Name Checksum Error");
		return FALSE;
	}

	ReadCharFromUart( TIMEOUT, &vl_Err);
	if( vl_Err == DWL_ACK_CREATEFILE)
	{
		;
	}
	else
	{
		strTemp.Format( "DWL_SOFT_TFS_CREATEFILE_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
		WriteFileTrace(strTemp);

		return FALSE;
	}

	memset( a_Buffer, 0x00,	DWL_BLOCK);
	BYTE vl_Checksum = 0;
	if( m_TFSDescritpion.m_aFile[FileNum].v_Flength > DWL_BLOCK )
	{
		for(j = 0; j < m_TFSDescritpion.m_aFile[FileNum].v_Flength / DWL_BLOCK; j++)
		{
			if( m_bStop )
			{
				m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
				return FALSE;
			}

			memcpy(a_Buffer, (const void*)&m_pFileTFSData[*pNbrCharSent], DWL_BLOCK);

			if( DWL_BLOCK != m_CommPort.WriteComm( a_Buffer, DWL_BLOCK))
			{
				strTemp.Format("Write TFS File Data Error( index : % )", FileNum);
				WriteFileTrace( strTemp );
				return FALSE;
			}

			vl_Checksum = 0;
			for (k = 0; k < DWL_BLOCK ; k++)
			{
				*pCheckSum = *pCheckSum + a_Buffer[k];
				vl_Checksum = vl_Checksum + a_Buffer[k];
				(*pNbrCharSent)++;
			}
			memset( a_Buffer, 0x00,	DWL_BLOCK);
			while(m_CommPort.GetOutQLen() != 0);	
			
			m_nPercent = (*pNbrCharSent) * 100 / m_dwTfsLength ;
			m_pWnd->PostMessage(DL_MSG_PROGRESS, m_nPercent, m_nPort);
		
			ReadCharFromUart( TIMEOUT, &vl_Err);
			if( vl_Err == DWL_ACK_TFSDATA )
			{
				ReadCharFromUart( TIMEOUT, &vl_Err);
				if(vl_Err != vl_Checksum)
				{
					strTemp.Format( "DWL_SOFT_TFS_CHECKSUM_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
					WriteFileTrace(strTemp);
					return FALSE;					
				}
			}
			else
			{
				strTemp.Format( "DWL_SOFT_TFS_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
				WriteFileTrace(strTemp);
				return FALSE;					
			}
		}

		if( 0 != (m_TFSDescritpion.m_aFile[FileNum].v_Flength % DWL_BLOCK ))
		{
			memcpy(a_Buffer, (const void*)&m_pFileTFSData[*pNbrCharSent], m_TFSDescritpion.m_aFile[FileNum].v_Flength % DWL_BLOCK);
			if( (m_TFSDescritpion.m_aFile[FileNum].v_Flength % DWL_BLOCK) != m_CommPort.WriteComm( a_Buffer, m_TFSDescritpion.m_aFile[FileNum].v_Flength % DWL_BLOCK))
			{
				strTemp.Format("Write TFS File Data Error( index : %d )", FileNum);
				WriteFileTrace( strTemp );
				return FALSE;
			}

			vl_Checksum = 0;
			for ( k=0; k < (m_TFSDescritpion.m_aFile[FileNum].v_Flength % DWL_BLOCK ) ; k++)
			{
				*pCheckSum = *pCheckSum + a_Buffer[k];
				vl_Checksum = vl_Checksum + a_Buffer[k];
				(*pNbrCharSent)++;
			}
			memset( a_Buffer, 0x00,	DWL_BLOCK);
			while(m_CommPort.GetOutQLen() != 0);	

			m_nPercent = (*pNbrCharSent) * 100 / m_dwTfsLength ;
			m_pWnd->PostMessage(DL_MSG_PROGRESS, m_nPercent, m_nPort);

			ReadCharFromUart( TIMEOUT, &vl_Err);

			if( vl_Err == DWL_ACK_TFSDATA )
			{
				ReadCharFromUart( TIMEOUT, &vl_Err);
				if(vl_Err != vl_Checksum)
				{
					strTemp.Format( "DWL_SOFT_TFS_CHECKSUM_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
					WriteFileTrace(strTemp);
					return FALSE;					
				}
			}
			else
			{
				strTemp.Format( "DWL_SOFT_TFS_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
				WriteFileTrace(strTemp);
				return FALSE;
			}
		}
	}
	else
	{
		memcpy(a_Buffer, (const void*)&m_pFileTFSData[*pNbrCharSent], m_TFSDescritpion.m_aFile[FileNum].v_Flength);
			
		if( (m_TFSDescritpion.m_aFile[FileNum].v_Flength) != m_CommPort.WriteComm( a_Buffer, m_TFSDescritpion.m_aFile[FileNum].v_Flength))
		{
			strTemp.Format("Write TFS File Data Error( index : %d )", FileNum);
			WriteFileTrace( strTemp );
			return FALSE;
		}

		vl_Checksum = 0;
		for ( k=0; k < m_TFSDescritpion.m_aFile[FileNum].v_Flength ; k++)
		{
			*pCheckSum = *pCheckSum + a_Buffer[k];
			vl_Checksum = vl_Checksum + a_Buffer[k];
			(*pNbrCharSent)++;
		}

		memset( a_Buffer, 0x00,	DWL_BLOCK);
		while(m_CommPort.GetOutQLen() != 0);	

		m_nPercent = (*pNbrCharSent) * 100 / m_dwTfsLength ;
		m_pWnd->PostMessage(DL_MSG_PROGRESS, m_nPercent, m_nPort);

		ReadCharFromUart( TIMEOUT, &vl_Err);

		if( vl_Err == DWL_ACK_TFSDATA )
		{
			ReadCharFromUart( TIMEOUT, &vl_Err);
			if(vl_Err != vl_Checksum)
			{
				strTemp.Format( "DWL_SOFT_TFS_CHECKSUM_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
				WriteFileTrace(strTemp);
				return FALSE;					
			}
		}
		else
		{
			strTemp.Format( "DWL_SOFT_TFS_DATA_ERR(index : 0x%x, Ack : 0x%x)", FileNum, vl_Err);
			WriteFileTrace(strTemp);
			return FALSE;
		}
	}

	ReadCharFromUart( TIMEOUT, &vl_Err);

	if( vl_Err == DWL_ACK_CLOSEFILE )
	{
		strTemp.Format("%s OK", m_TFSDescritpion.m_aFile[FileNum].v_TFSFName);
		WriteFileTrace(strTemp);
	}
	else
	{
		strTemp.Format( "DWL_SOFT_TFS_CLOSEFILE_ERR(index : 0x%x, Ack : 0x%x", FileNum, vl_Err);
		WriteFileTrace(strTemp);
		return FALSE;
	}

	return TRUE;
}

BOOL CDownloadThread::SwitchOffCommand()
{
	u8  vl_Ack= 0;

	TRACE("COMMAND : Switch off the mobile");
	/* Inform the mobile the download procedure is finished */
	
	WriteCharToUart( DWL_CMD_END_OF_DOWNLOAD );

	/* Read the ack of the mobile */
	ReadCharFromUart(TIMEOUT, &vl_Ack);
	
	/* Check the acknowledge */
	if ( vl_Ack != DWL_ACK_COMMAND_OK)
	{
		WriteFileTrace("DWL_COMMAND_SWITCH_OFF_ERR Error");
		return FALSE;
	}

	/* return code */
	return TRUE;
}

void CDownloadThread::WriteFileTrace(CString strData)
{
	strData.Remove('\n');
	strData = strData + "\r\n";
	m_FileTrace.Write(strData, strData.GetLength());
	TRACE(strData);
}