/*!
  @file
  boot_pin_test.c

  @brief
  It is used to test each pin  in the factory

*/
/*===========================================================================

                        EDIT HISTORY FOR MODULE

This section contains comments describing changes made to the module.
Notice that changes are listed in reverse chronological order.


when         who      what, where, why
----------   ----     ---------------------------------------------------------
2020/02/18   Egan     Create the file, It is used to check nvm erase flash


===========================================================================*/

/*===========================================================================

                           INCLUDE FILES

===========================================================================*/


#include "boot_flasherase_check.h"
#include "ptable.h"


//#define flash_check_log(format, args...)   (uart_printf(format , __FILE__, __FUNCTION__ , __LINE__, ##args))
#define flash_check_log(...)
//#define uart_printf(...)   
typedef unsigned char	BYTE;	/* char must be 8-bit */

extern struct spi_flash_chip *chip;
struct spi_flash_chip *spichip=NULL;
UINT32 FlashIsSPI=0;
UINT8 isChip3601S=FALSE;
#define CHIP_SECTOR_SIZE 		  0x1000    //erase 4k each times


/* Compare memory block */
int quec_mem_cmp (const void* dst, const void* src, UINT32 cnt)	/* ZR:same, NZ:different */
{
	const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
	int r = 0;

	do {
		r = *d++ - *s++;
	} while (--cnt && r == 0);

	return r;
}

BOOL isChip_3601S(void)
{
    static UINT8 tmp = FALSE;
    if (!tmp)
    {
        *((volatile UINT32 *)0xd4282868) = 0x09;
        isChip3601S = (*((volatile UINT32 *)0xd4201404)>>12)&0x1; //bank0[28]
        *((volatile UINT32 *)0xd4282868) = 0x0;
        tmp = TRUE;
        
    }
    return isChip3601S;
}


unsigned int spi_nor_do_erase(unsigned int addr, unsigned int size)
{

	int ret = 0;
#ifdef RUN_XIP_MODE
    watchdogKick();
#endif
	if(isChip3601S)
	{
		if(FlashIsSPI)
		{
			flash_check_log("erase\r\n");
			ret = spichip->ops->erase_sector(spichip, addr); //erase a block
		}
		else
		{
			flash_check_log("erase_1\r\n");
			ret = chip->ops->erase(chip, addr, size);
		}
	}
	else
	{
		flash_check_log("erase_2\r\n");
		ret = chip->ops->erase(chip, addr, size);
	}

	return 0;

}

unsigned int spi_nor_do_read(unsigned int addr, unsigned int buf_addr, unsigned int size)
{

	int ret = 0;
	if(isChip3601S)
	{
		if(FlashIsSPI)
		{
			flash_check_log("read\r\n");
			ret = spichip->ops->read(spichip, addr, size, (uint8_t *)buf_addr);
		}
		else
		{
			flash_check_log("read_1\r\n");
			ret = chip->ops->read(chip, addr, size, (uint8_t *)buf_addr);
		}
	}
	else
	{
		flash_check_log("read_2\r\n");
		ret = chip->ops->read(chip, addr, size, (uint8_t *)buf_addr);
	}
		return ret;
}

unsigned int spi_nor_do_write(unsigned int addr, unsigned int buf_addr,unsigned int size)
{

	int ret = 0;
#ifdef RUN_XIP_MODE
    watchdogKick();
#endif
	if(isChip3601S)
	{
		if(FlashIsSPI)
		{
			flash_check_log("write\r\n");
			ret = spichip->ops->write(spichip, addr, size, (uint8_t *)buf_addr);
		}
		else
		{
			flash_check_log("write_1\r\n");
			ret = chip->ops->write(chip, addr, size, (uint8_t *)buf_addr);
		}
	}
	else
	{
		flash_check_log("write_2\r\n");
		ret = chip->ops->write(chip, addr, size, (uint8_t *)buf_addr);
		flash_check_log("write_2_end\r\n");
	}
	return 0;

}

#ifdef QUEC_UART2_ENABLE

