s32 nv_flash_read(u8* ptr, u32 size, u32 count, FILE* fp)
{
u32 real_size = 0;
s32 ret = -1;
struct nv_flash_file_header_stru* ffp = (struct nv_flash_file_header_stru*)fp;
u32 len = size*count;
nv_file_debug(NV_FILE_READ_API,0,0,size,count);
if((NULL == ffp)||(ffp->fp != ffp))
{
return BSP_ERR_NV_INVALID_PARAM;
}
real_size = ((ffp->seek+len) < ffp->length)? len: (ffp->length - ffp->seek );
ret = (s32)nv_mtd_read(ffp,(ffp->off+ffp->seek),real_size,ptr);/*读取注意文件seek位置*/
if(ret != NAND_OK)
{
nv_file_debug(NV_FILE_READ_API,2,(u32)ret,real_size,ffp->flash_type);
nv_mntn_record("\n[%s]\n",__func__);
nv_flash_help(NV_FILE_READ_API);
return -1;
}
ffp->seek += real_size;
return (s32)real_size;
}
s32 nv_emmc_close(FILE* fp)
{
struct nv_emmc_file_header_stru* fd = (struct nv_emmc_file_header_stru*)fp;
nv_file_debug(NV_FILE_CLOSE_API,0,0,0,0);
if((NULL == fd)||(fd->fp != fd))
{
nv_file_debug(NV_FILE_CLOSE_API,1,0,0,0);
return BSP_ERR_NV_INVALID_PARAM;
}
put_mtd_device(fd->mtd);
osl_sem_up(&fd->file_sem);
fd->fp = NULL;
fd->seek = 0;
fd->length = 0;
fd->off = 0;
fd->ops --;
fd->mtd = NULL;
if(fd->ops != 0)
{
nv_file_debug(NV_FILE_CLOSE_API,2,fd->ops,0,0);
return BSP_ERR_NV_CLOSE_FILE_FAIL;
}
return NV_OK;
}
s32 nv_emmc_read(u8* ptr, u32 size, u32 count, FILE* fp)
{
u32 real_size = 0;
u32 ret;
struct nv_emmc_file_header_stru* fd = (struct nv_emmc_file_header_stru*)fp;
u32 len = size*count;
nv_file_debug(NV_FILE_READ_API,0,0,size,count);
if((NULL == fd)||(fd->fp != fd))
{
return BSP_ERR_NV_INVALID_PARAM;
}
real_size = ((fd->seek+len) < fd->length)? len: (fd->length - fd->seek );
ret = nv_mtd_read(fd,(fd->off+fd->seek),real_size,ptr);/*读取注意文件seek位置*/
if(ret != NAND_OK)
{
nv_file_debug(NV_FILE_READ_API,2,(u32)ret,real_size,fd->emmc_type);
printf("\n[%s]\n",__func__);
nv_emmc_help(NV_FILE_READ_API);
return -1;
}
fd->seek += real_size;
return (s32)real_size;
}
s32 nv_flash_write(u8* ptr, u32 size, u32 count, FILE* fp)
{
s32 ret = -1;
u32 len = size*count;
struct nv_flash_file_header_stru* ffp = (struct nv_flash_file_header_stru*)fp;
u32* sec_off = NULL;
struct nv_file_info_stru* file_info;
nv_file_debug(NV_FILE_WRITE_API,0,0,size,count);
if((NULL == ffp)||(ffp->fp != ffp))
{
nv_file_debug(NV_FILE_WRITE_API,1,0,size,count);
goto nv_flash_write_err;
}
switch(ffp->flash_type)
{
case NV_FILE_BACKUP:
sec_off = g_sec_info.nv_bak;
file_info = &g_flash_info.bak_sec;
break;
case NV_FILE_SYS_NV:
sec_off = g_sec_info.sys_nv;
file_info = &g_flash_info.sys_nv;
break;
case NV_FILE_DEFAULT:
sec_off = g_sec_info.nv_default;
file_info = &g_flash_info.def_sec;
break;
default:
return -1;
}
ret = (s32)nv_mtd_write(ffp,(ffp->off+ffp->seek),len,ptr);
if(ret)
{
nv_file_debug(NV_FILE_WRITE_API,3,(u32)ret,len,ffp->flash_type);
goto nv_flash_write_err;
}
ret = (s32)nv_count_file_sec_info(ffp->name,len,sec_off);
if(ret)
{
nv_file_debug(NV_FILE_WRITE_API,4,(u32)ret,len,ffp->flash_type);
goto nv_flash_write_err;
}
file_info->magic_num = NV_FILE_EXIST;
file_info->len = len;
file_info->off = 0;
ffp->seek += len;
return (s32)len;
nv_flash_write_err:
nv_mntn_record("\n[%s]\n",__func__);
nv_flash_help(NV_FILE_WRITE_API);
return BSP_ERR_NV_INVALID_PARAM;
}
s32 nv_emmc_ftell(FILE* fp)
{
struct nv_emmc_file_header_stru* fd = (struct nv_emmc_file_header_stru*)fp;
nv_file_debug(NV_FILE_FTELL_API,0,0,0,0);
if((NULL == fd)||(fd->fp != fd))
{
nv_file_debug(NV_FILE_FTELL_API,1,0,0,0);
return BSP_ERR_NV_INVALID_PARAM;
}
return (s32)fd->seek;
}
s32 nv_flash_ftell(FILE* fp)
{
struct nv_flash_file_header_stru* ffp = (struct nv_flash_file_header_stru*)fp;
nv_file_debug(NV_FILE_FTELL_API,0,0,0,0);
if((NULL == ffp)||(ffp->fp != ffp))
{
nv_file_debug(NV_FILE_FTELL_API,1,0,0,0);
return BSP_ERR_NV_INVALID_PARAM;
}
return (s32)(ffp->seek);
}
u32 nv_flash_init(void)
{
u32 ret = NV_ERROR;
u32 i = 0;
nv_file_debug(NV_FILE_INIT_API,0,0,0,0);
/*first init every file sem*/
for(i = 0;i<NV_FILE_BUTT;i++)
{
osl_sem_init(1,&g_nv_file[i].file_sem);
}
memset(&g_flash_info,0,sizeof(struct nv_flash_global_ctrl_stru));
memset(&g_sec_info,0xff,sizeof(struct nv_sec_file_block_info));
/*get dload info*/
ret = nv_dload_file_info_init();
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,1,ret,0,0);
goto nv_flash_init_err;
}
/*get sys nv file info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_SYS_NV].name,&g_flash_info.sys_nv,g_sec_info.sys_nv);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,2,ret,0,0);
goto nv_flash_init_err;
}
/*get backup info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_BACKUP].name,&g_flash_info.bak_sec,g_sec_info.nv_bak);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,3,ret,0,0);
goto nv_flash_init_err;
}
/*get default info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_DEFAULT].name,&g_flash_info.def_sec,g_sec_info.nv_default);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,4,ret,0,0);
goto nv_flash_init_err;
}
return NV_OK;
nv_flash_init_err:
nv_mntn_record("\n[%s]\n",__func__);
nv_flash_help(NV_FILE_INIT_API);
return NV_ERROR;
}
u32 nv_emmc_init(void)
{
u32 ret = NV_ERROR;
u32 i = 0;
nv_file_debug(NV_FILE_INIT_API,0,0,0,0);
/*first init every file sem*/
for(i = 0;i<NV_FILE_BUTT;i++)
{
osl_sem_init(1,&g_nv_file[i].file_sem);
}
memset(&g_emmc_info,0,sizeof(struct nv_emmc_global_ctrl_stru));
/*get sys nv info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_SYS_NV].name,&g_emmc_info.sys_nv);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,1,ret,(u32)(unsigned long)g_nv_file[NV_FILE_SYS_NV].mtd,NV_FILE_SYS_NV);
goto nv_emmc_init_err;
}
/*get dload info*/
ret = nv_dload_file_info_init();
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,2,ret,0,NV_FILE_DLOAD);
goto nv_emmc_init_err;
}
/*get backup info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_BACKUP].name,&g_emmc_info.bak_sec);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,3,ret,0,NV_FILE_BACKUP);
goto nv_emmc_init_err;
}
/*get default info*/
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_DEFAULT].name,&g_emmc_info.def_sec);
if(ret)
{
nv_file_debug(NV_FILE_INIT_API,4,ret,0,NV_FILE_DEFAULT);
goto nv_emmc_init_err;
}
return NV_OK;
nv_emmc_init_err:
printf("\n[%s]\n",__func__);
nv_emmc_help(NV_FILE_INIT_API);
return NV_ERROR;
}
s32 nv_emmc_write(u8* ptr, u32 size, u32 count, FILE* fp)
{
u32 ret = NV_ERROR;
u32 len = size*count;
struct nv_emmc_file_header_stru* fd = (struct nv_emmc_file_header_stru*)fp;
struct nv_file_info_stru* file_info;
nv_file_debug(NV_FILE_WRITE_API,0,0,size,count);
if((NULL == fd)||(fd->fp != fd))
{
nv_file_debug(NV_FILE_WRITE_API,1,0,size,count);
goto nv_flash_write_err;
}
switch(fd->emmc_type)
{
case NV_FILE_BACKUP:
file_info = &g_emmc_info.bak_sec;
break;
case NV_FILE_SYS_NV:
file_info = &g_emmc_info.sys_nv;
break;
case NV_FILE_DEFAULT:
file_info = &g_emmc_info.def_sec;
break;
default:
return -1;
}
ret = (u32)nv_mtd_write(fd,(fd->off+fd->seek),len,ptr);
if(ret)
{
nv_file_debug(NV_FILE_WRITE_API,3,ret,len,fd->emmc_type);
goto nv_flash_write_err;
}
file_info->magic_num = NV_FILE_EXIST;
file_info->len = len;
file_info->off = 0;
fd->seek += len;
return (s32)len;
nv_flash_write_err:
nv_mntn_record("\n[%s]\n",__func__);
nv_emmc_help(NV_FILE_WRITE_API);
return BSP_ERR_NV_INVALID_PARAM;
}
s32 nv_emmc_seek(FILE* fp,s32 offset,s32 whence)
{
u32 ret = 0;
struct nv_emmc_file_header_stru* fd = (struct nv_emmc_file_header_stru*)fp;
nv_file_debug(NV_FILE_SEEK_API,0,(u32)offset,(u32)whence,0);
if((NULL == fd)||(fd->fp != fd))
{
nv_file_debug(NV_FILE_SEEK_API,1,(u32)offset,(u32)whence,0);
goto out;
}
ret = fd->seek;
switch(whence)
{
case SEEK_SET:
nv_file_debug(NV_FILE_SEEK_API,2,(u32)offset,(u32)whence,ret);
ret = (u32)offset;
break;
case SEEK_CUR:
nv_file_debug(NV_FILE_SEEK_API,3,(u32)offset,(u32)whence,ret);
ret += (u32)offset;
break;
case SEEK_END:
nv_file_debug(NV_FILE_SEEK_API,4,(u32)offset,(u32)whence,ret);
ret = fd->length + (u32)offset;
break;
default:
nv_file_debug(NV_FILE_SEEK_API,5,(u32)offset,(u32)whence,ret);
goto out;
}
fd->seek = ret;
return NV_OK;
out:
printf("\n[%s]\n",__func__);
nv_emmc_help(NV_FILE_SEEK_API);
return BSP_ERR_NV_INVALID_PARAM;
}
s32 nv_emmc_remove(const s8* path)
{
s32 ret = -1;
struct nv_emmc_file_header_stru* fd = NULL;
struct erase_info erase = {0,};
struct mtd_info* mtd = NULL;
u32 i = 0;
nv_file_debug(NV_FILE_REMOVE_API,0,0,0,0);
for(i=0;i<NV_FILE_BUTT;i++)
{
if(0 == strcmp(path,g_nv_file[i].path))
{
fd = &g_nv_file[i];
break;
}
}
if(NULL == fd)
{
nv_file_debug(NV_FILE_REMOVE_API,1,0,0,0);
return -1;
}
switch(fd->emmc_type)
{
case NV_FILE_DLOAD:
g_emmc_info.nv_dload.nv_bin.magic_num = NV_FLASH_NULL;
break;
case NV_FILE_BACKUP:
memset(&g_emmc_info.bak_sec,NV_FLASH_FILL,sizeof(struct nv_file_info_stru));
goto flash_erase;
case NV_FILE_CUST_CARD_1:
g_emmc_info.nv_dload.cust_xml[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_CARD_1:
g_emmc_info.nv_dload.xnv_xml[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_CUST_CARD_2:
g_emmc_info.nv_dload.cust_xml[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_CARD_2:
g_emmc_info.nv_dload.xnv_xml[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_MAP_CARD_1:
g_emmc_info.nv_dload.xnv_map[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_MAP_CARD_2:
g_emmc_info.nv_dload.xnv_map[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_DEFAULT:
memset(&g_emmc_info.def_sec,NV_FLASH_FILL,sizeof(struct nv_file_info_stru));
goto flash_erase;
case NV_FILE_SYS_NV:
memset(&g_emmc_info.sys_nv,NV_FLASH_FILL,sizeof(g_emmc_info.sys_nv));
goto flash_erase;
default:
return BSP_ERR_NV_INVALID_PARAM;
}
if(true == nv_dload_exist_file())
{
return NV_OK;
}
flash_erase:
mtd = get_mtd_device_nm(fd->name);
if(IS_ERR(mtd))
{
printf("[%s]:get mtd device err! %s\n",__func__,fd->name);
return -1;
}
erase.addr = 0;
erase.mtd = mtd;
erase.len = mtd->size;
erase.callback = NULL;
erase.priv = 0;
erase.time = 10000;
erase.retries = 2;
ret = mtd_erase(mtd,&erase);
mtd_sync(mtd);
put_mtd_device(mtd);
if(ret)
{
nv_file_debug(NV_FILE_REMOVE_API,2,(u32)ret,fd->emmc_type,0);
printf("[%s]:ret 0x%x,mtd->name %s\n",__func__,ret,mtd->name);
return ret;
}
return NV_OK;
}
FILE* nv_emmc_open(const s8* path,const s8* mode)
{
u32 ret = NV_ERROR;
u32 i = 0;
struct nv_emmc_file_header_stru* fd = NULL;
u32 offset = 0;
u32 len = 0;
struct mtd_info* mtd = NULL;
nv_file_debug(NV_FILE_OPEN_API,0,0,0,0);
for(i=0; i<NV_FILE_BUTT; i++)
{
if(0 == strcmp(path,g_nv_file[i].path))
{
fd = &g_nv_file[i];
mtd = get_mtd_device_nm(fd->name);
if(IS_ERR(mtd))
{
printf("[%s]:get mtd device err! %s\n",__func__,fd->name);
return NULL;
}
g_nv_file[i].mtd = mtd;
break;
}
}
if(NULL == fd)
{
nv_file_debug(NV_FILE_OPEN_API,1,0,0,0);
return NULL;
}
osl_sem_down(&fd->file_sem);
switch(fd->emmc_type)
{
case NV_FILE_DLOAD:
ret = nv_get_nvbin_info(mode,&offset,&len);
break;
case NV_FILE_BACKUP:
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_BACKUP].name,&g_emmc_info.bak_sec);
ret |= nv_get_back_info(mode,&offset,&len);
break;
case NV_FILE_XNV_CARD_1:
ret = nv_get_xnv_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_CUST_CARD_1:
ret = nv_get_cust_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_XNV_CARD_2:
ret = nv_get_xnv_info(NV_USIMM_CARD_2,&offset,&len);
break;
case NV_FILE_CUST_CARD_2:
ret = nv_get_cust_info(NV_USIMM_CARD_2,&offset,&len);
break;
case NV_FILE_SYS_NV:
ret = nv_get_sys_nv_info(mode,&offset,&len);
break;
case NV_FILE_DEFAULT:
ret = nv_get_default_info(mode,&offset,&len);
break;
case NV_FILE_XNV_MAP_CARD_1:
ret = nv_get_xnv_map_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_XNV_MAP_CARD_2:
ret = nv_get_xnv_map_info(NV_USIMM_CARD_2,&offset,&len);
break;
default:
ret = BSP_ERR_NV_INVALID_PARAM;
}
if(NV_OK != ret)
{
put_mtd_device(fd->mtd);
osl_sem_up(&fd->file_sem);
nv_file_debug(NV_FILE_OPEN_API,3,fd->emmc_type,ret,0);
return NULL;
}
fd->ops ++;
fd->seek = 0;
fd->length = len;
fd->off = offset;
fd->fp = fd;
return fd;
}
