//---------------------------------------------------------------------------
#include "generateBin.h"
#include "generateSave.h"
#include "generateOutput.h"
#include "drv_spi_sfs.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

#ifdef CONFIG_DISABLE_CIKEY_HDCPKEY_SPI_ENCRYPT
#define HDCP_KEY_SIZE  (588)
#define HDCP2X_KEY_SIZE  (588)
#define CIPLUS_KEY_DATA_SIZE  (10240)
extern void do_spi_decrypt(char *, unsigned int, unsigned int);
#endif
//---------------------------------------------------------------------------
extern bool copyFileToMemory( u8 *memOut, const char *fileName, int maxSize );
extern void writeToFlashTempFile( const char *fileName, u8 *memOut, u32 memSize );
extern bool checkFileNameExtension( const char *fileName, const char *wildcard );
extern int BMP2Bin(char *szFileIn, char *szFileOut);
extern int JPG2Bin( const char *szFileIn, const char *szFileOut );
extern int ini2binmem(char* pInFile, char *pOutData, int nBufSize);
extern int syscmd( const char * format, ... );

//---------------------------------------------------------------------------

#if 0
static inline bool generateFlashTempFile()
{
	int i;
	for( i = 0; i < MODULE_MAX; i++ )
	{
		if( !flashModuleInfo[i].isValid  ) continue;
		if( !mergeToBinCrossFlash( &flashModuleInfo[i] ) ) return false;
	}

	if( !mergeToBin_GenerateOption() ) return false;
	if( !mergeToBin_GenerateUMFDefaultSetting() ) return false;
#if 0//gaia, remove featrue 2013.04.23
	if( !mergeToBin_Backup64K() ) return false;
	if( !mergeToBin_BackupRRT() ) return false;
#endif
	return true;
}
#endif

static unsigned int get_lzma_uncompressed_size(char *bin_name)
{
    int i, fd, ret;
    unsigned int unpack_size;
    unsigned char tmp_buf[64];
    unsigned char offset = 0;
	 
    fd = open(bin_name,O_RDONLY);
    if (fd < 0)
        return 0;
    ret = read(fd, tmp_buf, 64);
    if (ret <= 0) {
        close(fd);
        return 0;
    } else {   
        close(fd);
    }
    
    unpack_size = 0;

#ifdef CONFIG_SUPPORT_PROJECT_ID
    /* the header format is: the size of whole panel bin(2bytes) |Reserved byte(1Byte)| panel id(1byte) | Panel Name(38Bytes) | real data of panel bin(rest bytes) */
    /* for GammaTable, VIPTable, CLUTTable, there will be 42 bytes header */
    #define HEADER_SIZE (42)
    char *p = strrchr(bin_name, '/');
    if (p != NULL && (!strncmp(p+1, "GAMMATABLE.bin", strlen(p+1))
        || !strncmp(p+1, "VIPTABLE.bin", strlen(p+1))
        || !strncmp(p+1, "COLORLUT.bin", strlen(p+1))))
    {
        offset = HEADER_SIZE;
    }
#endif
    for (i = 0;i < 8; i++) {
        unpack_size += (tmp_buf[5+i+offset]<<(i*8));
    }

    return unpack_size; 
}

static unsigned int get_table_shaodw_size(char *pattern_str)
{
    char pattern_buf[128];
    char cmd_buf[128];
    FILE *pfile;
    char *ref_file;
    char *ref_file1 = "../boot/include/rom_def.h";
    char *ref_file2 = "../drivers/module_include/drv_spi_flashalloc_internal.h";

    if (!strcmp(pattern_str,"SPI_Custable_ShadowSize"))
        ref_file = ref_file2;
    else
        ref_file = ref_file1;
    memset(pattern_buf, 0, 128);
    memset(cmd_buf, 0, 128);
    sprintf(cmd_buf,"sed -n 's/#define\\s\\+%s\\s\\+\\(\\S\\+\\)/\\1/p' %s",pattern_str,ref_file);
    pfile = popen(cmd_buf, "r");
    if (fgets(pattern_buf, 128, pfile) != NULL) {
        pclose(pfile);
    } else {
        return 0;
    }
    sprintf(cmd_buf,"python -c 'print %s'",pattern_buf);
    pfile = popen(cmd_buf, "r");
    memset(pattern_buf, 0 ,128);
    if (fgets(pattern_buf, 128, pfile) != NULL) {
        pclose(pfile);
        return (unsigned int)atoi(pattern_buf);
    } else {
        return 0;
    }
     
}