quec_production_cfg_s quec_production_config={NULL,1};
/*
int quec_production_cfg_get(void)
{
	quec_production_cfg_s cfg_read = {0};
	
	memset(&cfg_read, 0, sizeof(quec_production_cfg_s));
	memset(&quec_production_config, 0, sizeof(quec_production_cfg_s));
	
	if (NoError != ReadFlash(QUEC_PRODUCTION_CFG_ADDR, &cfg_read, sizeof(quec_production_cfg_s), BOOT_FLASH))
	{
		uart_printf("read production_config from flash error!\n");
		return 0;
	}
//	uart_printf("Egan %s ,%d\r\n",cfg_read.quec_chk_bytes,quec_production_config.quec_dualport_support);
	if (0 != memcmp(cfg_read.quec_chk_bytes, QUEC_CFG_BYTE_STR, strlen(QUEC_CFG_BYTE_STR)))
	{
		return 0;
	}

	memcpy(&quec_production_config, &cfg_read, sizeof(quec_production_cfg_s));
	return 0;
}
*/
int quec_production_cfg_get(void)
{
	_ptentry * quec_cfg_Entry= ptable_find_entry("quec_cfg");
	volatile unsigned int *quec_cfs_add=quec_cfg_Entry->vstart;
	quec_production_cfg_s *ptr=(quec_production_cfg_s*)quec_cfs_add;
	if (0 == memcmp(ptr->quec_chk_bytes, QUEC_CFG_BYTE_STR, strlen(QUEC_CFG_BYTE_STR)))
	{
		uart_printf("quec_cfg ok %d\r\n",ptr->quec_dualport_support);
		quec_production_config.quec_dualport_support=ptr->quec_dualport_support;		
	}
	else
	{
		uart_printf("quec_cfg fail %d\r\n",ptr->quec_dualport_support);
	}
}


#endif

UINT32 ReadFlash(UINT32 flash_addr, UINT32 buffer, UINT32 total_size, FlashBootType_T fbt)
{
	int ret = NULL;
	ret=spi_nor_do_read(flash_addr,buffer,total_size);
	if(ret != NULL)
	{
		uart_printf("boot_readflash_fail %d %d\r\n",flash_addr,total_size);
	}
	return ret;
}

UINT32 WriteFlash(UINT32 flash_addr, UINT32 buffer, UINT32 total_size, FlashBootType_T fbt)
{
	int ret = NULL;
	ret=spi_nor_do_write(flash_addr,buffer,total_size);
	if(ret != NULL)
	{
		uart_printf("boot_writeflash_fail %d %d\r\n",flash_addr,total_size);
	}
	return ret;
}

UINT32 EraseFlash(UINT32 flash_addr, UINT32 size, FlashBootType_T fbt)
{
	int ret = NULL;
	ret=spi_nor_do_erase(flash_addr,size);
	if(ret != NULL)
	{
		uart_printf("boot_eraseflash_fail %d %d\r\n",flash_addr,size);
	}
	return ret;
}

#define Quec_UpdaterExecAddress 0x7E300000//bind on updater build sct loader config  1606 0x7E000000~0x7E400000

#ifdef QUEC_NORFLASH_ERASE_OPTIMIZE
#define CHIP_BLOCK_SIZE 		  0x10000
#define CRANE_QSPI_BASE_ADDRESS             0x80000000

