downloadthread.cpp

free sources for gsm

  	/* Checksum is OK --> change speed */
  	/* Check the Output queue is empty before changing serial link speed */ 
	while ( m_CommPort.GetOutQLen () != 0);

	/* Init COM port with new speed and no parity */

	if (!m_CommPort.SetDCB( 115200 << m_nBaudRatePos, 8, NOPARITY, ONESTOPBIT))
	{
		WriteFileTrace("new speed Error");
		return FALSE;
	}

	if (!SpeedControl())
	{
		WriteFileTrace("SpeedControl Error");
		return FALSE;
	}
	/* return code */
	return TRUE;
}

BOOL CDownloadThread::SpeedControl()
{
	u8 vl_Ack;
	u8 vl_TrialNb=0;

	TRACE("COMMAND : control the mobile speed \n");
	do
	{
		/* Send command to the mobile to verify speed synchronisation between PC and mobile (try 3 times maximaum) */
		WriteCharToUart( DWL_CMD_CHANGE_SPEED_CONF ); 

		/* Wait for Acknowledge */ 
		ReadCharFromUart( TIMEOUT, &vl_Ack );
		vl_TrialNb++;
	} while ( (vl_TrialNb <= 3 ) && (vl_Ack != DWL_ACK_CHANGE_SPEED_CONF_ACK) );

	if (vl_Ack != DWL_ACK_CHANGE_SPEED_CONF_ACK)
	{
		WriteFileTrace("DWL_ACK_CHANGE_SPEED_CONF_ACK Error");
		return FALSE; 
	}	
	
	return TRUE;
}

BOOL CDownloadThread::DownloadExtendMobule()
{
	u32 vl_SizeFileSPM=0;

	u8 vl_Ack;
	u32 vl_DownloadSize=0;

	UINT Total;
	clock_t start;
	CString str;
	start = clock();

	WriteCharToUart( DWL_CMD_DOWNLOAD_EXTEND_MODULE );

	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if( vl_Ack != DWL_ACK_COMMAND_OK )
	{
		WriteFileTrace("DWL_CMD_DOWNLOAD_EXTEND_MODULE Error");
		m_pWnd->PostMessage(DL_MSG_ERR, DOWNLOAD_MODULE_ERR, m_nPort);
		return FALSE;
	}

	if(gl_strModel == "SGH-D488")
	{
		vl_SizeFileSPM = StubSize_D488[1];
	}
	else if(gl_strModel == "SGH-E330")
	{
		vl_SizeFileSPM = StubSize_E330[1];
	}
	else
	{
		vl_SizeFileSPM = StubSize[1];
	}

	ReadCharFromUart( TIMEOUT, &vl_Ack);
	vl_DownloadSize|=vl_Ack<<24;
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	vl_DownloadSize|=vl_Ack<<16;
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	vl_DownloadSize|=vl_Ack<<8;
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	vl_DownloadSize|=vl_Ack;

	if(vl_SizeFileSPM != vl_DownloadSize-1)
	{
		WriteFileTrace("Extend Module Size Error");
		m_pWnd->PostMessage(DL_MSG_ERR, DOWNLOAD_MODULE_ERR, m_nPort);
		return FALSE;
	}

	Total = 0;
	UINT size = 0;
	char *pStub;

	pStub = new char[vl_SizeFileSPM];

	if(gl_strModel == "SGH-D488")
	{
		memcpy((void *)pStub, (const void *)Stub_D488[1], vl_SizeFileSPM);
	}
	else if(gl_strModel == "SGH-E330")
	{
		memcpy((void *)pStub, (const void *)Stub_E330[1], vl_SizeFileSPM);
	}
	else
	{
		memcpy((void *)pStub, (const void *)Stub[1], vl_SizeFileSPM);
	}

	do
	{
		if (m_bStop)
		{
			m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
			return FALSE;
		}

		size = (vl_SizeFileSPM - Total ) > 256 ? 256 : vl_SizeFileSPM - Total ;

		if(!m_CommPort.WriteComm((void*)&(pStub[Total]), size))
		{
			WriteFileTrace("Send Char error during Loader download");
			m_pWnd->PostMessage(DL_MSG_ERR, SEND_CHAR_ERR, m_nPort);

			delete pStub;
			return FALSE;
		}
		Total += size ;
		m_nPercent = (UINT)(Total * 100/vl_SizeFileSPM);
		m_pWnd->PostMessage(DL_MSG_PROGRESS, m_nPercent, m_nPort);	
	}
	while ( Total < vl_SizeFileSPM);

	delete pStub;

	WriteCharToUart( 0x00 ); /*SEND EOF*/
	ReadCharFromUart( TIMEOUT*10, &vl_Ack);
	
	if( vl_Ack != 99 )
	{
		return FALSE;
	}

	m_pWnd->PostMessage(DL_MSG_DLLOADER, DL_LOADER_DONE, m_nPort);

	return TRUE;
}