static void __check_table_shaodw_size(char *bin_name, char *pattern_str)
{
    unsigned int unpack_size;
    unsigned int shaodw_size;
    char *ref_file;
    char *ref_file1 = "boot/include/rom_def.h";
    char *ref_file2 = "drivers/module_include/drv_spi_flashalloc_internal.h";

    if (!strcmp(pattern_str,"SPI_Custable_ShadowSize"))
        ref_file = ref_file2;
    else
        ref_file = ref_file1;
    
    shaodw_size = get_table_shaodw_size(pattern_str);
    unpack_size = get_lzma_uncompressed_size(bin_name);
    if ( shaodw_size < unpack_size) {
        printf("\033[31;43m%s error!(real:%d shaodw:%d)\nPlease modify %s\n#define %s\033[0m\n",pattern_str,unpack_size,shaodw_size, ref_file, pattern_str);
        exit(-1);
    }
}

void check_table_shaodw_size(void)
{
    int i;

    for (i=0; i < MODULE_MAX; i++) {
        if (!strncmp(flashModuleInfo[i].moduleName, "Custable", TAG_LENGTH)) {
            __check_table_shaodw_size(flashModuleInfo[i].tmpBinName, "SPI_Custable_ShadowSize");
        }
        if (!strncmp(flashModuleInfo[i].moduleName, "GammaTable", TAG_LENGTH)) {
            __check_table_shaodw_size(flashModuleInfo[i].tmpBinName, "GammaTable_ShaodwSize");
        }
        if (!strncmp(flashModuleInfo[i].moduleName, "VIPTable", TAG_LENGTH)) {
            __check_table_shaodw_size(flashModuleInfo[i].tmpBinName, "VipTable_ShadowSize");
        }
        if (!strncmp(flashModuleInfo[i].moduleName, "CLUPTable", TAG_LENGTH)) {
            __check_table_shaodw_size(flashModuleInfo[i].tmpBinName, "ColorLUTTable_ShaodwSize");
        }
    }
}

static inline bool generateEncryptFlashBin( const char *tmp, const char *final )
{
	if( sisspi_encrypt( tmp, final, true ) )
	{
		errMsg( "encrypt failed\n"); return false;
	}

	return true;
}
static bool generateFinalFlashBin( const char *tmp, const char *final, const char *save )
{
	bool ret = true;
	dbgMsg( "[generateFinalFlashBin] %s (%c)\n", final, MI_ENCRYPT_FLASH_BIN ? 'e' : 'd' );

	ret = generateEncryptFlashBin( tmp, FILENAME_ENCRYPTTMP );
#if 0
	if( miGenerateOriginalBinFlag ) copyToOutputFolder( save, FILENAME_ENCRYPTTMP );
#endif
	rename( MI_ENCRYPT_FLASH_BIN ? FILENAME_ENCRYPTTMP : tmp, final );
	//removeTempFile( MI_ENCRYPT_FLASH_BIN ? tmp : FILENAME_ENCRYPTTMP );
	return ret;
}

#ifdef CONFIG_SUPPORT_FLASH_MODULE_CRC_CHECK
void CalculatEachModuleCRC(u8 *raw_data, u32 data_size)
{
    int module_size;
    mtab_head_s *flash_head;
    char *current_ptr;
    char module_name[TAG_LENGTH+1];

    //calculate bootrom crc
    current_ptr = (char *)raw_data;
    module_size = *(u32 *)(current_ptr+8);
    flash_head = (mtab_head_s *)(raw_data+SPI_OUIBOOTINFO_ADDR);
    flash_head->crc = memCRC32(current_ptr, module_size);
    current_ptr += module_size;

    //calculate each module crc
    do {
        memset(module_name, '\0', TAG_LENGTH+1);
        memcpy(module_name, current_ptr, TAG_LENGTH);
        module_size = *(u32 *)(current_ptr+TAG_LENGTH);
        flash_head = (mtab_head_s *)current_ptr;
        flash_head->crc = memCRC32(current_ptr+sizeof(mtab_head_s), module_size-sizeof(mtab_head_s));
        current_ptr += module_size;
    }while( strncmp("NVM",module_name,TAG_LENGTH) );
}