char ERASE_RECORD_AREA[][16]={
	"nvm",
	"customer_fs"		//加入customer_fs进补擦区域 covington.wei @20250214
};//此数组需要与cp同步
UINT32 FLASH_ERASE_RECORD_ALLOW_AREA(UINT32 flash_addr,UINT32 size)
{
	int len =sizeof(ERASE_RECORD_AREA)/sizeof(ERASE_RECORD_AREA[0]);
	_ptentry *pnt;
	int i;
	for(i=0;i<len;i++)
	{
		pnt=ptable_find_entry(ERASE_RECORD_AREA[i]);
		//补擦的分区必须是内部分区才能判断地址范围
		if(pnt && ((pnt->vstart & 0xF0000000) == 0x80000000))
		{
			if(flash_addr >= pnt->start)
			{
				if((flash_addr+size) <= (pnt->start + pnt->size))
				{
					return 1;
				}
			}
		}
	}
	return NULL;
}
void Quec_FlashErase_Optimize(void)
{
	int i=0,EraseRecordAreaflag=0;	
	UINT32 tmp_buff;
	quec_flashErase_record_s *P_BlkEraseRecordcell = NULL;
	quec_RecordInfo_s *P_BlkERCellInfo = NULL;
	quec_Eraseflag_s *P_BlkERCellflag = NULL;
	UINT32 Retval = NoError;
	UINT32 BlockSize = CHIP_SECTOR_SIZE; 
	quec_Eraseflag_s BlkEraseflag;
	quec_RecordInfo_s BlkERecordCellInfo;	
	UINT32 QUEC_RECORD_BLOCKERASE_AREA_SIZE=NULL;
	UINT32 QUEC_RECORD_BLOCKERASE_AREA_ADD=NULL;
	_ptentry *ptn=ptable_find_entry("erase_rd");
	if(ptn==NULL)
	{
		uart_printf("not get erase_rd partition \r\n");
		return ;
	}
	QUEC_RECORD_BLOCKERASE_AREA_SIZE=ptn->size;
	QUEC_RECORD_BLOCKERASE_AREA_ADD=ptn->start;
//	uart_printf("start=0x%08x size=0x%08x\r\n",QUEC_RECORD_BLOCKERASE_AREA_ADD,QUEC_RECORD_BLOCKERASE_AREA_SIZE);
//	tmp_buff = DECOMPRESS_TEMP_ADDR;// 0x071B0000, size 0x10000 (64K),tmp buff used here
	BlkEraseflag.flag = 0xAAAA5555;
	BlkEraseflag.reserve = 0xffffffff;
	tmp_buff = Quec_UpdaterExecAddress ;
	Retval = ReadFlash(QUEC_RECORD_BLOCKERASE_AREA_ADD, tmp_buff,QUEC_RECORD_BLOCKERASE_AREA_SIZE, BOOT_FLASH);
//	isChip_3601S();//get the chip is 3601 or not
	if( NoError == Retval)
	{
		P_BlkEraseRecordcell = (quec_flashErase_record_s*)tmp_buff;
		P_BlkERCellInfo = (quec_RecordInfo_s*)tmp_buff;
		if((QUEC_RECORD_MAGIC2 == P_BlkERCellInfo->RecordMagic) && (0x00 == P_BlkERCellInfo->BlockId))// first record cell is a flag which mark the record area erase
		{
		    for(i=1; i*sizeof(quec_flashErase_record_s)<QUEC_RECORD_BLOCKERASE_AREA_SIZE; i++)
		    {
			P_BlkEraseRecordcell = (quec_flashErase_record_s*)tmp_buff+i;
			P_BlkERCellInfo = (quec_RecordInfo_s *)P_BlkEraseRecordcell;
			P_BlkERCellflag = (quec_Eraseflag_s *)((char *)P_BlkEraseRecordcell + sizeof(quec_RecordInfo_s));
			if(0xffffffff != P_BlkERCellInfo->BlockId && 0xAAAA5555 != P_BlkERCellflag->flag)
			{
				uart_printf("[Quec][Flash]:Blk=0x%x maybe need erase! i=%d type=%d \r\n",P_BlkERCellInfo->BlockId,i,P_BlkERCellInfo->Record_type);
				if( 0xffffffff == P_BlkERCellflag->flag && QUEC_RECORD_MAGIC1 == P_BlkERCellInfo->RecordMagic)
				{
					//Record cell is eflag not marked(0xaaaa55) nand magic number is right. erase this block now!!
					BlockSize=P_BlkERCellInfo->Record_type?CHIP_SECTOR_SIZE:CHIP_BLOCK_SIZE;
	
					if(FLASH_ERASE_RECORD_ALLOW_AREA(P_BlkERCellInfo->BlockId*BlockSize, BlockSize))
					{
						if( NoError == EraseFlash(P_BlkERCellInfo->BlockId*BlockSize, BlockSize, BOOT_FLASH))
						{
							Retval = WriteFlash(QUEC_RECORD_BLOCKERASE_AREA_ADD+i*sizeof(quec_flashErase_record_s)+sizeof(quec_RecordInfo_s), \
							           &BlkEraseflag,sizeof(BlkEraseflag), BOOT_FLASH);
							// 如果是AT补擦测试，需要URC回复
							if(P_BlkERCellflag->reserve == 0X12345678)
							{
								char erase_type[10]={0};
								if(P_BlkERCellInfo->Record_type)	//1为sector、0为block
									sprintf(erase_type,"%s","section");
								else
									sprintf(erase_type,"%s","block");
								uart2_printf("\r\n+QFTEST: \"RepairErase\",\"%s\",%p\r\n\r\n",erase_type, P_BlkERCellInfo->BlockId*BlockSize);
							}
							uart_printf("erase addr=%x size=%x block=0x%x erased again!!!! i=%d type=%d\r\n",P_BlkERCellInfo->BlockId*BlockSize,BlockSize,P_BlkERCellInfo->BlockId,i,P_BlkERCellInfo->Record_type);
						}
					} else {
						Retval = WriteFlash(QUEC_RECORD_BLOCKERASE_AREA_ADD+i*sizeof(quec_flashErase_record_s)+sizeof(quec_RecordInfo_s), \
						           &BlkEraseflag,sizeof(BlkEraseflag), BOOT_FLASH);
						uart_printf("addr is error not erase!!addr=%x size=%x block=0x%x i=%d type=%d\r\n",P_BlkERCellInfo->BlockId*BlockSize,BlockSize,P_BlkERCellInfo->BlockId,i,P_BlkERCellInfo->Record_type);
					}
				}
				else
				{
					uart_printf("[Quec][Flash]:RecordCell(i=%d) is dirty data,Blk=%d not need erase!! flag=0x%x\r\n",\
							i,P_BlkERCellInfo->BlockId,P_BlkERCellflag->flag);	
				}
			}

			if(0xffffffff == P_BlkERCellInfo->BlockId && 0xffffffff == P_BlkERCellflag->flag)
			{
				uart_printf("[Quec][Flash]:Abnormal Erasedblock not found(i=%d)\r\n",i);
				break;			
			}

		    }
		    uart_printf("[Quec][Flash]:Abnormal Erasedblock not found(i=%d)\r\n",i);	
		}
		else
		{
			EraseRecordAreaflag=1;
		}
		
		if(1==EraseRecordAreaflag)
        {
			if(NoError == EraseFlash(QUEC_RECORD_BLOCKERASE_AREA_ADD, QUEC_RECORD_BLOCKERASE_AREA_SIZE, BOOT_FLASH))
			{
				BlkERecordCellInfo.RecordMagic = QUEC_RECORD_MAGIC2;
				BlkERecordCellInfo.BlockId  = 0x00;
				Retval = WriteFlash(QUEC_RECORD_BLOCKERASE_AREA_ADD, &BlkERecordCellInfo, sizeof(BlkERecordCellInfo), BOOT_FLASH);
				if(NoError !=Retval)
				{
					uart_printf("[Quec][Flash]:write cell0  EraseRecord area erase flag faild !!!");
					return ;
				}
			}
			else
			{
				uart_printf("[Quec][Flash]:Erase record area fail !!!!!!");
				return ;
			}
		        uart_printf("[Quec][Flash]:cell0 write flag(MAGIC2=0x%x)(BlockId=%d)\r\n",BlkERecordCellInfo.RecordMagic,BlkERecordCellInfo.BlockId);	
			return;
		}
	}
	else
	{
		uart_printf("[Quec][Flash]:flash read EraseRecord Area failed ret=%d\r\n",Retval);
		return;
	}
	return;
}
#endif