BOOL CDownloadThread::FileOpen()
{
	if(m_nDownloadMode == 0 || m_nDownloadMode == 1)
	{
		if(m_fileBin.Open(m_strBinPathName, CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone))
		{
			m_dwBinLength = m_fileBin.GetLength();
		}
		else
		{
			AfxMessageBox("Binary File Open Error !!");
			return FALSE;
		}
	}

	if(m_nDownloadMode == 0 || m_nDownloadMode == 2)
	{
		if(m_fileTfs.Open(m_strTfsPathName, CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone))
		{
			m_dwTfsLength = m_fileTfs.GetLength();
		}
		else
		{
			AfxMessageBox("TFS File Open Error !!");
			return FALSE;
		}
	}

	return TRUE;
}

BOOL CDownloadThread::SendToFlash()
{
	if(m_nDownloadMode == 0 || m_nDownloadMode == 1)
	{
		if(!DownloadSoftware(DWL_ADDR_BASE)) return FALSE;
	}

	if(m_nDownloadMode == 0 || m_nDownloadMode == 2)
	{
		if(!NandFormat()) return FALSE;

		if(!DownloadTFSSoftware()) return FALSE;
	}

	if(gl_strModel != "SGH-E630")
	{
		if(!SwitchOffCommand()) return FALSE;
	}
	else
	{
		Sleep(2000);
	}

	return TRUE;
}