void FillEachModuleDataSize(u8 *raw_data, u32 data_size)
{
    int i,module_size;
    mtab_head_s *flash_head;
    char *current_ptr;
    struct stat st;
    char module_name[TAG_LENGTH+1];

    //skip bootrom data size
    current_ptr = (char *)raw_data;
    module_size = *(u32 *)(current_ptr+8);
    current_ptr += module_size;

    //calculate each module crc
    do {
        memset(module_name, '\0', TAG_LENGTH+1);
        memcpy(module_name, current_ptr, TAG_LENGTH);
        module_size = *(u32 *)(current_ptr+TAG_LENGTH);
        flash_head = (mtab_head_s *)current_ptr;
        for (i=0; i < MODULE_MAX; i++)
            if (!strncmp(flashModuleInfo[i].moduleName, module_name, TAG_LENGTH))
                break;
        if ( i < MODULE_MAX) {
            if ((i != MODULE_END) && (i != MODULE_NVM)){
                stat(flashModuleInfo[i].tmpBinName, &st);
                flash_head->data_size = st.st_size;
            }
        }
        current_ptr += module_size;
    }while( strncmp("NVM",module_name,TAG_LENGTH) );
}

#endif  //CONFIG_SUPPORT_FLASH_MODULE_CRC_CHECK

#if 0
bool generateFlashBin()
{
	bool ret = true;

	dbgMsg( "\ngenerateFlashBin ==>\n" );
	if( !mallocFlashTempMem() ) return false;
	ret = generateFlashTempFile();
	freeFlashTempMem();
	if( !ret ) return false;

	ret = generateFinalFlashBin( FILENAME_CODETMP, FILENAME_CODEBIN, miCodeBinName );

#if( CONFIG_DATA_FLASH_SIZE != 0  )
	if( ret ) ret = generateFinalFlashBin( FILENAME_DATATMP, FILENAME_DATABIN, miDataBinName );
#endif

    	return ret;
}
#endif

#if 0
#define TAG_LENGTH		12
typedef struct _mtab_head_s
{
	char sys_tag[TAG_LENGTH]; /* write by createRomBin tool */
 	unsigned int size;

}mtab_head_s;

#endif
static void cpy_mtab_head( char* buffer, char* sys_tag, int filesize)
{
	mtab_head_s mtab_head;
	memset(&mtab_head, 0, sizeof(mtab_head_s));
	strncpy(mtab_head.sys_tag, sys_tag, TAG_LENGTH);
	mtab_head.size = ROUND_16B_ALIGNMENT(filesize) + sizeof(mtab_head_s);
	memcpy(buffer, &mtab_head, sizeof(mtab_head_s));

}
#ifdef CONFIG_SUPPORT_NVM_PRELOAD
bool sfs_dispatch(u16 id, void* src, void* des, int size)
{
	int write_offset =0;
	u8 sn = 0;

	u8* buff = (void *)malloc(SFS_page_size);	//2013.05.10, buffer for DMA, care alignment
	if (buff == NULL)
		return false;
	
	oob_st* oob = (oob_st *)(&buff[SFS_data_size]);

	dbgMsg( "sfs_dispatch %d(%d bytes)\n", id, size);
	while(write_offset < size)
	{
		oob->id = id;
		oob->sn = sn;
		oob->offset = (write_offset/SFS_data_size);
		oob->len = ((size % SFS_data_size) == 0)? (size/SFS_data_size): (size/SFS_data_size+1);
		oob->Magic = SFS_MagicNum;
		memcpy(buff, (void *)((u32)src+write_offset), SFS_data_size);/*Warning, if remain size < pagesize, other space out of data will unknow */
		memcpy(des, buff, SFS_page_size);
		write_offset += SFS_data_size;
		des += SFS_page_size;
	}
	//dbgMsg("<--\n");

	free(buff);

	return true;
}


