XML_RESULT_ENUM_UINT32 xml_createaproperty( void )
{
/* 分配属性名内存,+1为保留字符串结束符用 */
xml_ctrl.g_stlxmlcurrentnode.stproperty.ulnamelength = 0; /* 已使用的长度 */
xml_ctrl.g_stlxmlcurrentnode.stproperty.pcpropertyname
= (s8*)nv_malloc(
XML_NODE_LABEL_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_stlxmlcurrentnode.stproperty.pcpropertyname)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
/* 分配属性值内存,+1为保留字符串结束符用 */
xml_ctrl.g_stlxmlcurrentnode.stproperty.ulvaluelength = 0; /* 已使用的长度 */
xml_ctrl.g_stlxmlcurrentnode.stproperty.pcpropertyvalue
= (s8*)nv_malloc(
XML_NODE_LABEL_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_stlxmlcurrentnode.stproperty.pcpropertyvalue)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
return XML_RESULT_SUCCEED;
}
nvlist_t *
nvlist_recv(int sock, int flags)
{
struct nvlist_header nvlhdr;
nvlist_t *nvl, *ret;
unsigned char *buf;
size_t nfds, size, i;
int *fds;
if (buf_recv(sock, &nvlhdr, sizeof(nvlhdr)) == -1)
return (NULL);
if (!nvlist_check_header(&nvlhdr))
return (NULL);
nfds = (size_t)nvlhdr.nvlh_descriptors;
size = sizeof(nvlhdr) + (size_t)nvlhdr.nvlh_size;
buf = nv_malloc(size);
if (buf == NULL)
return (NULL);
memcpy(buf, &nvlhdr, sizeof(nvlhdr));
ret = NULL;
fds = NULL;
if (buf_recv(sock, buf + sizeof(nvlhdr), size - sizeof(nvlhdr)) == -1)
goto out;
if (nfds > 0) {
fds = nv_malloc(nfds * sizeof(fds[0]));
if (fds == NULL)
goto out;
if (fd_recv(sock, fds, nfds) == -1)
goto out;
}
nvl = nvlist_xunpack(buf, size, fds, nfds, flags);
if (nvl == NULL) {
ERRNO_SAVE();
for (i = 0; i < nfds; i++)
close(fds[i]);
ERRNO_RESTORE();
goto out;
}
ret = nvl;
out:
ERRNO_SAVE();
nv_free(buf);
nv_free(fds);
ERRNO_RESTORE();
return (ret);
}
XML_RESULT_ENUM_UINT32 xml_createanode(void)
{
XML_RESULT_ENUM_UINT32 returnval = XML_RESULT_SUCCEED;
/* 创建一个新属性 */
returnval = xml_createaproperty();
if(XML_RESULT_SUCCEED != returnval)
{
return returnval;
}
/* 分配节点标签内存,+1为保留字符串结束符用*/
xml_ctrl.g_stlxmlcurrentnode.ullabellength = 0; /* 已使用的长度 */
xml_ctrl.g_stlxmlcurrentnode.pcnodelabel = (s8*)nv_malloc(
XML_NODE_LABEL_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_stlxmlcurrentnode.pcnodelabel)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
/* 分配节点结尾独立标签内存,+1为保留字符串结束符用 */
xml_ctrl.g_stlxmlcurrentnode.ullabelendlength = 0; /* 已使用的长度 */
xml_ctrl.g_stlxmlcurrentnode.pcnodelabelend = (s8*)nv_malloc(
XML_NODE_LABEL_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_stlxmlcurrentnode.pcnodelabelend)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
/* 分配节点值内存,+1为保留字符串结束符用 */
xml_ctrl.g_stlxmlcurrentnode.ulvaluelength = 0; /* 已使用的长度 */
xml_ctrl.g_stlxmlcurrentnode.pcnodevalue = (s8*)nv_malloc(
XML_NODE_VALUE_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_stlxmlcurrentnode.pcnodevalue)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
return returnval;
}
u32 nv_crc_write_test04(void)
{
struct nv_ref_data_info_stru nvArray[10] = {};
u32 count = 0;
u32 i = 0;
u32 ret = 0;
u8 *pOldNvData = NULL;
u8 *pNewNvData = NULL;
pOldNvData = (u8 *)nv_malloc(NV_MAX_UNIT_SIZE);
pNewNvData = (u8 *)nv_malloc(NV_MAX_UNIT_SIZE);
if((pOldNvData == NULL)||(pNewNvData == NULL))
{
nv_printf("malloc error 1111\n");
return NV_ERROR;
}
count = nv_test_find_edge_nv(nvArray);
for(i = 0; i < count; i++)
{
ret = bsp_nvm_read(nvArray[i].itemid, (u8 *)pOldNvData, nvArray[i].nv_len);
if(ret)
{
nv_printf("read error 222, nvid = 0x%x\n", nvArray[i].itemid);
return ret;
}
pOldNvData[0]+=2;
ret = bsp_nvm_write(nvArray[i].itemid, (u8 *)pOldNvData, nvArray[i].nv_len);
if(ret)
{
nv_printf("read error 3333, nvid = 0x%x\n", nvArray[i].itemid);
return ret;
}
ret = bsp_nvm_read(nvArray[i].itemid, (u8 *)pNewNvData, nvArray[i].nv_len);
if((ret)||(pNewNvData[0] != pOldNvData[0]))
{
nv_printf("read error 4444, nvid = 0x%x\n", nvArray[i].itemid);
return ret;
}
ret = nv_check_ddr_crc();
if(ret)
{
nv_printf("read error 5555, nvid = 0x%x\n", nvArray[i].itemid);
return ret;
}
}
nv_free(pOldNvData);
nv_free(pNewNvData);
return NV_OK;
}
nv_matrix_t *nv_matrix_list_alloc(int n, int m, int list)
{
void *mem;
int step = n * sizeof(float);//(n + 4 - (n & 3)) * sizeof(float); // SSE2
int mem_size = sizeof(nv_matrix_t) + (step * m + 0x20) * list;
nv_matrix_t *matrix = (nv_matrix_t *)nv_malloc(mem_size);
if (matrix == NULL) {
return NULL;
}
mem = ((char *)matrix) + sizeof(nv_matrix_t);
matrix->v = (float *)(((char *)mem) + 0x10 - ((unsigned int)mem & 0xf));
matrix->list = list;
matrix->n = n;
matrix->m = m;
matrix->cols = m;
matrix->rows = 1;
matrix->step = step / sizeof(float);
matrix->alias = 0;
matrix->list_step = matrix->step * matrix->m;
return matrix;
}
/*
* Function: nv_file_open
* Discription: open file
* Parameter: path : file path
* mode : file ops type etc:"r+","rb+","w+","wb+"
* Output : file pointer
*/
FILE* nv_file_open(const s8* path,const s8* mode)
{
struct nv_file_p* fp = NULL;
fp = (struct nv_file_p*)nv_malloc(sizeof(struct nv_file_p));
if(!fp)
{
return NULL;
}
#ifdef BSP_CONFIG_HI3630
if(0 == strcmp((char*)path,(char*)NV_IMG_PATH))
#else
if(0 == strcmp((char*)path,(char*)NV_IMG_PATH))
#endif
{
fp->fd = BSP_fopen((char*)path,(char*)mode);
fp->stor_type = NV_FILE_STOR_FS;
}
else
{
fp->fd = g_nv_ops.fo(path,mode);
fp->stor_type = NV_FILE_STOR_NON_FS;
}
if(NULL == fp->fd)
{
nv_free(fp);
return NULL;
}
return fp;
}
u32 nv_read_part_test(u32 nvid,u32 off,u32 len)
{
u32 ret;
u8* tempdata;
u32 i= 0;
tempdata = (u8*)nv_malloc(len +1);
if(NULL == tempdata)
{
return BSP_ERR_NV_MALLOC_FAIL;
}
ret = bsp_nvm_readpart(nvid,off,tempdata,len);
if(NV_OK != ret)
{
nv_free(tempdata);
return BSP_ERR_NV_READ_DATA_FAIL;
}
for(i=0;i<len;i++)
{
if((i%16) == 0)
{
printf("\n");
}
printf("%2.2x ",(u8)(*(tempdata+i)));
}
printf("\n");
nv_free(tempdata);
return NV_OK;
}
nv_matrix_t *
nv_vector_shallow_reshape3d(nv_matrix_t *vec, int vec_j,
int n, int rows, int cols)
{
nv_matrix_t *mat;
NV_ASSERT(vec->n == n * rows * cols);
NV_ASSERT(n < 8 || n % 8 == 0); // n >= 8 && n % 8 != 0, AVX does not work
if (!(vec->n == n * rows * cols && (n < 8 || n % 8 == 0))) {
return NULL;
}
mat = (nv_matrix_t *)nv_malloc(sizeof(nv_matrix_t));
mat->list = 1;
mat->n = n;
mat->m = rows * cols;
mat->rows = rows;
mat->cols = cols;
mat->v = &NV_MAT_V(vec, vec_j, 0);
mat->step = n;
mat->list_step = (int64_t)mat->step * mat->m;
mat->alias = 1;
return mat;
}
u32 nv_read_write_test(void)
{
u32 i;
u32 ret;
struct nv_ctrl_file_info_stru* ctrl_info = (struct nv_ctrl_file_info_stru*)NV_GLOBAL_CTRL_INFO_ADDR;
struct nv_ref_data_info_stru* ref_info = (struct nv_ref_data_info_stru*)(NV_GLOBAL_CTRL_INFO_ADDR+NV_GLOBAL_CTRL_INFO_SIZE\
+NV_GLOBAL_FILE_ELEMENT_SIZE*ctrl_info->file_num);
u8* pdata;
pdata = (u8*)nv_malloc(3072);
if(NULL == pdata)
{
return NV_ERROR;
}
for(i = 0;i<ctrl_info->ref_count;i++)
{
printf("*****************read & write 0x%x****************\n",ref_info->itemid);
ret = bsp_nvm_read(ref_info->itemid,pdata,ref_info->nv_len);
if(ret)
{
nv_free(pdata);
return ret;
}
ret = bsp_nvm_write(ref_info->itemid,pdata,ref_info->nv_len);
if(ret)
{
nv_free(pdata);
return ret;
}
ref_info++;
}
nv_free(pdata);
return NV_OK;
}
/*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;
}
/*
*get file info in back ,default,nvdload
*/
u32 nv_sec_file_info_init(const s8* name,struct nv_file_info_stru* sec_info)
{
u32 ret = NV_ERROR;
u32 file_len = 0;
struct nv_file_info_stru info;
struct nv_ctrl_file_info_stru ctrl_info;
u8* file_info;
/*first: read nv ctrl file*/
ret = (u32)bsp_nand_read((char*)name,0,&ctrl_info,sizeof(ctrl_info),NULL);
if(NAND_OK != ret)
{
printf("[%s]:patrition name %s,get file magic fail ret 0x%x,\n",__func__,name,ret);
return ret;
}
/*second :check magic num in file head*/
if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM)
{
printf("[%s]:enter this way 1111! %s\n",__func__,name);
return NV_OK;
}
/*third: read all nv ctrl file*/
file_info = (u8*)nv_malloc(ctrl_info.file_size+1);
if(NULL == file_info)
{
printf("[%s]:enter this way 2222! %s\n",__func__,name);
return BSP_ERR_NV_MALLOC_FAIL;
}
ret = (u32)bsp_nand_read((char*)name,sizeof(struct nv_ctrl_file_info_stru),file_info,ctrl_info.file_size,NULL);
if(NAND_OK != ret)
{
printf("[%s]:enter this way 3333! %s\n",__func__,name);
goto init_end;
}
/*fourth: count nv file len base the ctrl file info*/
ret = nv_get_bin_crc_file_len(&ctrl_info,(struct nv_file_list_info_stru*)file_info,&file_len);
if(ret)
{
printf("[%s]:enter this way 4444! %s\n",__func__,name);
goto init_end;
}
info.len = file_len;
info.magic_num = NV_FILE_EXIST;
info.off = 0;
memcpy(sec_info,&info,sizeof(info));
init_end:
nv_free(file_info);
return NV_OK;
}
XML_RESULT_ENUM_UINT32 xml_procinit(s8* map_path)
{
XML_RESULT_ENUM_UINT32 returnval;
/* 初始化全局变量 */
xml_initglobal();
/* 获得当前单板的product id*/ /*? UDP*/
xml_getproductid();
/*获取当前跳转信息*/
xml_getjumpinfo(map_path);
/* 创建节点信息 */
returnval = xml_createanode();
if (XML_RESULT_SUCCEED != returnval)
{
return returnval;
}
/* 申请存放NV Item的值的缓冲区,+1为保留字符串结束符用 */ /*分配固定空间*/
xml_ctrl.g_puclnvitem = (u8 *)nv_malloc(
XML_NODE_VALUE_BUFF_LENGTH_ORIGINAL+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_puclnvitem)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
/* 申请读取文件数据的缓冲区,+1为保留字符串结束符用 */ /*是否分配空间?*/
xml_ctrl.g_pclfilereadbuff = (s8*)nv_malloc(
XML_FILE_READ_BUFF_SIZE+2*EMMC_BLOCK_SIZE);
if (NULL == xml_ctrl.g_pclfilereadbuff)
{
xml_write_error_log(__LINE__, 0, XML_RESULT_FALIED_MALLOC);
return XML_RESULT_FALIED_MALLOC;
}
return XML_RESULT_SUCCEED;
}
nv_lr_t *
nv_lr_alloc(int n, int k)
{
nv_lr_t *lr = (nv_lr_t *)nv_malloc(sizeof(nv_lr_t));
lr->n = n;
lr->k = k;
lr->w = nv_matrix_alloc(lr->n, k);
nv_matrix_zero(lr->w);
return lr;
}
u32 nvm_read_randex(u32 nvid,u32 modem_id)
{
u32 ret; u8* tempdata; u32 i= 0;
struct nv_ref_data_info_stru ref_info = {0};
struct nv_file_list_info_stru file_info = {0};
ret = nv_search_byid(nvid, (u8*)NV_GLOBAL_CTRL_INFO_ADDR,&ref_info,&file_info);
if(NV_OK != ret)
{
return ret;
}
if(ref_info.nv_len == 0)
{
return NV_ERROR;
}
/*lint -save -e515 -e516*/
printf_nv("[0x%x]:len 0x%x,off 0x%x,file id %d\n",nvid,ref_info.nv_len,ref_info.nv_off,ref_info.file_id);
printf_nv("[0x%x]:dsda 0x%x\n",nvid,ref_info.modem_num);
/*lint -restore*/
/*lint -save -e516*/
tempdata = (u8*)nv_malloc(ref_info.nv_len +1);
/*lint -restore +e516*/
if(NULL == tempdata)
{
return BSP_ERR_NV_MALLOC_FAIL;
}
ret = bsp_nvm_dcread(modem_id,nvid,tempdata,ref_info.nv_len);
if(NV_OK != ret)
{
nv_free(tempdata);
return BSP_ERR_NV_READ_DATA_FAIL;
}
/*lint -save -e515 -e516*/
for(i=0;i<ref_info.nv_len;i++)
{
if((i%32) == 0)
{
printf_nv("\n");
}
printf_nv("%02x ",(u8)(*(tempdata+i)));
}
printf_nv("\n\n");
/*lint -restore*/
nv_free(tempdata);
return 0;
}
nv_plsi_t *
nv_plsi_alloc(int d, int w, int k)
{
nv_plsi_t *p = (nv_plsi_t *)nv_malloc(sizeof(nv_plsi_t));
p->k = k;
p->d = d;
p->w = w;
p->z = nv_matrix_alloc(p->k, 1);
p->dz = nv_matrix_alloc(p->k, p->d);
p->wz = nv_matrix_alloc(p->k, p->w);
return p;
}
nv_matrix_t *
nv_matrix_alias(const nv_matrix_t *parent, int sn, int sm, int n, int m)
{
nv_matrix_t *matrix = (nv_matrix_t *)nv_malloc(sizeof(nv_matrix_t));
matrix->list = 1;
matrix->n = n;
matrix->m = m;
matrix->rows = 1;
matrix->cols = m;
matrix->v = &parent->v[sm * parent->step + sn];
matrix->step = parent->step;
matrix->list_step = matrix->step * matrix->m;
matrix->alias = 1;
return matrix;
}
nv_mlp_t *nv_mlp_alloc(int input, int hidden, int k)
{
nv_mlp_t *mlp = (nv_mlp_t *)nv_malloc(sizeof(nv_mlp_t));
mlp->input = input;
mlp->hidden = hidden;
mlp->output = k;
mlp->dropout = 0.0f;
mlp->noise = 0.0f;
mlp->input_w = nv_matrix_alloc(input, hidden);
mlp->hidden_w = nv_matrix_alloc(mlp->input_w->m, k);
mlp->input_bias = nv_matrix_alloc(1, hidden);
mlp->hidden_bias = nv_matrix_alloc(1, k);
return mlp;
}
nv_matrix_t *
nv_matrix_list_get(const nv_matrix_t *parent, int list)
{
nv_matrix_t *matrix = (nv_matrix_t *)nv_malloc(sizeof(nv_matrix_t));
matrix->list = 1;
matrix->n = parent->n;
matrix->m = parent->m;
matrix->rows = parent->rows;
matrix->cols = parent->cols;
matrix->v = &NV_MAT_LIST_V(parent, list, 0, 0);
matrix->step = parent->step;
matrix->list_step = parent->list_step;
matrix->alias = 1;
return matrix;
}
void xml_getjumpinfo(s8* map_path)
{
FILE* fp = NULL;
s32 ret = 0;
u32 file_len;
XNV_MAP_HEAD_STRU* map_file = NULL;
XNV_MAP_PRODUCT_INFO product_info = {0};
if(!map_path)
return;
fp = nv_emmc_open(map_path,(s8*)NV_FILE_READ);
if(!fp)
return;
file_len = nv_boot_get_file_len(fp);
/* coverity[negative_returns] */
map_file = (XNV_MAP_HEAD_STRU*)nv_malloc(file_len+2*EMMC_BLOCK_SIZE);
if(!map_file)
{
nv_emmc_close(fp);
return;
}
ret = nv_emmc_read((u8*)map_file,1,file_len,fp);
/*lint -save -e737*/
if(ret != file_len)
{
goto out;
}
/*lint -restore +e737*/
ret = xml_search_productinfo((u32)(xml_ctrl.g_stlxmlproductid),(u8*)map_file,&product_info);
if(ret)
goto out;
memcpy(&xml_ctrl.g_stlxmljumpinfo,&product_info,sizeof(product_info));
xml_ctrl.g_stlxmljumpflag = XML_DECODE_STATUS_JUMP;
nv_emmc_close(fp);
nv_free(map_file);
return;
out:
nv_emmc_close(fp);
nv_free(map_file);
memset(&xml_ctrl.g_stlxmljumpinfo,0,sizeof(xml_ctrl.g_stlxmljumpinfo));
xml_ctrl.g_stlxmljumpflag = XML_DECODE_STATUS_NOJUMP;
return;
}
int *
nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
{
size_t nitems;
int *fds;
nitems = nvlist_ndescriptors(nvl);
fds = nv_malloc(sizeof(fds[0]) * (nitems + 1));
if (fds == NULL)
return (NULL);
if (nitems > 0)
nvlist_xdescriptors(nvl, fds);
fds[nitems] = -1;
if (nitemsp != NULL)
*nitemsp = nitems;
return (fds);
}
nvlist_t *
nvlist_create(int flags)
{
nvlist_t *nvl;
PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
nvl = nv_malloc(sizeof(*nvl));
if (nvl == NULL)
return (NULL);
nvl->nvl_error = 0;
nvl->nvl_flags = flags;
nvl->nvl_parent = NULL;
TAILQ_INIT(&nvl->nvl_head);
nvl->nvl_magic = NVLIST_MAGIC;
return (nvl);
}
nv_mlp3_t *nv_mlp3_alloc(int input, int hidden1, int hidden2, int k)
{
nv_mlp3_t *mlp = (nv_mlp3_t *)nv_malloc(sizeof(nv_mlp3_t));
mlp->input = input;
mlp->hidden1 = hidden1;
mlp->hidden2 = hidden2;
mlp->output = k;
mlp->input_w = nv_matrix_alloc(input, hidden1);
mlp->hidden1_w = nv_matrix_alloc(hidden1, hidden2);
mlp->hidden2_w = nv_matrix_alloc(hidden2, k);
mlp->input_bias = nv_matrix_alloc(1, hidden1);
mlp->hidden1_bias = nv_matrix_alloc(1, hidden2);
mlp->hidden2_bias = nv_matrix_alloc(1, k);
return mlp;
}
u32 nv_read_rand_test(u32 nvid)
{
u32 ret;
u8* tempdata;
u32 i= 0;
struct nv_ref_data_info_stru ref_info = {0};
struct nv_file_list_info_stru file_info = {0};
ret = nv_search_byid(nvid, (u8*)NV_GLOBAL_CTRL_INFO_ADDR,&ref_info,&file_info);
if(NV_OK != ret)
{
return ret;
}
if(ref_info.nv_len == 0)
{
return NV_ERROR;
}
tempdata = (u8*)nv_malloc((u32)(ref_info.nv_len) +1);
if(NULL == tempdata)
{
return BSP_ERR_NV_MALLOC_FAIL;
}
ret = bsp_nvm_read(nvid,tempdata,ref_info.nv_len);
if(NV_OK != ret)
{
nv_free(tempdata);
return BSP_ERR_NV_READ_DATA_FAIL;
}
for(i=0;i<ref_info.nv_len;i++)
{
if((i%16) == 0)
{
printf("\n");
}
printf("%2.2x ",(u8)(*(tempdata+i)));
}
printf("\n");
nv_free(tempdata);
return NV_OK;
}
u32 nv_function_test(void)
{
u32 i;
u32 ret;
struct nv_ctrl_file_info_stru* ctrl_info = (struct nv_ctrl_file_info_stru*)NV_GLOBAL_CTRL_INFO_ADDR;
struct nv_ref_data_info_stru* ref_info = (struct nv_ref_data_info_stru*)(NV_GLOBAL_CTRL_INFO_ADDR+NV_GLOBAL_CTRL_INFO_SIZE\
+NV_GLOBAL_FILE_ELEMENT_SIZE*ctrl_info->file_num);
u8* pdata;
u32 start,end;
start = bsp_get_slice_value();
pdata = (u8*)nv_malloc(3072);
if(NULL == pdata)
{
return NV_ERROR;
}
for(i = 0;i<100;i++)
{
printf("*****************read & write 0x%x****************\n",ref_info->itemid);
ret = bsp_nvm_read(ref_info->itemid,pdata,ref_info->nv_len);
if(ret)
{
nv_free(pdata);
return ret;
}
ret = bsp_nvm_write(ref_info->itemid,pdata,ref_info->nv_len);
if(ret)
{
nv_free(pdata);
return ret;
}
ref_info++;
}
end = bsp_get_slice_value();
nv_free(pdata);
printf("[%s]:slice 0x%x\n",__func__,end-start);
return NV_OK;
}
nv_pstable_t *
nv_pstable_alloc_ex(int vector_dim, int l, int k, float r)
{
nv_pstable_t *ps = (nv_pstable_t *)nv_malloc(sizeof(nv_pstable_t));
int m, n;
memset(ps, 0, sizeof(*ps));
ps->l = l;
ps->k = k;
ps->r = r;
ps->a = nv_matrix3d_alloc(vector_dim, ps->l, ps->k);
ps->b = nv_matrix3d_alloc(1, ps->l, ps->k);
ps->r1 = nv_matrix3d_alloc(1, ps->l, ps->k);
ps->r2 = nv_matrix3d_alloc(1, ps->l, ps->k);
for (m = 0; m < ps->a->m; ++m) {
for (n = 0; n < ps->a->n; ++n) {
NV_MAT_V(ps->a, m, n) = nv_gaussian_rand(0.0f, 1.0f);
}
}
for (m = 0; m < ps->b->m; ++m) {
for (n = 0; n < ps->b->n; ++n) {
NV_MAT_V(ps->b, m, n) = nv_rand() * ps->r;
}
}
for (m = 0; m < ps->r1->m; ++m) {
for (n = 0; n < ps->r1->n; ++n) {
NV_MAT_V(ps->r1, m, n) = NV_FLOOR(
nv_rand() * NV_PSTABLE_HASH_MAX * 2.0f - NV_PSTABLE_HASH_MAX
);
NV_MAT_V(ps->r2, m, n) = NV_FLOOR(
nv_rand() * NV_PSTABLE_HASH_MAX * 2.0f - NV_PSTABLE_HASH_MAX
);
}
}
return ps;
}
u32 nv_write_test_08(u32 itemid)
{
struct nv_file_list_info_stru file_info = {};
struct nv_ref_data_info_stru ref_info = {};
u8* pData = NULL;
u32 ret = 0;
pData = (u8*)nv_malloc(2*2048);
if(NULL == pData)
{
nv_printf("alloc error\n");
return NV_ERROR;
}
ret = nv_search_byid(itemid, (u8 *)NV_GLOBAL_CTRL_INFO_ADDR, &ref_info, &file_info);
if(ret)
{
nv_printf("nv_search_byid error\n");
nv_free(pData);
return ret;
}
ret = bsp_nvm_read(itemid, pData, ref_info.nv_len);
if(ret)
{
nv_printf("bsp_nvm_read error, ret = 0x%x 1111\n", ret);
return ret;
}
pData[0]++;
ret = bsp_nvm_write(itemid, pData, ref_info.nv_len);
if(ret)
{
nv_printf("bsp_nvm_read error, ret = 0x%x 2222\n", ret);
return ret;
}
nv_free(pData);
return NV_OK;
}
void
nv_plsi_emstep(nv_plsi_t *p, const nv_matrix_t *data, float tem_beta)
{
int i, z, w, d;
float zsum;
float zfactor = 0.0f;
nv_matrix_t *zfq= nv_matrix_alloc(p->k, 1);
nv_matrix_t *zdw_sum = nv_matrix_alloc(p->w, p->d);
#ifdef _OPENMP
int threads = nv_omp_procs();
#else
int threads = 1;
#endif
nv_matrix_t **zdw_val = (nv_matrix_t **)nv_malloc(sizeof(nv_matrix_t *) * threads);
for (i = 0; i < threads; ++i) {
zdw_val[i] = nv_matrix_alloc(p->w, p->d);
}
/* sum */
#ifdef _OPENMP
#pragma omp parallel for private(w, z)
#endif
for (d = 0; d < p->d; ++d) {
for (w = 0; w < p->w; ++w) {
float sum = 0.0f;
for (z = 0; z < p->k; ++z) {
sum += NV_MAT_V(p->dz, d, z) * (powf(NV_MAT_V(p->wz, w, z) * NV_MAT_V(p->z, 0, z), tem_beta));
}
if (sum != 0.0f) {
NV_MAT_V(zdw_sum, d, w) = 1.0f / sum;
} else {
NV_MAT_V(zdw_sum, d, w) = 0.0f;
}
}
}
zsum = 0.0f;
#ifdef _OPENMP
#pragma omp parallel for private(d, w) reduction(+:zsum)
#endif
for (z = 0; z < p->k; ++z) {
float sum = 0.0f;
float factor = 0.0f;
#ifdef _OPENMP
int thread_idx = nv_omp_thread_id();
#else
int thread_idx = 0;
#endif
/* zdw val */
for (d = 0; d < p->d; ++d) {
for (w = 0; w < p->w; ++w) {
/* (t-1) dz,wz,z */
NV_MAT_V(zdw_val[thread_idx], d, w) = NV_MAT_V(p->dz, d, z)
* (powf(NV_MAT_V(p->wz, w, z) * NV_MAT_V(p->z, 0, z), tem_beta)) * NV_MAT_V(zdw_sum, d, w);
}
}
for (d = 0; d < p->d; ++d) {
for (w = 0; w < p->w; ++w) {
sum += NV_MAT_V(data, d, w) * NV_MAT_V(zdw_val[thread_idx], d, w);
}
}
if (sum != 0.0f) {
factor = 1.0f / sum;
}
for (d = 0; d < p->d; ++d) {
NV_MAT_V(p->dz, d, z) = 0.0f;
}
for (w = 0; w < p->w; ++w) {
NV_MAT_V(p->wz, w, z) = 0.0f;
}
/* p(d,z), p(w,z) */
for (d = 0; d < p->d; ++d) {
for (w = 0; w < p->w; ++w) {
float ndwf = NV_MAT_V(data, d, w) * NV_MAT_V(zdw_val[thread_idx], d, w) * factor;
NV_MAT_V(p->dz, d, z) += ndwf;
NV_MAT_V(p->wz, w, z) += ndwf;
}
}
zsum += sum;
NV_MAT_V(zfq, 0, z) = sum;
}
/* p(z) */
if (zsum != 0.0f) {
zfactor = 1.0f / zsum;
}
for (z = 0; z < p->k; ++z) {
NV_MAT_V(p->z, 0, z) = NV_MAT_V(zfq, 0, z) * zfactor;
}
for (i = 0; i < threads; ++i) {
nv_matrix_free(&zdw_val[i]);
}
nv_free(zdw_val);
nv_matrix_free(&zfq);
nv_matrix_free(&zdw_sum);
}
void show_emmc_info(void)
{
struct nv_dload_packet_head_stru nv_dload;
struct nv_ctrl_file_info_stru ctrl_info;
u8* file_info;
s32 ret = -1 ;
printf("\n******************img info*********************\n");
ret = bsp_nand_read((char*)NV_SYS_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL);
if(ret)
return;
if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM)
{
ctrl_info.file_size = 144;
}
file_info = (u8*)nv_malloc(ctrl_info.file_size+1);
if(NULL == file_info)
{
return;
}
ret = bsp_nand_read((char*)NV_SYS_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL);
if(ret)
return;
printf("\n********sys mem info*******\n");
printf("nv :flag 0x%x,off 0x%x,len 0x%x\n",g_emmc_info.sys_nv.magic_num,\
g_emmc_info.sys_nv.off,g_emmc_info.sys_nv.len);
printf("\n************sys info in nand**************\n");
printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\
ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num);
printf("\n******************dload info*******************\n");
ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL);
if(ret)
return;
printf("\n********dload mem info*******\n");
printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.nv_bin.magic_num,\
g_emmc_info.nv_dload.nv_bin.len,g_emmc_info.nv_dload.nv_bin.off);
printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_xml[0].magic_num,\
g_emmc_info.nv_dload.xnv_xml[0].len,g_emmc_info.nv_dload.xnv_xml[0].off);
printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.cust_xml[0].magic_num,\
g_emmc_info.nv_dload.cust_xml[0].len,g_emmc_info.nv_dload.cust_xml[0].off);
printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_xml[1].magic_num,\
g_emmc_info.nv_dload.xnv_xml[1].len,g_emmc_info.nv_dload.xnv_xml[1].off);
printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.cust_xml[1].magic_num,\
g_emmc_info.nv_dload.cust_xml[1].len,g_emmc_info.nv_dload.cust_xml[1].off);
printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_map[0].magic_num,\
g_emmc_info.nv_dload.xnv_map[0].len,g_emmc_info.nv_dload.xnv_map[0].off);
printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_map[1].magic_num,\
g_emmc_info.nv_dload.xnv_map[1].len,g_emmc_info.nv_dload.xnv_map[1].off);
printf("\n********dload mtd info*******\n");
printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.nv_bin.magic_num,\
nv_dload.nv_bin.len,nv_dload.nv_bin.off);
printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[0].magic_num,\
nv_dload.xnv_xml[0].len,nv_dload.xnv_xml[0].off);
printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[0].magic_num,\
nv_dload.cust_xml[0].len,nv_dload.cust_xml[0].off);
printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[1].magic_num,\
nv_dload.xnv_xml[1].len,nv_dload.xnv_xml[1].off);
printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[1].magic_num,\
nv_dload.cust_xml[1].len,nv_dload.cust_xml[1].off);
printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[0].magic_num,\
nv_dload.xnv_map[0].len,nv_dload.xnv_map[0].off);
printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[1].magic_num,\
nv_dload.xnv_map[1].len,nv_dload.xnv_map[1].off);
printf("\n******************backup info******************\n");
printf("\n********backup mem info******\n");
printf("backup flag: 0x%x, len : 0x%x, off:0x%x\n",g_emmc_info.bak_sec.magic_num,\
g_emmc_info.bak_sec.len,g_emmc_info.bak_sec.off);
printf("\n********backup mtd info******\n");
ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL);
if(ret)
return;
if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM)
{
ctrl_info.file_size = 144;
}
ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL);
if(ret)
return;
printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\
ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num);
printf("\n******************default info*****************\n");
printf("\n********default mem info*****\n");
printf("default flag: 0x%x, len : 0x%x, off:0x%x\n",g_emmc_info.def_sec.magic_num,\
g_emmc_info.def_sec.len,g_emmc_info.def_sec.off);
printf("\n********default mtd info*****\n");
ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL);
if(ret)
return;
if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM)
{
ctrl_info.file_size = 144;
}
ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL);
if(ret)
return;
printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\
ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num);
nv_free(file_info);
}
s32 nv_file_copy(s8* dst_path,s8* src_path,bool path)
{
u32 ret = NV_ERROR;
FILE* dst_fp = NULL;
FILE* src_fp = NULL;
u32 u_ulen; /*文件拷贝单位长度*/
u32 u_tlen; /*源文件总长度*/
void* pdata; /*文件拷贝临时buffer*/
src_fp = nv_file_open(src_path,NV_FILE_READ);
dst_fp = nv_file_open(dst_path,NV_FILE_WRITE);
if(!src_fp || !dst_fp)
{
nv_printf("open fail src :%p,dst :%p\n",src_fp,dst_fp);
return BSP_ERR_NV_NO_FILE;
}
u_tlen = nv_get_file_len(src_fp);
if(u_tlen >= NV_MAX_FILE_SIZE)
{
nv_printf("u_tlen :0x%x\n",u_tlen);
goto out;
}
pdata = (void*)nv_malloc(NV_FILE_COPY_UNIT_SIZE);/*拷贝单位长度为16k*/
if(!pdata)
{
nv_printf("malloc failed !\n");
goto out;
}
while(u_tlen)
{
u_ulen = u_tlen > NV_FILE_COPY_UNIT_SIZE ? u_tlen :NV_FILE_COPY_UNIT_SIZE;
ret = (u32)nv_file_read(pdata,1,u_ulen,src_fp);
if(ret != u_ulen)
{
nv_printf("ret :0x%x u_ulen: 0x%x\n",ret,u_ulen);
goto out1;
}
ret = (u32)nv_file_write(pdata,1,u_ulen,dst_fp);
if(ret != u_ulen)
{
nv_printf("ret :0x%x u_ulen: 0x%x\n",ret,u_ulen);
goto out1;
}
u_tlen -= u_ulen;
}
(void)nv_file_close(src_fp);
(void)nv_file_close(dst_fp);
nv_free(pdata);
return NV_OK;
out1:
nv_free(pdata);
out:
(void)nv_file_close(src_fp);
(void)nv_file_close(dst_fp);
return -1;
}
static void *
nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
{
unsigned char *buf, *ptr;
size_t left, size;
const nvlist_t *tmpnvl;
nvpair_t *nvp, *tmpnvp;
void *cookie;
NVLIST_ASSERT(nvl);
if (nvl->nvl_error != 0) {
ERRNO_SET(nvl->nvl_error);
return (NULL);
}
size = nvlist_size(nvl);
buf = nv_malloc(size);
if (buf == NULL)
return (NULL);
ptr = buf;
left = size;
ptr = nvlist_pack_header(nvl, ptr, &left);
nvp = nvlist_first_nvpair(nvl);
while (nvp != NULL) {
NVPAIR_ASSERT(nvp);
nvpair_init_datasize(nvp);
ptr = nvpair_pack_header(nvp, ptr, &left);
if (ptr == NULL) {
nv_free(buf);
return (NULL);
}
switch (nvpair_type(nvp)) {
case NV_TYPE_NULL:
ptr = nvpair_pack_null(nvp, ptr, &left);
break;
case NV_TYPE_BOOL:
ptr = nvpair_pack_bool(nvp, ptr, &left);
break;
case NV_TYPE_NUMBER:
ptr = nvpair_pack_number(nvp, ptr, &left);
break;
case NV_TYPE_STRING:
ptr = nvpair_pack_string(nvp, ptr, &left);
break;
case NV_TYPE_NVLIST:
tmpnvl = nvpair_get_nvlist(nvp);
ptr = nvlist_pack_header(tmpnvl, ptr, &left);
if (ptr == NULL)
goto out;
tmpnvp = nvlist_first_nvpair(tmpnvl);
if (tmpnvp != NULL) {
nvl = tmpnvl;
nvp = tmpnvp;
continue;
}
ptr = nvpair_pack_nvlist_up(ptr, &left);
break;
#ifndef _KERNEL
case NV_TYPE_DESCRIPTOR:
ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
break;
#endif
case NV_TYPE_BINARY:
ptr = nvpair_pack_binary(nvp, ptr, &left);
break;
default:
PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
}
if (ptr == NULL) {
nv_free(buf);
return (NULL);
}
while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
cookie = NULL;
nvl = nvlist_get_parent(nvl, &cookie);
if (nvl == NULL)
goto out;
nvp = cookie;
ptr = nvpair_pack_nvlist_up(ptr, &left);
if (ptr == NULL)
goto out;
}
}
out:
if (sizep != NULL)
*sizep = size;
return (buf);
}
