Rigel/ec718
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ec718/ec_fullsdk/PLAT/middleware/thirdparty/lzma2201/C/wrapper/LzmaEc.c

858 lines
34 KiB
C
Raw Normal View History

init
2025-04-10 17:31:33 +08:00
/* LzmaUtil.c -- Test application for LZMA compression
2021-11-01 : Igor Pavlov : Public domain */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "7zAlloc.h"
#include "7zFile.h"
#include "LzFind.h"
#include "LzmaEnc.h"
#include "LzmaDec.h"
#include "LzmaEc.h"
#include "mem_map.h"
#ifdef CORE_IS_CP
#include "shareinfo.h"
#endif
#ifdef CORE_IS_AP
#include "tls.h"
#include "apmu_external.h"
#endif
extern UINT32 flashXIPLimit;
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
extern UINT32 _compress_buf_start;
extern UINT32 _decompress_buf_start;
#endif
//LZMA_BSS_SECTION CLzmaDec lzmaState = {0};
//LZMA_BSS_SECTION unsigned int lzmaUnpackSize = 0;
//LZMA_BSS_SECTION unsigned int lzmaUnpackSizeTotal = 0;
//LZMA_BSS_SECTION const ISzAlloc gLzmaEcAlloc = { SzAlloc, SzFree };
LZMA_BSS_SECTION ecCompBinSectionInfo *pCompBinSectionInfoAddr = NULL;
LZMA_BSS_SECTION ecCompBinHeader compBinHeader = {0};
LZMA_BSS_SECTION unsigned int hashBuffStartAddr = 0;
LZMA_BSS_SECTION unsigned int decompBuffStartAddr = 0;
LZMA_BSS_SECTION unsigned int decompBuffEndAddr = 0;
//LZMA_BSS_SECTION unsigned int decompDataTotalLen = 0;
LZMA_BSS_SECTION char *lzmaBootInputDataBase = NULL;
LZMA_BSS_SECTION char *lzmaBootInputDataCurr = NULL;
LZMA_BSS_SECTION int lzmaBootInputDataLen = 0;
LZMA_BSS_SECTION char *lzmaBootOutputDataBase = NULL;
LZMA_BSS_SECTION char *lzmaBootOutputDataCurr = NULL;
LZMA_BSS_SECTION int lzmaBootOutputDataLen = 0;
LZMA_BSS_SECTION char *lzmaBootBuffBase = NULL;
#ifdef CORE_IS_AP
LZMA_BSS_SECTION volatile char lzmaHashOut[APCP_HASH_OUT_MAX_LEN] = {0};
LZMA_BSS_SECTION volatile apCompExecRet apCompExecuteRet = {0};
#endif
#ifdef CORE_IS_CP
LZMA_BSS_SECTION volatile cpCompExecRet cpCompExecuteRet = {0};
#endif
typedef int (*lzmaDecDecodeToBuf)(CLzmaDec *, Byte *, SizeT *, const Byte *, SizeT *, ELzmaFinishMode, ELzmaStatus *);
#ifdef CORE_IS_AP
extern void sctInitLzma();
extern void sctDeInitLzma();
extern int32_t shaUpdateLzma(shaType_e shaMode, uint32_t srcAddr, uint32_t dstAddr, uint32_t length, uint32_t lastFlag);
extern int32_t dbusCacheForceOff( BOOL isForceOff );
extern uint32_t ShareInfoAPGetCPFlashXIPLimit(void);
#endif
PLAT_BL_UNCOMP_FLASH_TEXT SRes lzmaDecodeEcExc(CLzmaDec *state, unsigned char *outStream, unsigned int *outStreamLen, unsigned char *inDataStream, unsigned int inDataStreamLen, unsigned int unpackSize)
{
int thereIsSize = (unpackSize != (UInt64)(Int64)-1);
//Byte inBuf[IN_BUF_SIZE];
//Byte outBuf[OUT_BUF_SIZE];
unsigned char *inBuf = inDataStream;
unsigned char *outBuf = outStream;
size_t inPos = 0, inSize = 0, outPos = 0;
SRes res;
SizeT outProcessedBefore = DECOMPRESS_DATA_LEN_ONCE;
SizeT outProcessedAfter = 0;
SizeT inProcessedBefore = 0;
SizeT inProcessedAfter = 0;
ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
ELzmaStatus status;
//LzmaDec_Init(state);
for (;;)
{
if (inPos == inSize)
{
inSize = inDataStreamLen;
//RINOK(inStream->Read(inStream, inBuf, &inSize));
inPos = 0;
}
{
//SRes res;
inProcessedBefore = inSize - inPos;
inProcessedAfter = inSize - inPos;
outProcessedBefore = DECOMPRESS_DATA_LEN_ONCE;
finishMode = LZMA_FINISH_ANY;
if (thereIsSize && outProcessedBefore > unpackSize)
{
outProcessedBefore = (SizeT)unpackSize;
finishMode = LZMA_FINISH_END;
}
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
res = LzmaDec_DecodeToBuf(state, outBuf + outPos, &outProcessedBefore,
inBuf + inPos, &inProcessedAfter, finishMode, &status);
#else
#ifdef CORE_IS_AP
lzmaDecDecodeToBuf lzmaDecDecodeToBufPtr = (lzmaDecDecodeToBuf)(*(int *)(CP_FLASH_LOAD_ADDR + CP_LZMA_DEC_API_INDEX*4));
res = (*lzmaDecDecodeToBufPtr)(state, outBuf + outPos, &outProcessedBefore,
inBuf + inPos, &inProcessedAfter, finishMode, &status);
#endif
#ifdef CORE_IS_CP
res = LzmaDec_DecodeToBuf(state, outBuf + outPos, &outProcessedBefore,
inBuf + inPos, &inProcessedAfter, finishMode, &status);
#endif
#endif
inPos += inProcessedAfter;
outPos += outProcessedBefore;
unpackSize -= outProcessedBefore;
outProcessedAfter = outProcessedAfter + outProcessedBefore;
*outStreamLen = outProcessedAfter;
//if (outStream)
// if (outStream->Write(outStream, outBuf, outPos) != outPos)
// return SZ_ERROR_WRITE;
//outPos = 0;
if (res != SZ_OK || (thereIsSize && unpackSize == 0))
return res;
if (inProcessedAfter == 0 && outProcessedBefore == 0)
{
if (thereIsSize || status != LZMA_STATUS_FINISHED_WITH_MARK)
return SZ_ERROR_DATA;
return res;
}
if(inProcessedAfter == inProcessedBefore)
{
return res;
}
}
}
}
PLAT_BL_UNCOMP_FLASH_TEXT int lzmaDecodeEc(unsigned char *outStream, unsigned int *outStreamLen, unsigned char *inStream, unsigned int inStreamLen, unsigned int dataType, unsigned int *lzmaUnpackLen)
{
int i;
int res = 0;
unsigned char *inDataStream = NULL;
unsigned int inDataStreamLen = 0;
unsigned char *inStreamPtr = inStream;
CLzmaDec lzmaState;
unsigned int lzmaUnpackSize = 0;
ISzAlloc gLzmaEcAlloc = { SzAlloc, SzFree };
/* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
unsigned char header[LZMA_PROPS_SIZE + 8];
if(dataType == 0)
{
/* Read and parse header */
for(i=0; i<sizeof(header); i++)
{
header[i] = *inStreamPtr;
inStreamPtr++;
}
//memcpy(header, inStream, sizeof(header));
inDataStream = inStream + sizeof(header);
inDataStreamLen = inStreamLen - sizeof(header);
lzmaUnpackSize = 0;
for (i = 0; i < 8; i++)
lzmaUnpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);
LzmaDec_Construct(&lzmaState);
RINOK(LzmaDec_Allocate(&lzmaState, header, LZMA_PROPS_SIZE, &gLzmaEcAlloc));
LzmaDec_Init(&lzmaState);
*lzmaUnpackLen = lzmaUnpackSize;//lzmaUnpackSizeTotal total len of decomp data
}
else
{
inDataStream = inStream;
inDataStreamLen = inStreamLen;
}
// param is all right
res = (int)lzmaDecodeEcExc(&lzmaState, outStream, outStreamLen, inDataStream, inDataStreamLen, *lzmaUnpackLen);
//LzmaDec_Free(&state, &g_Alloc);
return res;
}
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
PLAT_BL_UNCOMP_FLASH_TEXT static SRes lzmaEncodeEcExc(ISeqOutStream *outStream, ISeqInStream *inStream, UInt64 fileSize, char *rs)
{
CLzmaEncHandle enc;
SRes res;
CLzmaEncProps props;
ISzAlloc gLzmaEcAlloc = { SzAlloc, SzFree };
enc = LzmaEnc_Create(&gLzmaEcAlloc);
if (enc == 0)
return SZ_ERROR_MEM;
LzmaEncProps_Init(&props);
res = LzmaEnc_SetProps(enc, &props);
if (res == SZ_OK)
{
Byte header[LZMA_PROPS_SIZE + 8];
size_t headerSize = LZMA_PROPS_SIZE;
int i;
res = LzmaEnc_WriteProperties(enc, header, &headerSize);
for (i = 0; i < 8; i++)
header[headerSize++] = (Byte)(fileSize >> (8 * i));
if (outStream->Write(outStream, header, headerSize) != headerSize)
res = SZ_ERROR_WRITE;
else
{
if (res == SZ_OK)
res = LzmaEnc_Encode(enc, outStream, inStream, NULL, &gLzmaEcAlloc, &gLzmaEcAlloc);
}
}
//LzmaEnc_Destroy(enc, &gLzmaEcAlloc, &gLzmaEcAlloc);
return res;
}
PLAT_BL_UNCOMP_FLASH_TEXT int lzmaEncodeEc(unsigned char *outStreamData, unsigned int *outStreamDataLen, unsigned char *inStreamData, unsigned int inStreamDataLen)
{
CFileSeqInStream inStream;
CFileOutStream outStream;
int res;
char rs = 0;
LzFindPrepare();
FileSeqInStream_CreateVTable(&inStream);
File_Construct(&inStream.file);
inStream.wres = 0;
FileOutStream_CreateVTable(&outStream);
File_Construct(&outStream.file);
outStream.wres = 0;
lzmaBootBuffBase = (char *)&_compress_buf_start;
lzmaBootInputDataBase = (char *)inStreamData;
lzmaBootInputDataCurr = (char *)inStreamData;
lzmaBootInputDataLen = inStreamDataLen;
lzmaBootOutputDataBase = (char *)outStreamData;
lzmaBootOutputDataCurr = (char *)outStreamData;
lzmaBootOutputDataLen = *outStreamDataLen;
memset((char *)((uint32_t)lzmaBootBuffBase + LZMA_BOOT_BUFF_HASH_OFFSET), 0, LZMA_BOOT_BUFF_HASH_LEN);
res = lzmaEncodeEcExc(&outStream.vt, &inStream.vt, inStreamDataLen, &rs);
*outStreamDataLen = lzmaBootOutputDataLen;
return res;
}
#endif
/*===========================================================================
* Function: TMU_APTimeRead: time read for AP
* Description: AP latch and read timeType
* Called by: after bcLd Isr
* Calls: none.
* Input: timeType: BC_TYPE_BC_TIME/BC_TYPE_BT_TIME
* Output: ecSysTime *sysTime, OFN included
* History: 2020/06/17 updated by zyfang
*===========================================================================*/
PLAT_BL_UNCOMP_FLASH_TEXT void lzma_APTimeRead(ecSysTime *sysTime, ecBcTimeType timeType)
{
#ifdef CORE_IS_AP
ecTmuBcRd* bcRd = (ecTmuBcRd* )(0x4F070000+0x0070); //APB_GP_PERIPH_BASE HW_TmuBcRd
#endif
#ifdef CORE_IS_CP
ecTmuBcRd* bcRd = (ecTmuBcRd* )(0x5F070000+0x0070); //APB_GP_PERIPH_BASE HW_TmuBcRd
#endif
UINT32 mask;
UINT32 ofnHfnSfnSbn1, ofnHfnSfnSbn2, spn = 0;
mask = SaveAndSetIRQMask();
// CLOCK_clockEnable(PCLK_TMU);
ofnHfnSfnSbn1 = 0;
ofnHfnSfnSbn2 = 0xFFFFFFFF;
if(timeType == EC_BC_TYPE_BC_TIME)
{
while(ofnHfnSfnSbn2 != ofnHfnSfnSbn1)
{
ofnHfnSfnSbn1 = bcRd->dbg_bc_h;
spn = bcRd->dbg_bc_l;
ofnHfnSfnSbn2 = bcRd->dbg_bc_h;
}
}
else if(timeType == EC_BC_TYPE_BT_TIME)
{
bcRd->bt_en = 1;
while(ofnHfnSfnSbn2 != ofnHfnSfnSbn1)
{
ofnHfnSfnSbn1 = bcRd->dbg_bt_h;
spn = bcRd->dbg_bt_l;
ofnHfnSfnSbn2 = bcRd->dbg_bt_h;
}
bcRd->bt_en = 0;
}
sysTime->hfnsfnsbn = ofnHfnSfnSbn1;
sysTime->spn = spn;
// CLOCK_clockDisable(PCLK_TMU);
if(timeType ==EC_BC_TYPE_BT_TIME)
{
// void tcocBTSystickCheck(uint32_t hfnsfnsbn);
// tcocBTSystickCheck(sysTime->hfnsfnsbn);
}
RestoreIRQMask(mask);
}
#define LZMA_DECOMPRESS_EC_WRAPPER_API
#ifdef RAMCODE_COMPRESS_EN
#ifdef CORE_IS_AP
PLAT_BL_UNCOMP_FLASH_TEXT __attribute__((noinline)) void decompressCpRamCodeHashCheck(int ramCodeType)
{
unsigned int *asmbData = NULL;
unsigned int *msmbData = NULL;
unsigned int index = ramCodeType-1;
unsigned int i = 0;
unsigned int length = 0;
unsigned int lengthLeft = 0;
unsigned int RetValue = 0;
unsigned int hashCount = 0;
unsigned int pFlashXIPAddr = 0;
ecSysTime mSysCpTime0;
ecSysTime mSysCpTime1;
UINT32 lzmaCurrCpTime0 = 0;
UINT32 lzmaCurrCpTime1 = 0;
unsigned int decompInfoFlag = 0;
/*
pFlashXIPAddr = ShareInfoAPGetCPFlashXIPLimit();
compBinHeader.magicHdr = *(unsigned int *)pFlashXIPAddr;
compBinHeader.numOfSec = *(unsigned int *)(pFlashXIPAddr+4);
pCompBinSectionInfoAddr = (ecCompBinSectionInfo *)(pFlashXIPAddr+8);
decompBuffStartAddr = up_buf_start;
hashBuffStartAddr = decompBuffStartAddr + CP_HASH_MEM_OFFSET;
*/
pFlashXIPAddr = *(int *)((CP_FLASH_LOAD_SIZE-8)+CP_FLASH_LOAD_ADDR)+CP_FLASH_LOAD_ADDR;
compBinHeader.magicHdr = *(unsigned int *)pFlashXIPAddr;
compBinHeader.numOfSec = *(unsigned int *)(pFlashXIPAddr+4);
pCompBinSectionInfoAddr = (ecCompBinSectionInfo *)(pFlashXIPAddr+8);
lzma_APTimeRead(&mSysCpTime0, EC_BC_TYPE_BC_TIME);
lzmaCurrCpTime0 = (((mSysCpTime0.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysCpTime0.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysCpTime0.hfnsfnsbn & 0xf))*1000 + (mSysCpTime0.spn*1000)/30720; //jing que dao 0.001ms
//lzmaCurrCpTime0 = (((mSysCpTime0.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysCpTime0.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysCpTime0.hfnsfnsbn & 0xf)); //jing que dao ms
//the ramCodeType maybe not be the type which 'compBinSectionInfoPtr[index]' stores
// if(pCompBinSectionInfoAddr[index].type != ramCodeType)
{
for(i=0; i<compBinHeader.numOfSec; i++)
{
if((pCompBinSectionInfoAddr[i].type == ramCodeType)&&(pCompBinSectionInfoAddr[i].ziped == 0x1)&&(pCompBinSectionInfoAddr[i].secFlag == 0x1))
{
index = i;
decompInfoFlag = 0xff;
break;
}
}
}
if(decompInfoFlag != 0xff) //not find section in the bin file
{
return ;
}
/*SHA_TYPE_256*/
if(apmuGetAPBootFlag()==AP_BOOT_FROM_POWER_ON)
{
if(((0 <= index)&&(index < SECTIONCP_HASH_CHECK_MAX_INDEX)) && (pCompBinSectionInfoAddr[index].origLen > 0))
{
sctInitLzma();
for(i=0; i<sizeof(lzmaHashOut);i++)
{
lzmaHashOut[i] = 0;
}
if((APCP_HASH_MSMB_MEM_START_ADDR <= pCompBinSectionInfoAddr[index].origAddr)&&(pCompBinSectionInfoAddr[index].origAddr <= APCP_HASH_MSMB_MEM_END_ADDR ))
{
if(pCompBinSectionInfoAddr[index].origLen <= APCP_HASH_ONCE_MAX_LEN)
{
RetValue = shaUpdateLzma(2, (uint32_t)pCompBinSectionInfoAddr[index].origAddr, (uint32_t)lzmaHashOut, pCompBinSectionInfoAddr[index].origLen, 1);
}
else
{
hashCount = pCompBinSectionInfoAddr[index].origLen/APCP_HASH_ONCE_MAX_LEN;
for(i=0; i<hashCount; i++)
{
RetValue = shaUpdateLzma(2, (uint32_t)(pCompBinSectionInfoAddr[index].origAddr+i*APCP_HASH_ONCE_MAX_LEN), (uint32_t)lzmaHashOut, APCP_HASH_ONCE_MAX_LEN, 0);
}
lengthLeft = pCompBinSectionInfoAddr[index].origLen%APCP_HASH_ONCE_MAX_LEN;
RetValue = shaUpdateLzma(2, (uint32_t)(pCompBinSectionInfoAddr[index].origAddr+hashCount*APCP_HASH_ONCE_MAX_LEN), (uint32_t)lzmaHashOut, lengthLeft, 1);
}
}
else
{
length = pCompBinSectionInfoAddr[index].origLen;
if(length <= CP_HASH_MEM_LEN)
{
length /= sizeof(unsigned int);
asmbData = (unsigned int *)pCompBinSectionInfoAddr[index].origAddr + CP_RAM_BASE_ADDR;
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, pCompBinSectionInfoAddr[index].origLen, 1);
}
else
{
hashCount = pCompBinSectionInfoAddr[index].origLen/CP_HASH_MEM_LEN;
for(i=0; i<hashCount; i++)
{
length = CP_HASH_MEM_LEN/sizeof(unsigned int);
asmbData = (unsigned int *)(pCompBinSectionInfoAddr[index].origAddr + CP_RAM_BASE_ADDR + i*CP_HASH_MEM_LEN);
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, CP_HASH_MEM_LEN, 0);
}
lengthLeft = pCompBinSectionInfoAddr[index].origLen%CP_HASH_MEM_LEN;
length = lengthLeft/sizeof(unsigned int);
asmbData = (unsigned int *)(pCompBinSectionInfoAddr[index].origAddr + CP_RAM_BASE_ADDR + hashCount*CP_HASH_MEM_LEN);
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, lengthLeft, 1);
}
}
for(i=0; i<APCP_HASH_OUT_MAX_LEN; i++)
{
if(lzmaHashOut[i] != pCompBinSectionInfoAddr[index].hash[i])
{
apCompExecuteRet.cpDecompHashRet[index] = 0xCDE00001;
__asm volatile("movw r12, #0xecaa");
__asm volatile("movt r12, #0xecaa");
__asm volatile("str r12, [r12]");
break;
}
}
sctDeInitLzma();
}
}
apCompExecuteRet.cpDecompHashRet[index] = RetValue;
lzma_APTimeRead(&mSysCpTime1, EC_BC_TYPE_BC_TIME);
lzmaCurrCpTime1 = (((mSysCpTime1.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysCpTime1.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysCpTime1.hfnsfnsbn & 0xf))*1000 + (mSysCpTime1.spn*1000)/30720; //jing que dao 0.001ms
//lzmaCurrCpTime0 = (((mSysCpTime1.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysCpTime1.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysCpTime1.hfnsfnsbn & 0xf)); //jing que dao ms
apCompExecuteRet.cpDecompHashTimeRet[index] = lzmaCurrCpTime1-lzmaCurrCpTime0;
}
#endif
#endif
PLAT_BL_UNCOMP_FLASH_TEXT void decompressGetAddrInfo(void)
{
unsigned int pFlashXIPAddr = 0;
#ifdef CORE_IS_AP
pFlashXIPAddr = *(int *)((AP_FLASH_LOAD_SIZE-8)+AP_FLASH_LOAD_ADDR)+AP_FLASH_LOAD_ADDR;
#endif
#ifdef CORE_IS_CP
pFlashXIPAddr = *(int *)((CP_FLASH_LOAD_SIZE-8)+CP_FLASH_LOAD_ADDR)+CP_FLASH_LOAD_ADDR;
#endif
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
pFlashXIPAddr = *(int *)((BOOTLOADER_FLASH_LOAD_SIZE-8)+BOOTLOADER_FLASH_LOAD_ADDR)+BOOTLOADER_FLASH_LOAD_ADDR;
#endif
compBinHeader.magicHdr = *(unsigned int *)pFlashXIPAddr;
compBinHeader.numOfSec = *(unsigned int *)(pFlashXIPAddr+4);
pCompBinSectionInfoAddr = (ecCompBinSectionInfo *)(pFlashXIPAddr+8);
#ifdef TYPE_EC718M
#if (defined CORE_IS_AP) && !(defined FEATURE_BOOTLOADER_PROJECT_ENABLE)
extern void *psDialGetUpMemAndSize(UINT32 *pUpMemSize);
decompBuffStartAddr = (uint32_t)psDialGetUpMemAndSize(NULL);
decompBuffEndAddr = decompBuffStartAddr + AP_DECOMP_MEM_RF_CALIB_MAX_LEN;
hashBuffStartAddr = decompBuffStartAddr + AP_HASH_MEM_OFFSET;
#endif
#else
#ifdef CORE_IS_AP
decompBuffStartAddr = up_buf_start;
decompBuffEndAddr = decompBuffStartAddr + AP_DECOMP_MEM_RF_CALIB_MAX_LEN;
hashBuffStartAddr = decompBuffStartAddr + AP_HASH_MEM_OFFSET;
#endif
#endif
#ifdef CORE_IS_CP
decompBuffStartAddr = ShareInfoCPGetCpdprsBufAddr();
decompBuffEndAddr = decompBuffStartAddr + CP_DECOMP_MEM_RF_CALIB_MAX_LEN;
hashBuffStartAddr = decompBuffStartAddr + CP_HASH_MEM_OFFSET;
#endif
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
decompBuffStartAddr = (unsigned int)&_decompress_buf_start;
decompBuffEndAddr = decompBuffStartAddr + AP_DECOMP_MEM_RF_CALIB_MAX_LEN;
hashBuffStartAddr = decompBuffStartAddr + AP_HASH_MEM_OFFSET;
#endif
}
PLAT_BL_UNCOMP_FLASH_TEXT void decompressRamCodeGetAddrInfo(void)
{
decompressGetAddrInfo();
}
#ifdef RAMCODE_COMPRESS_EN
PLAT_BL_UNCOMP_FLASH_TEXT void decompressRamCodeFromBin(int ramCodeType)
{
unsigned int *origData = NULL;
unsigned int *flashData = NULL;
unsigned char *compData = NULL;
unsigned int index = ramCodeType-1;
unsigned int i = 0;
unsigned int k = 0;
unsigned int length = 0;
unsigned int lzmaDecompDataTotalLen = 0;
unsigned int lzmaDecompDataLen = 0;
unsigned int lzmaCompDataLeft = 0;
unsigned int lzmaDecompMaxCount = 0;
unsigned int decompDataTotalLen = 0;
int res = 0;
ecSysTime mSysTime0;
UINT32 lzmaCurrTime0 = 0;
ecSysTime mSysTime1;
UINT32 lzmaCurrTime1 = 0;
#ifdef CORE_IS_AP
ecSysTime mSysTime2;
UINT32 lzmaCurrTime2 = 0;
unsigned int RetValue = 0;
unsigned int hashCount = 0;
unsigned int *asmbData = NULL;
unsigned int *msmbData = NULL;
unsigned int lengthLeft = 0;
#endif
unsigned int decompInfoFlag = 0;
#ifdef CORE_IS_AP
#ifndef FEATURE_BOOTLOADER_PROJECT_ENABLE
//index must >0, because dbusCacheForceOff is decompressed in index0
if(index > 0)
{
dbusCacheForceOff(FALSE);
}
#endif
#endif
//the ramCodeType maybe not be the type which 'compBinSectionInfoPtr[index]' stores
{
for(i=0; i<compBinHeader.numOfSec; i++)
{
if(pCompBinSectionInfoAddr[i].type == ramCodeType)
{
index = i;
decompInfoFlag = 0xff;
break;
}
}
}
if(decompInfoFlag != 0xff) //not find section in the bin file
{
#ifdef CORE_IS_AP
#ifndef FEATURE_BOOTLOADER_PROJECT_ENABLE
//index must >0, because dbusCacheForceOff is decompressed in index0
if(index > 0)
{
dbusCacheForceOff(TRUE);
}
#endif
#endif
return ;
}
lzma_APTimeRead(&mSysTime0, EC_BC_TYPE_BC_TIME);
lzmaCurrTime0 = (((mSysTime0.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime0.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime0.hfnsfnsbn & 0xf))*1000 + (mSysTime0.spn*1000)/30720; //jing que dao 0.001ms
//lzmaCurrTime0 = (((mSysTime0.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime0.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime0.hfnsfnsbn & 0xf)); //jing que dao ms
if((pCompBinSectionInfoAddr[index].ziped == 0x1)&&(pCompBinSectionInfoAddr[index].compressedLen > 0))
{
if(pCompBinSectionInfoAddr[index].compressedLen <= DECOMPRESS_DATA_LEN_ONCE)
{
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + BOOTLOADER_FLASH_LOAD_ADDR);
#else
#ifdef CORE_IS_AP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + AP_FLASH_LOAD_ADDR);
#endif
#ifdef CORE_IS_CP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + CP_FLASH_LOAD_ADDR);
#endif
#endif
lzmaDecompDataLen = DECOMPRESS_DATA_LEN_ONCE;
res = lzmaDecodeEc((unsigned char *)pCompBinSectionInfoAddr[index].origAddr, &lzmaDecompDataLen, (unsigned char *)compData, pCompBinSectionInfoAddr[index].compressedLen, DECOMPRESS_DATA_TYPE_HEADER, &lzmaDecompDataTotalLen);
}
else
{
lzmaDecompMaxCount = pCompBinSectionInfoAddr[index].compressedLen/DECOMPRESS_DATA_LEN_ONCE;
lzmaCompDataLeft = pCompBinSectionInfoAddr[index].compressedLen%DECOMPRESS_DATA_LEN_ONCE;
decompDataTotalLen = 0;
for(k=0; k<lzmaDecompMaxCount; k++)
{
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + BOOTLOADER_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#else
#ifdef CORE_IS_AP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + AP_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#endif
#ifdef CORE_IS_CP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + CP_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#endif
#endif
lzmaDecompDataLen = DECOMPRESS_DATA_LEN_ONCE;
if(k == 0)
{
res = lzmaDecodeEc((unsigned char *)pCompBinSectionInfoAddr[index].origAddr, &lzmaDecompDataLen, (unsigned char *)compData, DECOMPRESS_DATA_LEN_ONCE, DECOMPRESS_DATA_TYPE_HEADER, &lzmaDecompDataTotalLen);
decompDataTotalLen = decompDataTotalLen+lzmaDecompDataLen;
}
else
{
lzmaDecompDataTotalLen = lzmaDecompDataTotalLen - k*DECOMPRESS_DATA_LEN_ONCE;
res = lzmaDecodeEc((unsigned char *)(pCompBinSectionInfoAddr[index].origAddr+decompDataTotalLen), &lzmaDecompDataLen, (unsigned char *)compData, DECOMPRESS_DATA_LEN_ONCE, DECOMPRESS_DATA_TYPE_TRUNK, &lzmaDecompDataTotalLen);
decompDataTotalLen = decompDataTotalLen+lzmaDecompDataLen;
}
}
if(lzmaCompDataLeft > 0)
{
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + BOOTLOADER_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#else
#ifdef CORE_IS_AP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + AP_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#endif
#ifdef CORE_IS_CP
compData = (unsigned char *)(pCompBinSectionInfoAddr[index].compressedAddr + CP_FLASH_LOAD_ADDR + k*DECOMPRESS_DATA_LEN_ONCE);
#endif
#endif
lzmaDecompDataLen = DECOMPRESS_DATA_LEN_ONCE;
lzmaDecompDataTotalLen = lzmaDecompDataTotalLen - lzmaDecompMaxCount*DECOMPRESS_DATA_LEN_ONCE;
res = lzmaDecodeEc((unsigned char *)(pCompBinSectionInfoAddr[index].origAddr+decompDataTotalLen), &lzmaDecompDataLen, (unsigned char *)compData, lzmaCompDataLeft, DECOMPRESS_DATA_TYPE_TRUNK, &lzmaDecompDataTotalLen);
}
}
}
else
{
// origData and flashData should be 4 byte aligned generated by fcelf
// length is 4 byte aligned defined in LD
if(pCompBinSectionInfoAddr[index].origLen > 0)
{
length = pCompBinSectionInfoAddr[index].origLen;
length /= sizeof(unsigned int);
origData = (unsigned int *)pCompBinSectionInfoAddr[index].origAddr;
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
flashData = (unsigned int *)(pCompBinSectionInfoAddr[index].compressedAddr + BOOTLOADER_FLASH_LOAD_ADDR);
#else
#ifdef CORE_IS_AP
flashData = (unsigned int *)(pCompBinSectionInfoAddr[index].compressedAddr + AP_FLASH_LOAD_ADDR);
#endif
#ifdef CORE_IS_CP
flashData = (unsigned int *)(pCompBinSectionInfoAddr[index].compressedAddr + CP_FLASH_LOAD_ADDR);
#endif
#endif
if(origData != flashData)
{
while(length > 0)
{
origData[length-1] = flashData[length-1];
length--;
}
}
}
}
#ifdef CORE_IS_AP
apCompExecuteRet.apDecompRet[index] = res;
#endif
#ifdef CORE_IS_CP
cpCompExecuteRet.cpDecompRet[index] = res;
#endif
#ifdef CORE_IS_AP
#ifndef FEATURE_BOOTLOADER_PROJECT_ENABLE
if(index > 0)
{
dbusCacheForceOff(TRUE);
}
#endif
#endif
lzma_APTimeRead(&mSysTime1, EC_BC_TYPE_BC_TIME);
lzmaCurrTime1 = (((mSysTime1.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime1.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime1.hfnsfnsbn & 0xf))*1000 + (mSysTime1.spn*1000)/30720; //jing que dao 0.001ms
//lzmaCurrTime1 = (((mSysTime1.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime1.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime1.hfnsfnsbn & 0xf)); //jing que dao ms
#ifdef CORE_IS_AP
apCompExecuteRet.apDecompTimeRet[index] = lzmaCurrTime1-lzmaCurrTime0;
#endif
#ifdef CORE_IS_CP
cpCompExecuteRet.cpDecompTimeRet[index] = lzmaCurrTime1-lzmaCurrTime0;
#endif
#if 1
#ifdef CORE_IS_AP
/*for AP, after decompressing ram code, hash check will be done.
for CP, the hash check is done with decompressCpRamCodeHashCheck()*/
/*SHA_TYPE_256*/
#ifdef FEATURE_BOOTLOADER_PROJECT_ENABLE
if(((*(uint32_t *)0x4f0201A0)&0xe0) <= 0)
#else
if(apmuGetAPBootFlag() == AP_BOOT_FROM_POWER_ON)
#endif
{
if(((0 <= index)&&(index < SECTIONAP_HASH_CHECK_MAX_INDEX)) && (pCompBinSectionInfoAddr[index].origLen > 0))
{
sctInitLzma();
for(i=0; i<sizeof(lzmaHashOut);i++)
{
lzmaHashOut[i] = 0;
}
if((APCP_HASH_MSMB_MEM_START_ADDR <= pCompBinSectionInfoAddr[index].origAddr)&&(pCompBinSectionInfoAddr[index].origAddr <= APCP_HASH_MSMB_MEM_END_ADDR ))
{
if(pCompBinSectionInfoAddr[index].origLen <= APCP_HASH_ONCE_MAX_LEN)
{
RetValue = shaUpdateLzma(2, (uint32_t)pCompBinSectionInfoAddr[index].origAddr, (uint32_t)lzmaHashOut, pCompBinSectionInfoAddr[index].origLen, 1);
}
else
{
hashCount = pCompBinSectionInfoAddr[index].origLen/APCP_HASH_ONCE_MAX_LEN;
for(i=0; i<hashCount; i++)
{
RetValue = shaUpdateLzma(2, (uint32_t)(pCompBinSectionInfoAddr[index].origAddr+i*APCP_HASH_ONCE_MAX_LEN), (uint32_t)lzmaHashOut, APCP_HASH_ONCE_MAX_LEN, 0);
}
lengthLeft = pCompBinSectionInfoAddr[index].origLen%APCP_HASH_ONCE_MAX_LEN;
RetValue = shaUpdateLzma(2, (uint32_t)(pCompBinSectionInfoAddr[index].origAddr+hashCount*APCP_HASH_ONCE_MAX_LEN), (uint32_t)lzmaHashOut, lengthLeft, 1);
}
}
else
{
length = pCompBinSectionInfoAddr[index].origLen;//0x10000;
if(length <= AP_HASH_MEM_LEN)
{
length /= sizeof(unsigned int);
asmbData = (unsigned int *)pCompBinSectionInfoAddr[index].origAddr;
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, pCompBinSectionInfoAddr[index].origLen, 1);
}
else
{
hashCount = pCompBinSectionInfoAddr[index].origLen/AP_HASH_MEM_LEN;
for(i=0; i<hashCount; i++)
{
length = AP_HASH_MEM_LEN/sizeof(unsigned int);
asmbData = (unsigned int *)(pCompBinSectionInfoAddr[index].origAddr + i*AP_HASH_MEM_LEN);
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, AP_HASH_MEM_LEN, 0);
}
lengthLeft = pCompBinSectionInfoAddr[index].origLen%AP_HASH_MEM_LEN;
length = lengthLeft/sizeof(unsigned int);
asmbData = (unsigned int *)(pCompBinSectionInfoAddr[index].origAddr + hashCount*AP_HASH_MEM_LEN);
msmbData = (unsigned int *)hashBuffStartAddr;
while(length > 0)
{
msmbData[length-1] = asmbData[length-1];
length--;
}
RetValue = shaUpdateLzma(2, (uint32_t)msmbData, (uint32_t)lzmaHashOut, lengthLeft, 1);
}
}
for(i=0; i<APCP_HASH_OUT_MAX_LEN; i++)
{
if(lzmaHashOut[i] != pCompBinSectionInfoAddr[index].hash[i])
{
apCompExecuteRet.apDecompHashRet[index] = 0xADE00001;
__asm volatile("movw r12, #0xecad");
__asm volatile("movt r12, #0xecad");
__asm volatile("str r12, [r12]");
break;
}
}
sctDeInitLzma();
}
}
lzma_APTimeRead(&mSysTime2, EC_BC_TYPE_BC_TIME);
lzmaCurrTime2 = (((mSysTime2.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime2.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime2.hfnsfnsbn & 0xf))*1000 + (mSysTime2.spn*1000)/30720; //jing que dao 0.001ms
//lzmaCurrTime1 = (((mSysTime2.hfnsfnsbn >> 14)&0x3FF)*10240 + ((mSysTime2.hfnsfnsbn >> 4)&0x3FF)*10 + (mSysTime2.hfnsfnsbn & 0xf)); //jing que dao ms
apCompExecuteRet.apDecompHashTimeRet[index] = lzmaCurrTime2-lzmaCurrTime1;
apCompExecuteRet.apDecompHashRet[index] = RetValue;
#endif
#endif
}
#endif
Reference in New Issue Copy Permalink