bool transfer2sfs(u16 id, char* out_filename, char* in_filename)
{
	FILE *OutFile, *InFile;
	char *rbuff,*wbuff,*ptr;
	size_t result;

	int i,chksum=0x0,infile_size = getFileSize(in_filename);

	if (infile_size <= 0) {
		return false;
	}

	InFile = fopen(in_filename,"rb");
	OutFile = fopen(out_filename,"ab+");

	if(OutFile == NULL || InFile == NULL){
		fprintf(stderr, "Can't open will write/read file\n");
		if (InFile) fclose(InFile);
		if (OutFile) fclose(OutFile);
		return false;
	}

	rbuff = (char*) malloc(SFS_Size);
	if (rbuff == NULL) {
		fclose(InFile);
		fclose(OutFile);
		return false;
	}
	memset(rbuff,0,SFS_Size);

	result = fread(rbuff,1,infile_size,InFile);
	if(result != infile_size){
		fputs ("Reading error",stderr);
		fclose(InFile);
		fclose(OutFile);
		free(rbuff);
		return false;
	}

	wbuff = (char*)malloc(SFS_Size);
	if (wbuff == NULL) {
		fclose(InFile);
		fclose(OutFile);
		free(rbuff);
		return false;
	}
	memset(wbuff,0,SFS_Size);

	if(id == SPI_KMFSHARE_FLASHID){
		sfs_dispatch(id, rbuff, wbuff, infile_size);
		ptr=wbuff;
		for(i=0;i<infile_size;i++, ptr++){
			chksum += *ptr;
		}
		*ptr=chksum;
		dbgMsg("chksum 0x%x\n", *ptr);
		fwrite (wbuff , sizeof(char), (infile_size/SFS_page_size+1)*SFS_page_size, OutFile);
	}else{
		#if 1
		char *tmp = (char*)malloc(SFS_Size);
		if (tmp == NULL) {
			fclose(InFile);
			fclose(OutFile);
			free(rbuff);
			free(wbuff);
			return false;
		}
		memset(tmp,0,SFS_Size);
		//*(char *)tmp = infile_size;
		memcpy(tmp ,rbuff, infile_size);
		sfs_dispatch(id, tmp, wbuff, infile_size);
		fwrite(wbuff , sizeof(char), ((infile_size)/SFS_page_size+1)*SFS_page_size, OutFile);
		free (tmp);
		#endif
	}

	fclose (OutFile);
	fclose (InFile);

	free (wbuff);
	free (rbuff);

	return true;
}
#endif
//FlashTableStr FlashTable[MODULE_MAX] = {0};
//int FlashTableIdx = 0;
extern u8 *codeTmpMem;

