s32 nv_modify_upgrade_flag(bool flag)
{
struct nv_dload_packet_head_stru nv_dload;
s32 ret;
u32 old_magic;
u32 new_magic;
ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL);
if(ret)
{
return ret;
}
/*lint -save -e731*/
if(true == flag)
{
old_magic = NV_DLOAD_INVALID_FLAG;
new_magic = NV_FILE_EXIST;
}
else
{
new_magic = NV_DLOAD_INVALID_FLAG;
old_magic = NV_FILE_EXIST;
}
/*lint -restore*/
nv_dload.nv_bin.magic_num = (nv_dload.nv_bin.magic_num == old_magic) ? new_magic : nv_dload.nv_bin.magic_num;
ret = bsp_nand_write((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload));
if(ret)
{
return ret;
}
return 0;
}
/*
* 写nand接口
* mtd : mtd device
* off : loggic offset in this file,need
* len : data len write to flash ,len <= mtd->erasesize
* ptr : the data need to write
*/
u32 nv_mtd_write(struct nv_flash_file_header_stru* ffp,FSZ off,u32 len,u8* ptr)
{
u32 ret;
u32 offset = 0; /*传进来的偏移相对于文件头的逻辑偏移*/
struct mtd_info* mtd = ffp->mtd;
ret = nv_sec_off_count(ffp,off,&offset);
if(ret != NAND_OK)
{
nv_printf("%s\n",mtd->name);
return ret;
}
if ( NV_FILE_SYS_NV == ffp->flash_type )
{
ret = (u32)bsp_nand_write_dload((char*)mtd->name,offset,ptr,len);
}
else
{
ret = (u32)bsp_nand_write((char*)mtd->name,offset,ptr,len);
}
if(ret)
{
nv_printf("%s\n",mtd->name);
return ret;
}
return ret;
}
/*copy img to backup*/
u32 nv_copy_img2backup(void)
{
u32 ret;
FILE* fp = NULL;
u32 total_len;
u32 phy_off = 0;
u32 unit_len;
void* pdata = NULL;
fp = BSP_fopen((char*)NV_IMG_PATH,"rb");
if(!fp)
{
return BSP_ERR_NV_NO_FILE;
}
BSP_fseek(fp,0,SEEK_END);
total_len = (u32)BSP_ftell(fp);
BSP_fseek(fp,0,SEEK_SET);
pdata = (void*)nv_malloc(NV_FILE_COPY_UNIT_SIZE);
if(!pdata)
{
BSP_fclose(fp);
return BSP_ERR_NV_MALLOC_FAIL;
}
nv_create_flag_file((s8*)NV_BACK_FLAG_PATH);
while(total_len)
{
unit_len = (total_len >= NV_FILE_COPY_UNIT_SIZE)?NV_FILE_COPY_UNIT_SIZE : total_len;
ret = (u32)BSP_fread(pdata,1,unit_len,fp);
if(ret != unit_len)
{
nv_free(pdata);
BSP_fclose(fp);
return BSP_ERR_NV_READ_FILE_FAIL;
}
ret = (u32)bsp_nand_write((char*)NV_BACK_SEC_NAME,phy_off,pdata,unit_len);
if(ret)
{
nv_free(pdata);
BSP_fclose(fp);
return BSP_ERR_NV_WRITE_FILE_FAIL;
}
phy_off += unit_len;
total_len -= unit_len;
}
nv_free(pdata);
BSP_fclose(fp);
nv_delete_flag_file((s8*)NV_BACK_FLAG_PATH);
return NV_OK;
}
/*
* Function : sc_bakup
* Discription: c core nv init,this phase build upon the a core kernel init,
* this phase after icc init,this phase ensure to use all nv api normal
* start at this phase ,ops global ddr need spinlock
* Parameter : none
* Output : result
* History :
*/
s32 sc_bakup(s8 *pdata, u32 len)
{
s32 sc_fp = 0;
s32 wlen = 0;
u32 sc_mtd_len = 0;
struct mtd_info* mtd;
sc_fp = bsp_open((char *)SC_PACKET_TRANS_FILE,(RFILE_RDONLY),0660);
if(!sc_fp)
{
sc_error_printf("bsp_open error, chanid :0x%x sc_fp :0x%x\n",SC_ICC_CHAN_ID,sc_fp);
return BSP_ERR_SC_NO_FILE;
}
else
{
sc_debug_printf("bsp_open ok, file is 0x%x!\n",sc_fp);
}
wlen = bsp_read(sc_fp, pdata, len);
if(wlen != len)
{
sc_error_printf("bsp_read error, opt_len :0x%x sc_ram_len :0x%x\n", wlen, len);
bsp_close(sc_fp);
return BSP_ERR_SC_READ_FILE_FAIL;
}
else
{
sc_debug_printf("bsp_read ok, len is 0x%x!\n",(u32)(wlen));
}
bsp_close(sc_fp);
mtd = get_mtd_device_nm((char*)SC_BACKUP_SEC_NAME);
if (IS_ERR(mtd))
{
sc_error_printf("get mtd device err! %s\n",mtd);
return BSP_ERR_READ_MTD_FAIL;
}
sc_mtd_len = mtd->size;
sc_debug_printf("mtd len: 0x%x\n",sc_mtd_len);
put_mtd_device(mtd);
if((sc_mtd_len < SC_MTD_PTABLE_OFFSET) || (len >= SC_MTD_PTABLE_OFFSET))
{
sc_error_printf("mtd length err! sc_mtd_len: 0x%x, len: 0x%x\n",sc_mtd_len, len);
return BSP_ERR_READ_LGTH_FAIL;
}
wlen = bsp_nand_write((char*)SC_BACKUP_SEC_NAME, (sc_mtd_len - SC_MTD_PTABLE_OFFSET), pdata, len);
if(wlen != BSP_OK)
{
sc_error_printf("mtd length err! wlen 0x%x, len is 0x%x\n",wlen,len);
return BSP_ERR_SC_WRITE_FILE_FAIL;
}
sc_debug_printf("sc write to nand ok, len is 0x%x!\n",(u32)(wlen));
return SC_OK;
}
/*
* 写nand接口
* mtd : mtd device
* off : loggic offset in this file,need
* len : data len write to flash ,len <= mtd->erasesize
* ptr : the data need to write
*/
u32 nv_mtd_write(struct nv_emmc_file_header_stru* fd,FSZ off,u32 len,u8* ptr)
{
u32 ret;
u32 offset = 0; /*传进来的偏移相对于文件头的逻辑偏移*/
struct mtd_info* mtd = fd->mtd;
ret = nv_sec_off_count(fd,off,&offset);
if(ret != NAND_OK)
{
nv_printf("%s\n",mtd->name);
return ret;
}
ret = (u32)bsp_nand_write((char*)mtd->name,offset,ptr,len);
if(ret)
{
nv_printf("%s\n",mtd->name);
return ret;
}
return ret;
}
int sc_file_back2factory(char* path)
{
int len;
void* fp = NULL;
void* buf = NULL;
int ret;
fp = BSP_fopen(path,"rb");
if(!fp)
return 1;
BSP_fseek(fp,0,SEEK_END);
len = BSP_ftell(fp);
BSP_fseek(fp,0,SEEK_SET);
buf = (void*)kmalloc((unsigned int)len,GFP_KERNEL);
if(!buf){
BSP_fclose(fp);
return 2;
}
ret = BSP_fread(buf,1,(unsigned int)len,fp);
if(ret != len){
kfree(buf);
BSP_fclose(fp);
return 3;
}
BSP_fclose(fp);
ret = bsp_nand_write((char*)SC_BACKUP_SEC_NAME,SC_BACKUP_SEC_OFFSET,buf,(unsigned int)len);
if(ret){
printk("%s :write patrition fail ,ret :%d\n",__func__,ret);
kfree(buf);
return 4;
}
kfree(buf);
return 0;
}