BOOL CDownloadThread::DownloadSoftware(UINT vp_AddrBase)
{
	CFlashSectorList vl_FlashSectorList;

	u32 vl_SectorSize = 0;
	u32 vl_SizeTmp = 0;
	u8 vl_Ack =0;
	u32 i,j,k;
	u32 vl_NbrCharSent = 0;
	u32 vl_NbrChar = 0;
	u32 vl_CheckSum = 0;
	u32 vl_CheckSumReceived = 0;
	u8 vl_NbErrorSector = 0;
	u8 vl_NbErrorAllSector =0;

	CString str;
	WriteFileTrace("Starting Binary Downloading..");
	m_pWnd->PostMessage(DL_MSG_DLLOADER, DL_FLASH_BIN_LOADING, m_nPort);

	/* Get the sector list allows the download */
	if (!GetSectorList(&vl_FlashSectorList, vp_AddrBase- DWL_ADDR_BASE, m_dwBinLength ))
	{
		WriteFileTrace("GetSectorList Error");
		m_pWnd->PostMessage(DL_MSG_ERR, GET_SECTOR_LIST_ERR, m_nPort);
		return FALSE;
	}	

	for ( i=0; i<vl_FlashSectorList.v_NbSector;i++)
	{
		vl_CheckSum = 0;
  		vl_CheckSumReceived = 0;
		if( m_bStop )
		{
			m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
			return FALSE;
		}
		/* Get the size of sector */
		if (!GetSectorSize(vl_FlashSectorList.v_SectorList[i], &vl_SectorSize))
		{			
			WriteFileTrace("GetSectorSize");
			m_pWnd->PostMessage(DL_MSG_ERR, GET_SECTOR_SIZE_ERR, m_nPort);
			return FALSE;
		}

		if (vl_SectorSize < (m_dwBinLength - vl_SizeTmp))
		{
			vl_SizeTmp  = vl_SizeTmp + vl_SectorSize;
			vl_NbrChar = vl_SectorSize;
			/* send download sector command */
			DownloadSectorCommand(vp_AddrBase, vl_SectorSize, vl_SectorSize );
		}					 
		else
		{
			vl_NbrChar = m_dwBinLength - vl_SizeTmp;
			vl_SizeTmp = vl_SizeTmp + (m_dwBinLength - vl_SizeTmp);
			/* send download sector command */
			DownloadSectorCommand(vp_AddrBase, vl_SectorSize, vl_NbrChar );
		}

		/* Start the transfert */
		u8* pp_FileData;

		pp_FileData = m_pFileClaData;
		/* 8kbytes buffer by 8kbytes buffer */
		for (j=0; j < (vl_NbrChar / DWL_BLOCK) ; j++)
		{
			if( m_bStop )
			{
				m_pWnd->PostMessage(DL_MSG_WORK_CANCEL, NULL, m_nPort);
				return FALSE;
			}
			m_CommPort.WriteComm(&(pp_FileData[vl_NbrCharSent]), DWL_BLOCK);
			/* Calculate checksum */
			for ( k=0; k<(DWL_BLOCK); k++)
			{
				vl_CheckSum = vl_CheckSum + pp_FileData[vl_NbrCharSent];
				vl_NbrCharSent++;
			}
			while( m_CommPort.GetOutQLen() != 0 );
			Sleep(0);
		}

		if(vl_NbrChar % DWL_BLOCK)
		{
			m_CommPort.WriteComm(&(pp_FileData[vl_NbrCharSent]), (vl_NbrChar % DWL_BLOCK) );
			/* Calculate checksum */
			for ( k=0; k<(vl_NbrChar % DWL_BLOCK); k++)
			{
				vl_CheckSum = vl_CheckSum + pp_FileData[vl_NbrCharSent];
				vl_NbrCharSent++;
			}
			while( m_CommPort.GetOutQLen() != 0 );
			Sleep(0);
		}

		/* Wait the acknowlegde from the mobile */
		/* It indicate the end of sector download */
		vl_Ack = 0;
		ReadCharFromUart( TIMEOUT, &vl_Ack);

		if ( vl_Ack != DWL_ACK_DOWNLOAD_SECTOR_END)
		{
			if ( vl_Ack == DWL_ACK_DOWNLOAD_SECTOR_ERR)
			{
				/* Receive status */
				ReadCharFromUart( TIMEOUT, &vl_Ack);
				/* Error management*/
				vl_NbErrorSector++;
				vl_NbErrorAllSector++;
				if ( vl_NbErrorSector == 3 || vl_NbErrorAllSector == 5)
				{
					/* return code */
					WriteFileTrace("DWL_SOFT_DOWNLOAD_SECTOR_ERR");
					m_pWnd->PostMessage(DL_MSG_ERR, DOWNLOAD_SECTOR_ERR, m_nPort);
					return FALSE;
				}
				vl_NbrCharSent = vl_NbrCharSent - vl_NbrChar;
				vl_SizeTmp  = vl_SizeTmp - vl_NbrChar;   
				i--;
			}
			else /* Error of synchronisation, abort the download */
			{
				/* return code */
				WriteFileTrace("DWL_SOFT_DOWNLOAD_SECTOR_END_ERR");
				m_pWnd->PostMessage(DL_MSG_ERR, DOWNLOAD_SECTOR_ERR, m_nPort);
				return FALSE;
			}
		}
		else /* Right acknowledge, ckeck the ckecksum */
		{
			/* Check the check sum of the block */
#if 0
			m_CommPort.ReadComm((u8*)&vl_CheckSumReceived, 4);
#else
			vl_CheckSumReceived = 0;
			ReadCharFromUart( TIMEOUT, &vl_Ack );
			vl_CheckSumReceived = vl_Ack;
			ReadCharFromUart( TIMEOUT, &vl_Ack );
			vl_CheckSumReceived |= vl_Ack<<8;
			ReadCharFromUart( TIMEOUT, &vl_Ack );
			vl_CheckSumReceived |= vl_Ack<<16;
			ReadCharFromUart( TIMEOUT, &vl_Ack );
			vl_CheckSumReceived |= vl_Ack<<24;
#endif

			if( vl_CheckSumReceived != vl_CheckSum)
		  	{
				/* Error management*/
				vl_NbErrorSector++;
				vl_NbErrorAllSector++;
				if ( vl_NbErrorSector ==3 || vl_NbErrorAllSector == 5)
				{
					/* return code */
					WriteFileTrace("DWL_SOFT_DOWNLOAD_SECTOR_CHECKSUM");
					return FALSE;
				}
				vl_NbrCharSent = vl_NbrCharSent - vl_NbrChar;
				vl_SizeTmp  = vl_SizeTmp - vl_NbrChar;   
				i--;
		  	}
		  	else /* The checksum is rigth, Download the next sector*/
		  	{
				m_nPercent = vl_NbrCharSent * 100 / m_dwBinLength ;
				m_pWnd->PostMessage(DL_MSG_PROGRESS, m_nPercent, m_nPort);
				str.Format( "DOWNLOAD : 0x%08X ~ 0x%08X ...OK", 
					vp_AddrBase - DWL_ADDR_BASE, vp_AddrBase - DWL_ADDR_BASE + vl_SectorSize -1 );
				WriteFileTrace(str);
				vp_AddrBase = vp_AddrBase + vl_SectorSize;
				/* Reset the number of error for this sector*/
				vl_NbErrorSector = 0;
		  	}
		}
		Sleep(0);
	}

	WriteFileTrace("Binary File Download Successfully Completed!!");

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

BOOL CDownloadThread::GetSectorList(CFlashSectorList* pp_FlashSectorList, UINT vp_StartAddress, DWORD vp_SectionSize)
{

	u8 vl_FlashIndex =0;
	u32 vl_SectorNumber = 0; 
	u32 vl_SizeTmp = 0;
	u32 i=0;
	
	/* Initialisation */
	pp_FlashSectorList->v_TotalSectorSize = 0;
	pp_FlashSectorList->v_NbSector =0;
	/* Get the index of the flash according to Device ID */
	if(!GetFlashIndex(&vl_FlashIndex))
	{
		WriteFileTrace("GetFlashIndex Error");
		return FALSE;
	}
	else
	{
		/* Check the address pass in parameter is rigth */
		/* GYUHONG : vl_SectorNumber = calculate number of start sector */
		if( !GetSectorNumberWithStartAddr(vp_StartAddress ,&vl_SectorNumber))
		/* if the vl_ReturnCode is different from DWL_FLASH_OK then return DWL_FLASH_ADDR_NOT_START_SECTOR */
		{
			WriteFileTrace("GetSectorNumberWithStartAddr Error");
			return FALSE;
		}
		else
		{
			/* GYUHONG : check the space */
			while(vl_SizeTmp < vp_SectionSize) 
			{
				vl_SizeTmp = vl_SizeTmp + m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_aSector[vl_SectorNumber].m_nSizeSector ;
				pp_FlashSectorList->v_SectorList[pp_FlashSectorList->v_NbSector] = vl_SectorNumber;
				pp_FlashSectorList->v_NbSector++;
				vl_SectorNumber++;
				if ( m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_nNbSectors < vl_SectorNumber )
				{
					WriteFileTrace("DWL_FLASH_NO_ENOUGH_SECTOR");
					return FALSE;
				}
			}
			pp_FlashSectorList->v_TotalSectorSize = vl_SizeTmp;
		}
	}
	return TRUE;
}

BOOL CDownloadThread::GetSectorNumberWithStartAddr(UINT vp_StartAddress, UINT* pp_SectorNumber) 
{
	u8 vl_FlashIndex =0;
	u16 i=0;
	bool vl_AddressFound = FALSE;
	u32 vl_AddressTmp = 0;

	/* Get the index of the flash according to Device ID */
	if(!GetFlashIndex(&vl_FlashIndex))
	{
		WriteFileTrace("GetFlashIndex Error");
		return FALSE;
	}
	else
	{
		/* Special case */
		if (vp_StartAddress ==0)
		{ /* It is first sector */
			*pp_SectorNumber = 0;
			vl_AddressFound = TRUE;	
		}
		/* Try to find the address */
		for ( i=0; i< m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_nNbSectors && vl_AddressFound != true ; i++)
		{
			vl_AddressTmp = vl_AddressTmp + m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_aSector[i].m_nSizeSector;
			if(vl_AddressTmp >= vp_StartAddress)
			{
				*pp_SectorNumber = i+1;
				vl_AddressFound = TRUE;	
			}
		}
		if (vl_AddressFound == TRUE)
		{
			if( vl_AddressTmp != vp_StartAddress)
			{
				;
			}
		}
		else
		{
			WriteFileTrace("DWL_FLASH_ADDR_NOT_START_SECTOR");
			return FALSE;
		}
	}
	return TRUE;
}

BOOL CDownloadThread::GetSectorSize(UINT vp_SectorNb, UINT* pp_SectorSize)
{
	u8 vl_FlashIndex =0;

	/* Get the index of the flash according to Device ID */
	if(!GetFlashIndex(&vl_FlashIndex))
	/* if the vl_ReturnCode is different from DWL_FLASH_OK then return DWL_FLASH_DEVICE_ID_UNKNOWN*/
	{
		WriteFileTrace("GetFlashIndex");
		return FALSE;
	}
	else
	{
		/* Check that the v_SectorNumber is not upper than the number of sector for this flash */
		if( vp_SectorNb < m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_nNbSectors )
		{		
			*pp_SectorSize	= m_FlashDescription.m_aFlashCharacteristic[vl_FlashIndex].m_aSector[vp_SectorNb].m_nSizeSector;
		}
		else
		{ 
			/* Problem : The parameter v_SectorNumber is not rigth (> of number of sector for this flash */
			WriteFileTrace("DWL_FLASH_PROB_WITH_SECTOR_NB");
			return FALSE;
		}
	}
	return TRUE;
}

BOOL CDownloadThread::DownloadSectorCommand(UINT vp_StartAddress, UINT vp_SectorSize, UINT vp_BlockSize)
{
	u8 vl_Params[4];

	TRACE("COMMAND : Send command to download a sector\n");
	/* Send the command to download a sector */
	WriteCharToUart( DWL_CMD_DOWNLOAD_SECTOR);

	/* Send sector size */ 
	vl_Params[0] = (vp_SectorSize >> 24);
	vl_Params[1] = (vp_SectorSize >> 16);   
	vl_Params[2] = (vp_SectorSize >> 8);   
	vl_Params[3] = (vp_SectorSize); 
	m_CommPort.WriteComm(vl_Params, 4);

	/* Send first block address */
	vl_Params[0] = (vp_StartAddress >> 24);
	vl_Params[1] = (vp_StartAddress >> 16);   
	vl_Params[2] = (vp_StartAddress >> 8);   
	vl_Params[3] = (vp_StartAddress);   
	m_CommPort.WriteComm(vl_Params, 4);

	/* Send the block size */
	vl_Params[0] = (vp_BlockSize >> 24);
	vl_Params[1] = (vp_BlockSize >> 16);   
	vl_Params[2] = (vp_BlockSize >> 8);   
	vl_Params[3] = (vp_BlockSize);   
	m_CommPort.WriteComm(vl_Params, 4);

	/* return code */
	return TRUE;
}

BOOL CDownloadThread::NandFormat()
{
	u8 vl_Ack;
	
	WriteCharToUart( 0x10 ); //format commnad
	
	ReadCharFromUart( TIMEOUT*5, &vl_Ack);
	if(vl_Ack==0x57) //MakeBadMapTable OK
	{
		WriteFileTrace("MakeBadMapTable OK");
	}
	else
	{
		WriteFileTrace("MakeBadMapTable err");
		
		if ((u8)vl_Ack != 0x9d)
		{
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			ReadCharFromUart( TIMEOUT, &vl_Ack);
		}
		
		return FALSE;
	}
	ReadCharFromUart( TIMEOUT, &vl_Ack);
	if(vl_Ack==0x44) //format OK
	{	
		WriteFileTrace("Format OK");
		ReadCharFromUart( TIMEOUT, &vl_Ack);
		if(vl_Ack==0x91)
		{
			WriteFileTrace("Mount OK"); 			
			ReadCharFromUart( TIMEOUT, &vl_Ack);
			if(vl_Ack==0x92)
			{
				WriteFileTrace("Setdrv OK");					
				ReadCharFromUart( TIMEOUT, &vl_Ack);
				if(vl_Ack==0x93)
				{
					WriteFileTrace("Create dir OK");
				}			
			}			
		}