bool MergeBins2Mem(void)
{
	int i, fileSize;
	bool ret = true;
	//FILE* tmpbin;
	u32 ACC_Offset = 0x00000000;		//start offset
	u32 flashSize = CONFIG_CODE_FLASH_SIZE *1024 ;		//flash size
	float fRealFlashSize = 0;
	u32 keys_phy_addr = 0;
	u32 last_module_offset = 0;
	u32 last_module_size = 0;
    u32 max_size = 0;

#ifdef CONFIG_SUPPORT_NVM_PRELOAD
	char sfs_tempfile[] = "sfs/nvm.bin";
#endif
#ifdef CONFIG_DISABLE_CIKEY_HDCPKEY_SPI_ENCRYPT
    char *decrypt_tmp;
#endif
    check_table_shaodw_size();
	if( !mallocFlashTempMem() ) return false;

	/* initial key start offset */
	#define SIMFS_PHYADDR 	(SPI_SIMFS_FLASHADDR & 0x00ffffff)
	keys_phy_addr = CONFIG_FLASH_KEYSTORAGE_END_OFFSET + EDID_RELATEADDR;

	/* scan all modules */
	showMsg( "******* FlashMap *******\nAddress \tSize \tName \tPath\n");
	for( i = 0; i < MODULE_MAX; i++ )
	{
		if( !flashModuleInfo[i].isValid  ) continue;
		/* fopen input file */
		fileSize = getFileSize(flashModuleInfo[i].tmpBinName);
        max_size = flashModuleInfo[i].max_module_size*1024;

        if ((max_size != 0) && (fileSize > max_size)){
            errMsg("Module %s size(%d) large than max size(%d)\n",flashModuleInfo[i].moduleName, fileSize, max_size);
            return false;
        }
        fileSize = max_size? max_size:fileSize;

		if((i == MODULE_END) || (i == MODULE_NVM))
			fileSize = 0x7fffffff;
		if( fileSize < 0 ){
			#if !DBG_SKIP_NOT_EXIST
				errMsg( "getFileSize failed (%s)\n", flashModuleInfo[i].tmpBinName );//isAllowSkip?
				return false;
			#else
				errMsg( "file not found, skip (%s)\n", flashModuleInfo[i].tmpBinName );//isAllowSkip?
				continue;
			#endif
		}
		if(((ACC_Offset + fileSize) > flashSize)
		    && (i != MODULE_END) && (i != MODULE_NVM)){
            errMsg("FiashSize is %d, ACC_Offset(0x%x(%d)) + filesize(%d) = %d, Over FlashSize %d B\n",
                flashSize, ACC_Offset, ACC_Offset, fileSize, ACC_Offset+fileSize, ACC_Offset+fileSize-flashSize);
            return false;
		}
		switch(i){
		//fix address start here..
			case MODULE_BOOTROM:	//bootrom @ 0xbc000000..+? byte, No header
				copyFileToMemory(&codeTmpMem[ACC_Offset], flashModuleInfo[i].tmpBinName, fileSize);
				showMsg( "0x%08x\t%d\t%s\t%s\n",  ACC_Offset, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				ACC_Offset += ROUND_16B_ALIGNMENT(fileSize);
				break;
			case MODULE_OPTION:	//option @ 0xbc011000..+0x200 & No header
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				copyFileToMemory(&codeTmpMem[SPI_OPTION_DATA_ADDR], (const char*)flashModuleInfo[i].tmpBinName, SPI_OPTION_DATA_SIZE);
				showMsg( "0x%08x \t%d\t%s\t%s\n",  SPI_OPTION_DATA_ADDR,SPI_OPTION_DATA_SIZE, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				break;
			case MODULE_OUIBOOTINFO:	//oui info @ 0xbc011200..+0x30
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[SPI_OUIBOOTINFO_ADDR], flashModuleInfo[i].moduleName, fileSize);
				copyFileToMemory(&codeTmpMem[SPI_OUIBOOTINFO_ADDR+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, 0x30);
				showMsg( "0x%08x \t48\t%s\t%s\n",  SPI_OUIBOOTINFO_ADDR, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				break;
			case MODULE_EDID:	//edid @ (NVM - 12K)..+0x380
			{
				/* check size first */
				int tmp =  keys_phy_addr - ACC_Offset;
				if ( tmp < 0) {
					printf( "\n\n** ERROR!!! Code Size Overflow (%d bytes)! **\n\n", tmp);
					return false;
				}
				/* extend the module before keys to key offset. */
				//showMsg( "last_module_offset %x\n", last_module_offset);
				/* add POOP */
				mtab_head_s *mtab_head = (mtab_head_s *)(&codeTmpMem[last_module_offset]);
				last_module_size = mtab_head->size;
				cpy_mtab_head((char*)&codeTmpMem[last_module_offset + mtab_head->size], "NOOP", 0x10);
				mtab_head_s *mtab_headS = (mtab_head_s *)(&codeTmpMem[last_module_offset + mtab_head->size ]);
				mtab_headS->size = (CONFIG_FLASH_KEYSTORAGE_END_OFFSET + EDID_RELATEADDR)-(last_module_offset+last_module_size);
				showMsg( "=== MainCode Size 0x%08x ===\n\t%s\n",  last_module_offset + mtab_head->size, "NOOP");

				/* copy header */
				dbgMsg( "%d copyFileToMemory %s %d\n", i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[keys_phy_addr], flashModuleInfo[i].moduleName, EDID_SIZE);
				copyFileToMemory(&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, EDID_SIZE);
				showMsg( "0x%08x \t%d\t%s\t%s\n",  keys_phy_addr, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				keys_phy_addr +=  EDID_SIZE + FLASH_HEAD_SIZE;
				break;
			}
			case MODULE_HDCPKEY:	//hdcp @ (edid_addr)..+0x280
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[keys_phy_addr], flashModuleInfo[i].moduleName, HDCPKEY_SIZE);
				copyFileToMemory(&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, HDCPKEY_SIZE);
#ifdef CONFIG_DISABLE_CIKEY_HDCPKEY_SPI_ENCRYPT
                decrypt_tmp = malloc(((HDCP_KEY_SIZE+15)>>4)<<4);
                memcpy((void *)decrypt_tmp, (void *)&codeTmpMem[keys_phy_addr+0x10], HDCP_KEY_SIZE);
                do_spi_decrypt(decrypt_tmp, (((HDCP_KEY_SIZE+15)>>4)<<4), 0);
                memcpy((void *)&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], (void *)decrypt_tmp, HDCP_KEY_SIZE);
                free(decrypt_tmp);
#endif
				showMsg( "0x%08x \t%d\t%s\t%s\n",  keys_phy_addr, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				keys_phy_addr +=  HDCPKEY_SIZE + FLASH_HEAD_SIZE;
				break;
#ifdef CONFIG_AUTO_WB
            case MODULE_WBDATA:
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[keys_phy_addr], flashModuleInfo[i].moduleName, WBDATA_SIZE);
				copyFileToMemory(&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, WBDATA_SIZE);
				showMsg( "0x%08x \t%d\t%s\t%s\n",  keys_phy_addr, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				keys_phy_addr +=  WBDATA_SIZE + FLASH_HEAD_SIZE;
				break;
#endif
#ifdef CONFIG_SUPPORT_STORE_HDCP2X_TO_FLASH
 			case MODULE_HDCP2XKEY:
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[keys_phy_addr], flashModuleInfo[i].moduleName, HDCP2XKEY_SIZE);
				copyFileToMemory(&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, HDCP2XKEY_SIZE);
#ifdef CONFIG_DISABLE_CIKEY_HDCPKEY_SPI_ENCRYPT
                decrypt_tmp = malloc(((HDCP2X_KEY_SIZE+15)>>4)<<4);
                memcpy((void *)decrypt_tmp, (void *)&codeTmpMem[keys_phy_addr+0x10], HDCP2X_KEY_SIZE);
                do_spi_decrypt(decrypt_tmp, (((HDCP2X_KEY_SIZE+15)>>4)<<4), 0);
                memcpy((void *)&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], (void *)decrypt_tmp, HDCP2X_KEY_SIZE);
                free(decrypt_tmp);
#endif
				showMsg( "0x%08x \t%d\t%s\t%s\n",  keys_phy_addr, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				keys_phy_addr +=  HDCP2XKEY_SIZE + FLASH_HEAD_SIZE;
				break;
#endif
#ifdef CONFIG_CI_SUPPORT
			case MODULE_CIKEY:	//hdcp @ (hdcpy_addr)..+? ( max 10740)
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].tmpBinName, fileSize );
				cpy_mtab_head((char*)&codeTmpMem[keys_phy_addr], flashModuleInfo[i].moduleName, fileSize);
				copyFileToMemory(&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], flashModuleInfo[i].tmpBinName, fileSize);
#ifdef CONFIG_DISABLE_CIKEY_HDCPKEY_SPI_ENCRYPT
                do_spi_decrypt((char *)&codeTmpMem[keys_phy_addr+FLASH_HEAD_SIZE], CIPLUS_KEY_DATA_SIZE, 0);
#endif
				showMsg( "0x%08x \t%d\t%s\t%s\n",  keys_phy_addr, fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].tmpBinName);
				keys_phy_addr +=  fileSize + FLASH_HEAD_SIZE;
				break;
#endif
			case MODULE_END:
			{	//code end, just the last module before NVM

				int the_range_between_end_and_nvm = (SIMFS_PHYADDR-FLASH_HEAD_SIZE)-keys_phy_addr-FLASH_HEAD_SIZE;
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  flashModuleInfo[i].moduleName, fileSize );
				ACC_Offset = keys_phy_addr;		//end = keys end..
				cpy_mtab_head((char*)&codeTmpMem[ACC_Offset], flashModuleInfo[i].moduleName, the_range_between_end_and_nvm);
				showMsg( "0x%08x \t\t%s\n",  ACC_Offset, flashModuleInfo[i].moduleName);
				ACC_Offset += ROUND_16B_ALIGNMENT(sizeof(mtab_head_s));
				break;
			}

			case MODULE_NVM:
			{
#ifdef CONFIG_SUPPORT_NVM_PRELOAD
                int c;
                c=system("rm sfs/nvm.bin");
                for (c = 0; c < gNVMData_count; c++) {
				    if (!transfer2sfs( gNVMData[c].id, sfs_tempfile,  gNVMData[c].pathName)){
					printf( "\nERROR!!! transfer2sfs fail!!!\n");
					return false;
				}
                }
				int outfile_size = getFileSize(sfs_tempfile);
				dbgMsg( "%d copyFileToMemory %s %d\n",i,  sfs_tempfile, outfile_size);
				cpy_mtab_head((char*)&codeTmpMem[SIMFS_PHYADDR-FLASH_HEAD_SIZE], flashModuleInfo[i].moduleName, outfile_size);
				copyFileToMemory(&codeTmpMem[SIMFS_PHYADDR], sfs_tempfile , outfile_size);
				showMsg( "0x%08x \t%d\tNVM\t%s\n",  SIMFS_PHYADDR-FLASH_HEAD_SIZE, outfile_size, "sfs/nvm.bin");
				ACC_Offset = SIMFS_PHYADDR + outfile_size;
#else
				cpy_mtab_head((char*)&codeTmpMem[SIMFS_PHYADDR-FLASH_HEAD_SIZE], flashModuleInfo[i].moduleName, 0);
				ACC_Offset = SIMFS_PHYADDR;
#endif
				break;
			}

		//dynamic address start here..
			default:
				last_module_offset = ACC_Offset;
				cpy_mtab_head((char*)&codeTmpMem[ACC_Offset], flashModuleInfo[i].moduleName, fileSize);
				ACC_Offset +=	 sizeof(mtab_head_s);
				copyFileToMemory(&codeTmpMem[ACC_Offset], flashModuleInfo[i].tmpBinName, fileSize);
				showMsg( "0x%08x \t%d\t%s\t%s\n",  ACC_Offset-sizeof(mtab_head_s), fileSize, flashModuleInfo[i].moduleName, flashModuleInfo[i].fileName);
				ACC_Offset += ROUND_16B_ALIGNMENT(fileSize);
				break;
		}
	}
	/* check size */
	showMsg( "End offset %x\n", ACC_Offset);
	fRealFlashSize = (float)ACC_Offset / 1024.0 / 1024.0;
	showMsg( "Real BIN size=%.2fM\n", fRealFlashSize);

	//write to flash temp file