#ifdef QUECTEL_FOTA_UPDATER_PARTITION

#define  UPDATER_PKG_IMAGE_SIZE   0x10000*2   //64K
#define  QUEC_UPDATER_PKG_START_FLAG   "QUEC_UPDATER_STR"  // 16 BYTE  start flag,  not modify
#define  QUEC_UPDATER_PKG_END_FLAG     "QUEC_UPDATER_END" // 16 BYTE   not modify

typedef struct
{
    char flagStr[16] ;
    unsigned int updater_file_size;
    unsigned int checksum;
    unsigned int version;
    unsigned int  reserved;
}quec_updater_head_s;


static unsigned int ASR_fbf_checksum(unsigned char * src, unsigned int len, unsigned int checksum)
{
	unsigned int * start = (unsigned int *)src;
	unsigned int * end = (unsigned int *)(src + len);
	while (start < end) {
		checksum ^= (*start++);
	}
	return checksum;
}

// 这个函数 不能随便返回0， 不然可能会影响正常fota升级。只有在updater分区被擦除了，写flash出错了才能返回0，其他都要返回1
int Quectel_ota_updaterImage_function(void)
{  
	UINT32 Retval = NoError;
	UINT32  *DATA_buf= NULL;
	quec_updater_head_s *p_QupdaterPKG_Head;
	unsigned int  updater_pkg_size=0, Q_updaterImgChecksum=0;
	UINT32 QUEC_UPDATER_SOURCE_AREA_SIZE=NULL;
	UINT32 QUEC_UPDATER_SOURCE_AREA_ADD=NULL;
	_ptentry *updater_ptn=ptable_find_entry("updater");
	_ptentry *Rd_ptn=ptable_find_entry("fota_pkg");
	
	if(NULL == Rd_ptn)
	{
		uart_printf("[Quec][boot33][Flash][%s]:not get erase_rd partition \r\n",__func__);
		return  1;
	}
	if(NULL == updater_ptn)
	{
		uart_printf("[Quec][boot33][Flash][%s]:not get updater partition \r\n",__func__);
		return  1;
	}

	DATA_buf = Quec_UpdaterExecAddress;  //malloc(UPDATER_IMAGE_SIZE);  临时借用updater执行的这段内存，毕竟这是还没有运行updater
	if(NULL == DATA_buf)
	{
		uart_printf("[Quec][boot33][Flash][%s]: malloc (size=0x%08X)\r\n",__func__, UPDATER_PKG_IMAGE_SIZE);
		return 1;
	}

	if((Rd_ptn->size) < UPDATER_PKG_IMAGE_SIZE)
	{
		uart_printf("[Quec][boot33][Flash][%s]: fota_pkg partition size too small !!!! (ptn->sizesize=0x%08X)\r\n",__func__,Rd_ptn->size);
		return 1;
	}
	Retval = ReadFlash(Rd_ptn->start, DATA_buf,UPDATER_PKG_IMAGE_SIZE, BOOT_FLASH);
	if( NoError != Retval)
	{
		uart_printf("[Quec][boot33][Flash][%s]: read fota_pkg partiton data failed Retval=%d!!!\r\n",__func__,Retval);
		return 1;
	}
	if(0 !=  quec_mem_cmp((void *)DATA_buf, QUEC_UPDATER_PKG_START_FLAG, strlen(QUEC_UPDATER_PKG_START_FLAG)))
	{
		uart_printf("[Quec][boot33][Flash][%s]: fota_pkg partiton can't found updater OTA flag !!\r\n",__func__);
		return 1;
	}

	#if 1 // check crc
		p_QupdaterPKG_Head = (quec_updater_head_s *)DATA_buf;
		Q_updaterImgChecksum = ASR_fbf_checksum((char *)DATA_buf+sizeof(quec_updater_head_s), p_QupdaterPKG_Head->updater_file_size,0);
		uart_printf("[Quec][boot33][Flash]:updater img checksum flag checksum=[0x%08x], cal checksum[0x%08x]\r\n", p_QupdaterPKG_Head->checksum,Q_updaterImgChecksum);
		if(Q_updaterImgChecksum != p_QupdaterPKG_Head->checksum)
		{
			uart_printf("[Quec][boot33][Flash]:updater img checksum failed, flag checksum=[0x%08x], cal checksum[0x%08x]\r\n", p_QupdaterPKG_Head->checksum,Q_updaterImgChecksum);
			return 1;
		}
	#endif 

	if( 1 == p_QupdaterPKG_Head->version)//we can.t  control this action ,when make updater  PKG
	{
		CpCoreFreqChangeTo416(); // upgrade  updater partiton set CPU Freq  to  416
	}

	Retval = EraseFlash(updater_ptn->start, updater_ptn->size,BOOT_FLASH);
	if(NoError != Retval)
	{
		uart_printf("[Quec][boot33][Flash][%s]: erase updater partition failed!!!!!\r\n",__func__);
		return 1;
	}
	else // updater 分区擦除成功，后面必须要保证updater 数据更新完成，不然不能跳转到updater里去运行。
	{
		Retval = WriteFlash(updater_ptn->start, (char *)DATA_buf+sizeof(quec_updater_head_s), UPDATER_PKG_IMAGE_SIZE-sizeof(quec_updater_head_s)/*head*/-sizeof(quec_updater_head_s)/*tail*/, BOOT_FLASH);
		if(NoError != Retval)
		{
			uart_printf("[Quec][boot33][Flash][%s]:updater_partiton upgrade write flash failed Retval= %d !!!\r\n",__func__,Retval);
			return 0;   // must  return 0,  updater_partition  upgrade fail,  must reboot  
		}
		else
		{
			uart_printf("[Quec][boot33][Flash][%s]:updater_partiton upgrade sucess !!\r\n",__func__);
			Retval = EraseFlash(Rd_ptn->start, UPDATER_PKG_IMAGE_SIZE,BOOT_FLASH);
			if(NoError != Retval)
			{
				uart_printf("[Quec][boot33][Flash][%s]:EraseFlash upgrade flag fail !!\r\n",__func__);
			}
			return 1;
		}
	}
	return 1;
	
}
#endif