marvell/obm/Common/Misc/asr_flag.c

#include "asr_flag.h"
#include "fota.h"
#include "obm2osl.h"
#include "serial.h"
#include "Errors.h"
#include "print.h"

extern UINT_T UUID[2];
extern UINT8_T FlashInitDone;
extern OBM2OSL	*pOBM2OSL_h;
FOTA_Info FOTAInfo;
FOTA_Firmware FotaFirmware;

static void OTA_SetDefault_Config(P_FOTA_Firmware pFOTA_T, UINT_T Header, UINT_T MaxLen);

VOID ASRFlag_ParseCfgToOBM2OSLO(pTIM pTIM_h)
{
	P_FOTA_Firmware pFOTA_T = OTAGetConfig(pTIM_h);

	if(pFOTA_T == NULL){
		obm_printf("ASR Flag not found in %s\n\r", __FUNCTION__);
		return;
	}

	if(pFOTA_T->eehP[0] == EEHPID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->eehP[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->eehP[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->cpsr[0] == CPSRID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->cpsr[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->cpsr[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->hawk[0] == HAWKID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->hawk[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->hawk[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->imsd[0] == IMSDID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->imsd[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->imsd[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if((pFOTA_T->Production_Mode_Flag >= 0)&&
	   (pFOTA_T->Production_Mode_Flag <= 2))
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id		 = PRODID;
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value	  = pFOTA_T->Production_Mode_Flag;
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->pipe[0] == PIPEID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->pipe[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->pipe[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->fast[0] == FASTID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->fast[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->fast[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->apmf[0] == APMFID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->apmf[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->apmf[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->pid[0] == PIDID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->pid[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->pid[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->vid[0] == VIDID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->vid[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->vid[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(UUID[0] != 0)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = UUID0;
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = UUID[0];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(UUID[1] != 0)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = UUID1;
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = UUID[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->ramdump[0] == RAMDUMPID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->ramdump[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->ramdump[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->nocp[0] == NOCPID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->nocp[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->nocp[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

	if(pFOTA_T->cplog[0] == CPLOGID)
	{
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = pFOTA_T->cplog[0];
		pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = pFOTA_T->cplog[1];
		pOBM2OSL_h->info.cfg_numbers++;
	}

#if CONFIG_SAVE_LOG_TO_MEM
	pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_id	 = BOOT_LOG_MAGIC;
	pOBM2OSL_h->info.cfg_info[pOBM2OSL_h->info.cfg_numbers].cfg_value  = CONFIG_BOOT_LOG_ADDR;
	pOBM2OSL_h->info.cfg_numbers++;
#endif

	return;
}

VOID ASRFlag_UpdateCRC(P_FOTA_Firmware pFOTA_T)
{
	UINT_T CrcLen, CrcVal;
	CrcLen = sizeof(FOTA_Firmware) - 4; /* 4 bytes is CRC itself */

	CrcVal = malbrain_crc32(0, pFOTA_T, CrcLen);

	pFOTA_T->CRC = CrcVal;

	return;
}

INT_T ASRFlag_ValidateCRC(P_FOTA_Firmware pFOTA_T)
{
	UINT_T CrcLen, CrcVal;
	CrcLen = sizeof(FOTA_Firmware) - 4; /* 4 bytes is CRC itself */

	CrcVal = malbrain_crc32(0, pFOTA_T, CrcLen);

	if(pFOTA_T->CRC != CrcVal){
		obm_printf("ASR Flag CRC mismatch: 0x%x 0x%x 0x%x\n\r", CrcVal, pFOTA_T->CRC, pFOTA_T->Header);
		return 1;
	}

	return 0;
}

INT_T ASRFlag_IsInvalid(P_FOTA_Firmware pFOTA_T, pFOTA_INFO pFI)
{
	if(pFOTA_T->Header != pFI->Magic)
		return 1;

	if(ASRFlag_ValidateCRC(pFOTA_T))
		return 1;

	return 0;
}

P_FOTA_Firmware OTAGetConfig(pTIM pTIM_h)
{
	UINT_T Retval = GeneralError;
	P_FOTA_Firmware pFOTA_T = &FotaFirmware;
	P_FOTA_Firmware pFOTA_Temp1 = NULL;
	P_FOTA_Firmware pFOTA_Temp2 = NULL;
	pWTP_RESERVED_AREA_HEADER pWRAH = NULL;
	pFOTA_INFO pFI = NULL;
	P_FOTA_Info pFOTAInfo = &FOTAInfo;
	P_FlashProperties_T pFlashP = GetFlashProperties(BOOT_FLASH);
	UINT_T AsrFlagLen = sizeof(FOTA_Firmware);
#if MMC_CODE
	UINT_T AsrFlagMaxLen = MAX_ASR_FLAG_SIZE;
#else
	UINT_T AsrFlagMaxLen = pFlashP->BlockSize;
#endif
	UINT_T NeedUpgrade = 1;
	CHAR *CurVersion = NULL;

#if MMC_CODE
	SetPartition(MMC_SD_USER_PARTITION, BOOT_FLASH);
#endif

	if((pFOTAInfo->InitFlag != INIT_DONE) && FlashInitDone)
	{
		pWRAH = FindPackageInReserved(&Retval, pTIM_h, FOTAINFOID);
		if ((pWRAH == NULL) || (Retval != NoError))
		{
			obm_printf("No FOTA package found\n\r");
			return NULL;
		}
		else
		{
			pFI = (pFOTA_INFO) pWRAH;
			if (pFI->Enable != 1)
			{
				obm_printf("FOTA Not Enabled\n\r");
				return NULL;
			}
			else
			{
				pFOTA_Temp1 = malloc(AsrFlagMaxLen);
				pFOTA_Temp2 = malloc(AsrFlagMaxLen);
				if(pFOTA_Temp1 == NULL || pFOTA_Temp2 == NULL)
					return HeapExhaustedError;
				memset(pFOTA_Temp1, 0xFF, AsrFlagMaxLen);
				memset(pFOTA_Temp2, 0xFF, AsrFlagMaxLen);

				pFOTAInfo->FOTA_Addr = pFI->FlashAddr;
				pFOTAInfo->FOTA_FBF_Flag = pFI->Magic;
				if(pWRAH->Size == 24)
					AsrFlagMaxLen = pFI->FlagLen;

				Retval = ReadFlash(pFI->FlashAddr, pFOTA_Temp1, AsrFlagLen, BOOT_FLASH);
				if (Retval != NoError || pFOTA_Temp1->Header != pFI->Magic)
				{
					obm_printf("No main ASR Flag, ret: 0x%x, 0x%x\n\r", Retval, pFOTA_Temp1->Header);
					free(pFOTA_Temp1); pFOTA_Temp1 = NULL;
				}

#if MMC_CODE
				Retval = ReadFlash(pFI->FlashAddr + AsrFlagMaxLen/512, pFOTA_Temp2, AsrFlagLen, BOOT_FLASH);
#else
				Retval = ReadFlash(pFI->FlashAddr + AsrFlagMaxLen, pFOTA_Temp2, AsrFlagLen, BOOT_FLASH);
#endif
				if (Retval != NoError || pFOTA_Temp2->Header != pFI->Magic )
				{
					obm_printf("No backup ASR Flag, ret: 0x%x, 0x%x\n\r", Retval, pFOTA_Temp2->CRC);
					free(pFOTA_Temp2); pFOTA_Temp2 = NULL;
				}

				if ( pFOTA_Temp2 ) { /* means dual asr flag is enabled */
					if (pFOTA_Temp2->Version == ASRFLAG_VERSION_LEGACY ||
						pFOTA_Temp2->Version < ASRFLAG_VERSION_DAF)
					{
						free(pFOTA_Temp2); pFOTA_Temp2 = NULL;
					}

					if (pFOTA_Temp1 && ( pFOTA_Temp1->Version == ASRFLAG_VERSION_LEGACY ||
						pFOTA_Temp1->Version < ASRFLAG_VERSION_DAF) )
					{
						free(pFOTA_Temp1); pFOTA_Temp1 = NULL;
					}
				}

				if (pFOTA_Temp2 == NULL && pFOTA_Temp1 == NULL) {
					obm_printf("Init ASR Flag partition\n\r");
					OTA_SetDefault_Config(pFOTA_T, pFI->Magic, AsrFlagMaxLen);
				} else {
					if(pFOTA_Temp1 == NULL) {
						memcpy(pFOTA_T, pFOTA_Temp2, AsrFlagLen);
					} else if(pFOTA_Temp2 == NULL) {
						memcpy(pFOTA_T, pFOTA_Temp1, AsrFlagLen);
					} else {
						if (pFOTA_Temp1->Version >= ASRFLAG_VERSION_CRC || 
							pFOTA_Temp2->Version >= ASRFLAG_VERSION_CRC)
						{
							if (ASRFlag_ValidateCRC(pFOTA_Temp1) ) {
								free(pFOTA_Temp1); pFOTA_Temp1 = NULL;
							}

							if (ASRFlag_ValidateCRC(pFOTA_Temp2) ) {
								free(pFOTA_Temp2); pFOTA_Temp2 = NULL;
							}

							if (pFOTA_Temp1 == NULL && pFOTA_Temp2 == NULL) {
								obm_printf("ASR Flag is lost, re-init, should never happen\n\r");
								OTA_SetDefault_Config(pFOTA_T, pFI->Magic, AsrFlagMaxLen);
								goto asr_flag_found;
							} else if (pFOTA_Temp1 == NULL) {
								memcpy(pFOTA_T, pFOTA_Temp2, AsrFlagLen);
								goto asr_flag_found;
							} else if (pFOTA_Temp2 == NULL) {
								memcpy(pFOTA_T, pFOTA_Temp1, AsrFlagLen);
								goto asr_flag_found;
							}
						}

						if(pFOTA_Temp2->RefCounter > pFOTA_Temp1->RefCounter)
							memcpy(pFOTA_T, pFOTA_Temp2, AsrFlagLen);
						else
							memcpy(pFOTA_T, pFOTA_Temp1, AsrFlagLen);

						if(pFOTA_Temp1->RefCounter == pFOTA_Temp2->RefCounter)
							NeedUpgrade = 0;
					}
				}

	asr_flag_found:
				/* There is an old version ASR flag in board */
				if (pFOTA_T->Version != ASRFLAG_VERSION) {
					/* old way, upgrade here */
					pFOTA_T->RefCounter = 0;
					pFOTA_T->FlagLen = AsrFlagMaxLen;
					NeedUpgrade = 1;
					if(pFOTA_T->Version == ASRFLAG_VERSION_LEGACY)
						CurVersion = "legacy";
					else
						CurVersion = HexToSwdObmVersion(pFOTA_T->Version);
					obm_printf("Upgrade ASR Flag from %s to ", CurVersion);
					obm_printf("%s\n\r", HexToSwdObmVersion(ASRFLAG_VERSION));
					pFOTA_T->Version = ASRFLAG_VERSION;
				}

				pFOTAInfo->InitFlag = INIT_DONE;
				serial_set_quiet(!pFOTA_T->ramdump[1]);

				if (pFOTA_Temp1) { free(pFOTA_Temp1); pFOTA_Temp1 = NULL; }
				if (pFOTA_Temp2) { free(pFOTA_Temp2); pFOTA_Temp2 = NULL; }

				UINT_T DDR_PID = GetDDR_PID();
				UINT_T Flash_PID = GetFlash_PID();
				if(DDR_PID != 0 && pFOTA_T->DDR_ID != DDR_PID) {
					pFOTA_T->DDR_ID = DDR_PID;
					NeedUpgrade++;
				}

				if(Flash_PID != 0 && pFOTA_T->Flash_ID != Flash_PID) {
					pFOTA_T->Flash_ID = Flash_PID;
					NeedUpgrade++;
				}

				/* InitFlag must be INIT_DONE here, otherwise deed loop */
				if(NeedUpgrade) OTA_Save_Config(pTIM_h);
			}
		}
	}

	return pFOTA_T;
}

UINT_T OTA_Save_Config(pTIM pTIM_h)
{
	UINT_T MainRet = NoError, BackupRet = NoError;
	P_FOTA_Info pFOTAInfo = &FOTAInfo;
	P_FOTA_Firmware pFOTA_T = OTAGetConfig(pTIM_h);
	P_FlashProperties_T pFlashP = GetFlashProperties(BOOT_FLASH);
#if MMC_CODE
	UINT_T AsrFlagMaxLen = MAX_ASR_FLAG_SIZE;
#else
	UINT_T AsrFlagMaxLen = pFlashP->BlockSize;
#endif
	UINT_T AsrFlagLen = sizeof(FOTA_Firmware);

	if (!pFOTA_T)
		return NotFoundError;

#if MMC_CODE
	SetPartition(MMC_SD_USER_PARTITION, BOOT_FLASH);
#endif

	if (pFOTA_T->Header != pFOTAInfo->FOTA_FBF_Flag)
	{
		obm_printf("ASR Flag Header mismatch: 0x%x, 0x%x\n\r", 
						pFOTA_T->Header, pFOTAInfo->FOTA_FBF_Flag);
		return NotFoundError;
	}

	if(pFOTA_T->RefCounter++ == 0xFFFFFFFF)
		pFOTA_T->RefCounter = 0;

	ASRFlag_UpdateCRC(pFOTA_T);

	AsrFlagMaxLen = pFOTA_T->FlagLen;

	MainRet = EraseFlash(pFOTAInfo->FOTA_Addr, AsrFlagLen, BOOT_FLASH);
	if (MainRet != NoError)
	{
		obm_printf("Warning: Erase main ASR Flag error\n\r");
	} else {
		MainRet = WriteFlash(pFOTAInfo->FOTA_Addr, (UINT_T)pFOTA_T, AsrFlagLen, BOOT_FLASH);
		if (MainRet != NoError)
			obm_printf("Warning: Write main ASR Flag error\n\r");
	}

#if MMC_CODE
	/* not need erase for mmc */
#else
	BackupRet = EraseFlash(pFOTAInfo->FOTA_Addr + AsrFlagMaxLen, AsrFlagLen, BOOT_FLASH);
#endif
	if (BackupRet != NoError)
	{
		obm_printf("Warning: Erase backup ASR Flag error\n\r");
	} else {
#if MMC_CODE
		BackupRet = WriteFlash(pFOTAInfo->FOTA_Addr + AsrFlagMaxLen/512, (UINT_T)pFOTA_T, AsrFlagLen, BOOT_FLASH);
#else
		BackupRet = WriteFlash(pFOTAInfo->FOTA_Addr + AsrFlagMaxLen, (UINT_T)pFOTA_T, AsrFlagLen, BOOT_FLASH);
#endif
		if (BackupRet != NoError)
			obm_printf("Warning: Write backup ASR Flag error\n\r");
	}

	SetUseSpareArea( FALSE, BOOT_FLASH );
	UpdateBBT();

	#if SPI_CODE
	SPINOR_Disable4BytesMode();
	#endif

	#if OLED_SUPPORT || LED_DISPLAY
	Firmware_Upgrade_Done();
	#endif

	if (MainRet && BackupRet) {
		/* Both main and backup ASR flag are not saved */
		return ASRFlagSaveError;
	}

	return NoError;
}


void OTA_SetDefault_Config(P_FOTA_Firmware pFOTA_T, UINT_T Header, UINT_T MaxLen)
{

	memset((void *)pFOTA_T, 0x00, sizeof(FOTA_Firmware));

	pFOTA_T->nocp[0] = NOCPID;
	pFOTA_T->nocp[1] = 0;
	pFOTA_T->TrustBootStatus = TB_NO_ERROR;

#if NEZHA701||NEZHA702||FALCON401
	/* Set default value of ASR Flags. */
	pFOTA_T->Production_Mode_Flag = 1;
#else
	pFOTA_T->Production_Mode_Flag = 0;
#endif

	/* PIPE mode flag */
#if NEZHA701||NEZHA305
	pFOTA_T->pipe[0] = PIPEID;
	pFOTA_T->pipe[1] = 1;

	pFOTA_T->imsd[0] = IMSDID;
	pFOTA_T->imsd[1] = 1;

	pFOTA_T->eehP[0] = EEHPID;
	pFOTA_T->eehP[1] = 2;

	pFOTA_T->ramdump[0] = RAMDUMPID;
	pFOTA_T->ramdump[1] = 0;
    
    pFOTA_T->cplog[0] = CPLOGID;
    pFOTA_T->cplog[1] = 0;
#elif NEZHA702
	pFOTA_T->pipe[0] = PIPEID;
	pFOTA_T->pipe[1] = 0;

	pFOTA_T->imsd[0] = IMSDID;
	pFOTA_T->imsd[1] = 0;

	pFOTA_T->eehP[0] = EEHPID;
	pFOTA_T->eehP[1] = 2;

	pFOTA_T->ramdump[0] = RAMDUMPID;
	pFOTA_T->ramdump[1] = 0;
    
    pFOTA_T->cplog[0] = CPLOGID;
    pFOTA_T->cplog[1] = 0;
#else
	pFOTA_T->pipe[0] = PIPEID;
	pFOTA_T->pipe[1] = 0;
	
	// Add by liubin for Open IMSD by default.
	pFOTA_T->imsd[0] = IMSDID;
	pFOTA_T->imsd[1] = 1;

	pFOTA_T->eehP[0] = EEHPID;
	pFOTA_T->eehP[1] = 2;

	pFOTA_T->ramdump[0] = RAMDUMPID;
	pFOTA_T->ramdump[1] = 0;
    
    pFOTA_T->cplog[0] = CPLOGID;
    pFOTA_T->cplog[1] = 1;
#endif

	/* OBM enum USB port flag */
	pFOTA_T->obmdl[0] = OBMDLID;
	pFOTA_T->obmdl[1] = OBMNOUSB;

	/* OBM download flag */
	pFOTA_T->dlflag[0] = DLFLG;
	pFOTA_T->dlflag[1] = DLDONE;

	pFOTA_T->DDR_ID = GetDDR_PID();
	pFOTA_T->Flash_ID = GetFlash_PID(); 

	pFOTA_T->Header = Header;
	pFOTA_T->RefCounter = 0;
	pFOTA_T->FlagLen = MaxLen;
	pFOTA_T->Version = ASRFLAG_VERSION;

	return;
}

UINT_T ASRFlag_TrustBootStatus_Update(pTIM pTIM_h, UINT_T para)
{
	#if TRUSTED
	UINT_T Retval;
	P_FOTA_Info pFOTAInfo = &FOTAInfo;
	P_FOTA_Firmware pFOTA_T = OTAGetConfig(pTIM_h);

	if (!pFOTA_T)
		return NotFoundError;

	switch(para)
	{
		case DTIM_PRIMARY:
			pFOTA_T->TrustBootStatus = TB_DTIM_PRIMARY_ERROR;
			break;
		case DTIM_RECOVERY:
			pFOTA_T->TrustBootStatus = TB_DTIM_RECOVERY_ERROR;
			break;
		case DTIM_PPSETTING:
			pFOTA_T->TrustBootStatus = TB_DTIM_PPSETTING_ERROR;
			break;
		case TZSWIDENTIFIER:
			pFOTA_T->TrustBootStatus = TB_TOS_ERROR;
			break;
		case OSLOADERID:
		case OSL2ADERID:
			pFOTA_T->TrustBootStatus = TB_UBOOT_ERROR;
			break;
		case SDTIM:
			pFOTA_T->TrustBootStatus = TB_SDTIM_ERROR;
			break;
		default:
			pFOTA_T->TrustBootStatus = para;
			break;
	}

	Retval = OTA_Save_Config(pTIM_h);
	if (Retval != NoError)
	{
		obm_printf("OTA_Save_Config: 0x%x\n\r", Retval);
		return Retval;
	}

	if((pFOTA_T->TrustBootStatus != 0) && (pFOTA_T->TrustBootStatus != -1)) {
		err_msg("Reboot due to trusted boot error: %d\n\r", pFOTA_T->TrustBootStatus);
		do_wdt_reset(); // reset after download as default
		//while(1);
	}
	#endif

	return Retval;
}

UINT_T ASRFlag_DLStatus_Update(pTIM pTIM_h, UINT_T dlflag0, UINT_T dlflag1)
{
	UINT_T Retval = NoError;
	P_FOTA_Firmware pFOTA_T = NULL;

	pFOTA_T = OTAGetConfig(pTIM_h);

	/* OBM download flag */
	if (pFOTA_T) {
		pFOTA_T->dlflag[0] = dlflag0;
		pFOTA_T->dlflag[1] = dlflag1;

		Retval = OTA_Save_Config(pTIM_h);
		if (Retval != NoError)
		{
			obm_printf("%s error\n\r", __FUNCTION__);
		}
	}

	return Retval;
}

INT ASRFlag_InProductionMode(pTIM pTIM_h)
{
	P_FOTA_Firmware pFOTA_T = NULL;
	pFOTA_T = OTAGetConfig(pTIM_h);
	if(pFOTA_T) {
		if(pFOTA_T->Production_Mode_Flag == PRODUCT_USB_MODE || 
			pFOTA_T->Production_Mode_Flag == PRODUCT_UART_MODE)

		return 1;
	}

	return 0;
}

VOID ASRFlag_Update_DdrFlashId(pTIM pTIM_h, UINT_T DDR_PID, UINT_T Flash_PID)
{
	UINT_T Retval = NoError;
	P_FOTA_Firmware pFOTA_T = NULL;

	if(pFOTA_T->DDR_ID == DDR_PID && pFOTA_T->Flash_ID == Flash_PID)
		return;

	pFOTA_T = OTAGetConfig(pTIM_h);

	if ( pFOTA_T &&
		(pFOTA_T->DDR_ID != DDR_PID || pFOTA_T->Flash_ID != Flash_PID) ) 
	{
		pFOTA_T->DDR_ID = DDR_PID;
		pFOTA_T->Flash_ID = Flash_PID;

		Retval = OTA_Save_Config(pTIM_h);
		if (Retval != NoError)
		{
			obm_printf("%s error\n\r", __FUNCTION__);
			return;
		}
	}

	return;
}

BOOL ASRFlag_NeedRunDDRT(pTIM pTIM_h)
{
	UINT_T Retval = NoError;
	P_FOTA_Firmware pFOTA_T = NULL;

	pFOTA_T = OTAGetConfig(pTIM_h);

	if ( pFOTA_T && pFOTA_T->ddrt_state.bits.test_proc) 
	{
		return TRUE;
			
	}

	return FALSE;
}