#ifdef CONFIG_SUPPORT_FLASH_MODULE_CRC_CHECK
    FillEachModuleDataSize(codeTmpMem, ACC_Offset);
    CalculatEachModuleCRC(codeTmpMem, ACC_Offset);
#endif

	writeToFlashTempFile( FILENAME_CODETMP, codeTmpMem, ACC_Offset	);
	free( codeTmpMem );

	ret = generateFinalFlashBin( FILENAME_CODETMP, FILENAME_CODEBIN, miCodeBinName );

#if( CONFIG_DATA_FLASH_SIZE != 0  )
	if( ret ) ret = generateFinalFlashBin( FILENAME_DATATMP, FILENAME_DATABIN, miDataBinName );
#endif
#ifdef CONFIG_APPEND_NAME_TO_CIKEY_HDCPKEY
#ifdef CONFIG_CI_SUPPORT
		removeTempFile(flashModuleInfo[MODULE_CIKEY].tmpBinName);
#endif
		removeTempFile(flashModuleInfo[MODULE_HDCPKEY].tmpBinName);
        #ifdef CONFIG_SUPPORT_STORE_HDCP2X_TO_FLASH
		removeTempFile(flashModuleInfo[MODULE_HDCP2XKEY].tmpBinName);
        #endif
#endif
    	return ret;
}

bool transferPnelSet2Bin(char* out_filename, char* pnl_ini_name)
{
	#define MAX_PNLSET_SIZE		2048
	FILE *OutFile;
	char* buff;
	int size;
	
	buff = malloc(MAX_PNLSET_SIZE);		// max panelset bin file size 2k.
	if (buff == NULL)
		return false;
	
	size = ini2binmem(pnl_ini_name, buff, MAX_PNLSET_SIZE);
	//get writed size
	if(size < 0) {
		free(buff);
		return false;
	}
	
	OutFile = fopen(out_filename,"wb");
	if (OutFile == NULL) {
		fprintf(stderr, "Can't open will write file\n");
		free(buff);
		return false;
	}
	
	fwrite(buff, size, 1, OutFile);
	fclose(OutFile);
	free(buff);

	#undef MAX_PNLSET_SIZE
	return true;
}

//bool transferLogo2Bin( u8* memOut, NorFlashModuleInfo *info  )
bool transferLogo2Bin(char* out_filename, char* input_name)
{
	int ret = false;
	showMsg( "[transferLogoFileToMemory] %s\n", input_name );
	if( checkFileNameExtension( input_name, ".bmp" ) )
	{
		ret = BMP2Bin( input_name, FILENAME_LOGOTMP );
		if( syscmd( "./../tools/lzma460/lzma e %s %s", FILENAME_LOGOTMP, FILENAME_LOGOGZTMP ) )
		{
			ret = false;
		}
		if( syscmd( "mv %s %s ", FILENAME_LOGOGZTMP, out_filename ) )
		{
			ret = false;
		}
	}
	else if( checkFileNameExtension( input_name, ".jpg" ) || \
             checkFileNameExtension( input_name, ".mp3" ) || \
             checkFileNameExtension( input_name, ".jpeg" ))
	{
		ret = JPG2Bin( input_name, out_filename );
	}
	return ret;
}
bool transferCustable2GZIPBin(char* out_filename, char* input_name)
{
	int ret = true;
	//char* out_file[30];
	showMsg( "[transferCustomertable2lzma] %s\n", input_name );
	if( checkFileNameExtension( input_name, ".bin" ) )
	{

		if(syscmd("./../tools/lzma460/lzma e %s %s",input_name,FILENAME_CUSTABLEGZTMP))
		{
			ret = false;
		}
		if( syscmd( "mv %s %s ", FILENAME_CUSTABLEGZTMP, out_filename ) )
		{
			ret = false;
		}
	}
	return ret;
}

bool genTempBinFiles()
{
	int i, ret = true;
#ifdef CONFIG_APPEND_NAME_TO_CIKEY_HDCPKEY
	int char_read;
	char buffer[1024];
	char tempstring[] = "temp";
	char temp[512];
	FILE *f_in, *f_out;
#endif
	//char outname[32];
	dbgMsg( "genTempBinFiles..\n" );
	for( i = 0; i < MODULE_MAX; i++ )
	{
		//transfer all ini files
		if( !flashModuleInfo[i].isValid  )
			continue;
#if 0	// if not support Multi-panel bin file
		//if get PanelSet.ini
		if( i ==  MODULE_PANELSET ){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			ret = transferPnelSet2Bin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName);
		}
		//if get ExtraPanelSet1.ini
		else if( i == MODULE_EXTRAPANELSET1 ){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			ret = transferPnelSet2Bin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName);
		}
		//if get ExtraPanelSet2.ini
		else if( i == MODULE_EXTRAPANELSET2 ){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			ret = transferPnelSet2Bin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName);
		}
		//if get ExtraPanelSet3.ini
		else if( i == MODULE_EXTRAPANELSET3 ){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			ret = transferPnelSet2Bin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName);
		}
		//Logo
		else if( i ==  MODULE_LOGO ){
#endif
		#if 0
		else if( i ==  MODULE_OPTION){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			if( !mergeToBin_GenerateOption(flashModuleInfo[i].tmpBinName) )
				return false;
		}
		#endif
		else if( i ==  MODULE_CUSTABLE){
			sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
			if( !transferCustable2GZIPBin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName) )
				return false;
		}
#ifdef CONFIG_APPEND_NAME_TO_CIKEY_HDCPKEY
		else if(0||
                #ifdef CONFIG_CI_SUPPORT
                ( i ==  MODULE_CIKEY ) || 
                #endif
                ( i ==  MODULE_HDCPKEY)||
                #ifdef CONFIG_SUPPORT_STORE_HDCP2X_TO_FLASH
                ( i ==  MODULE_HDCP2XKEY)||
                #endif
                0){
				strcpy(temp, flashModuleInfo[i].fileName);
				strcat(temp , tempstring);
				f_in = fopen (flashModuleInfo[i].fileName, "rb");
				if(f_in == NULL)
				{
					showMsg( "\nCan not find module binfile: %s\n", flashModuleInfo[i].fileName);
					return false;
				}
				f_out = fopen (temp, "wb");
				if (f_out == NULL) 
				{
					fclose(f_in);
					return false;
				}
				while(!feof(f_in)) {
				   	char_read=fread(buffer, 1, 32, f_in);
				    fwrite(buffer,1, char_read, f_out);
				}
				fseek(f_out, 0, SEEK_END);
				fwrite(flashModuleInfo[i].eachfileName, 1, (int)32, f_out);
				fclose(f_in);
				fclose(f_out);

				sprintf(flashModuleInfo[i].tmpBinName, "%s", temp);
		}
#endif
		else{
			//just copy fileName to tmpBinName

			if(checkFileNameExtension( flashModuleInfo[i].fileName, ".jpg" ) || \
               checkFileNameExtension( flashModuleInfo[i].fileName, ".mp3" ) || \
               checkFileNameExtension( flashModuleInfo[i].fileName, ".jpeg" ) || \
               checkFileNameExtension( flashModuleInfo[i].fileName, ".bmp" ) ){
				showMsg( "use %s %s\n", flashModuleInfo[i].moduleName, flashModuleInfo[i].fileName );
				sprintf(flashModuleInfo[i].tmpBinName, "%s.bin", flashModuleInfo[i].moduleName);
				ret = transferLogo2Bin(flashModuleInfo[i].tmpBinName,  flashModuleInfo[i].fileName);
			}else{	//bmp or jpeg
			showMsg( "use %s\n", flashModuleInfo[i].fileName );
					snprintf(flashModuleInfo[i].tmpBinName, sizeof(flashModuleInfo[i].tmpBinName), "%s", flashModuleInfo[i].fileName);
			}
		}
	}
#if 0	//todo
	if( !mergeToBin_GenerateUMFDefaultSetting() ) return false;
#endif
	/**/
    	return ret;
}