Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
void
nvlist_move_string_array(nvlist_t *nvl, const char *name, char **value,
    size_t nitems)
{
	nvpair_t *nvp;
	size_t i;

	if (nvlist_error(nvl) != 0) {
		if (value != NULL) {
			for (i = 0; i < nitems; i++)
				nv_free(value[i]);
			nv_free(value);
		}
		ERRNO_SET(nvlist_error(nvl));
		return;
	}

	nvp = nvpair_move_string_array(name, value, nitems);
	if (nvp == NULL) {
		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
		ERRNO_SET(nvl->nvl_error);
	} else {
		(void)nvlist_move_nvpair(nvl, nvp);
	}
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
static void
nv_mlp_train_accuracy(const nv_mlp_t *mlp,
					  const nv_matrix_t *data, const nv_matrix_t *label)
{
	int i;
	int output = mlp->output;
	int *correct_count = nv_alloc_type(int, output);
	int *error_count = nv_alloc_type(int, output);
	
	memset(correct_count, 0, sizeof(int) * output);
	memset(error_count, 0, sizeof(int) * output);
	for (i = 0; i < data->m; ++i) {
		int predict = nv_mlp_predict_label(mlp, data, i);
		int teach = (int)NV_MAT_V(label, i, 0);
		if (predict == teach) {
			++correct_count[teach];
		} else {
			++error_count[teach];
		}
	}
	for (i = 0; i < output; ++i) {
		if (correct_count[i] + error_count[i] > 0) {
			printf("%d: correct: %d, ng: %d, %f\n",
				   i, correct_count[i], error_count[i], 
				   (float)correct_count[i] / (float)(correct_count[i] + error_count[i]));
		} else {
			printf("%d: no data found\n", i);
		}
	}
	nv_free(correct_count);
	nv_free(error_count);
}
Exemplo n.º 5
0
/*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;

}
Exemplo n.º 6
0
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);
}
Exemplo n.º 7
0
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;

}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
0
void
nvlist_destroy(nvlist_t *nvl)
{
	nvpair_t *nvp;

	if (nvl == NULL)
		return;

	ERRNO_SAVE();

	NVLIST_ASSERT(nvl);

	while ((nvp = nvlist_first_nvpair(nvl)) != NULL) {
		nvlist_remove_nvpair(nvl, nvp);
		nvpair_free(nvp);
	}
	if (nvl->nvl_array_next != NULL)
		nvpair_free_structure(nvl->nvl_array_next);
	nvl->nvl_array_next = NULL;
	nvl->nvl_parent = NULL;
	nvl->nvl_magic = 0;
	nv_free(nvl);

	ERRNO_RESTORE();
}
Exemplo n.º 10
0
/*
 * 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;
}
Exemplo n.º 11
0
void
print_freqs(struct print_freqs_param *param) {
    char *start = param->start;
    int length = param->length;
    int frame = param->frame;
    char *output = param->output;
    int output_size = param->output_size;

    struct ht_ht *ht = ht_create(32);
    char buffer[frame + 1];
    int output_pos = 0;

    generate_seqences(start, length, frame, ht);
    
    struct ht_node *counts = ht_values_as_vector(ht);
    int size = ht->items;

    qsort(counts, size, sizeof(struct ht_node), &key_count_cmp);

    int total_count = 0;
    for (int i = 0; i < size; i++) {
        total_count += counts[i].val;
    }

    for (int i = 0; i < size; i++) {
        unpack_key(counts[i].key, frame, buffer);
        output_pos += snprintf(output + output_pos, output_size - output_pos,
                "%s %.3f\n", buffer, counts[i].val*100.0f/total_count);
    }

    nv_free(counts);
    ht_destroy(ht);
}
Exemplo n.º 12
0
/*
 * Load the configuration plugin from the given file.
 * If the configuration plugin structure is NULL then it is allocated.
 * This should normally be the case.
 */
int config_p_init(char *file) {
	char *buf = NULL;
	int len = 0;
	lt_dlhandle module = NULL;
	int (*config_init)(struct nv_config_p *);
	int stat = 0;
	int ret = 0;

	/* get reference to config plugin file */
	nv_log(NVLOG_INFO, "loading config plugin from %s", file);
	len = strlen(CONFIG_PATH)+strlen(file)+2;
	buf = nv_calloc(char, len);
	snprintf(buf, len, "%s/%s", CONFIG_PATH, file);
	module = lt_dlopen(buf);
	nv_free(buf);
	if (module == NULL) {
		nv_log(NVLOG_ERROR, "lt_dlopen(): %s", lt_dlerror());
		stat = -1;
		goto cleanup;
	}

	/* allocate memory for config plugin struct if necessary */
	if (nv_config_p == NULL) {
		nv_config_p = nv_calloc(struct nv_config_p, 1);
	}
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;
}
Exemplo n.º 14
0
int
metadata_write(struct hast_resource *res)
{
	struct ebuf *eb;
	struct nv *nv;
	unsigned char *buf, *ptr;
	size_t size;
	ssize_t done;
	int ret;

	buf = calloc(1, METADATA_SIZE);
	if (buf == NULL) {
		pjdlog_error("Unable to allocate %zu bytes for metadata.",
		    (size_t)METADATA_SIZE);
		return (-1);
	}

	ret = -1;

	nv = nv_alloc();
	nv_add_string(nv, res->hr_name, "resource");
	nv_add_uint64(nv, (uint64_t)res->hr_datasize, "datasize");
	nv_add_uint32(nv, (uint32_t)res->hr_extentsize, "extentsize");
	nv_add_uint32(nv, (uint32_t)res->hr_keepdirty, "keepdirty");
	nv_add_uint64(nv, (uint64_t)res->hr_localoff, "offset");
	nv_add_uint64(nv, res->hr_resuid, "resuid");
	if (res->hr_role == HAST_ROLE_PRIMARY ||
	    res->hr_role == HAST_ROLE_INIT) {
		nv_add_uint64(nv, res->hr_primary_localcnt, "localcnt");
		nv_add_uint64(nv, res->hr_primary_remotecnt, "remotecnt");
	} else /* if (res->hr_role == HAST_ROLE_SECONDARY) */ {
		PJDLOG_ASSERT(res->hr_role == HAST_ROLE_SECONDARY);
		nv_add_uint64(nv, res->hr_secondary_localcnt, "localcnt");
		nv_add_uint64(nv, res->hr_secondary_remotecnt, "remotecnt");
	}
	nv_add_string(nv, role2str(res->hr_role), "prevrole");
	if (nv_error(nv) != 0) {
		pjdlog_error("Unable to create metadata.");
		goto end;
	}
	res->hr_previous_role = res->hr_role;
	eb = nv_hton(nv);
	PJDLOG_ASSERT(eb != NULL);
	ptr = ebuf_data(eb, &size);
	PJDLOG_ASSERT(ptr != NULL);
	PJDLOG_ASSERT(size < METADATA_SIZE);
	bcopy(ptr, buf, size);
	done = pwrite(res->hr_localfd, buf, METADATA_SIZE, 0);
	if (done == -1 || done != METADATA_SIZE) {
		pjdlog_errno(LOG_ERR, "Unable to write metadata");
		goto end;
	}
	ret = 0;
end:
	free(buf);
	nv_free(nv);
	return (ret);
}
Exemplo n.º 15
0
void 
nv_lr_free(nv_lr_t **lr)
{
	if (*lr) {
		nv_matrix_free(&(*lr)->w);
		nv_free(*lr);
		*lr = NULL;
	}
}
Exemplo n.º 16
0
void
otama_image_free(otama_image_t **image)
{
	if (image && *image) {
		nv_matrix_free(&(*image)->image);
		nv_free(*image);
		*image = NULL;
	}
}
Exemplo n.º 17
0
void
nv_pa_free(nv_pa_t **pa)
{
	if (pa && *pa) {
		nv_matrix_free(&(*pa)->w);
		nv_free(*pa);
		*pa = NULL;
	}
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
0
void
nv_arow_free(nv_arow_t **arow)
{
	if (arow && *arow) {
		nv_matrix_free(&(*arow)->w);
		nv_matrix_free(&(*arow)->bias);
		nv_free(*arow);
		*arow = NULL;
	}
}
Exemplo n.º 20
0
void
nv_bgseg_free(nv_bgseg_t **bg)
{
	if (bg && *bg) {
		nv_matrix_free(&(*bg)->av);
		nv_matrix_free(&(*bg)->sgm);
		nv_free(*bg);
		*bg = NULL;
	}
}
Exemplo n.º 21
0
/*
 *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;
}
Exemplo n.º 22
0
int
nvlist_send(int sock, const nvlist_t *nvl)
{
	size_t datasize, nfds;
	int *fds;
	void *data;
	int64_t fdidx;
	int ret;

	if (nvlist_error(nvl) != 0) {
		ERRNO_SET(nvlist_error(nvl));
		return (-1);
	}

	fds = nvlist_descriptors(nvl, &nfds);
	if (fds == NULL)
		return (-1);

	ret = -1;
	data = NULL;
	fdidx = 0;

	data = nvlist_xpack(nvl, &fdidx, &datasize);
	if (data == NULL)
		goto out;

	if (buf_send(sock, data, datasize) == -1)
		goto out;

	if (nfds > 0) {
		if (fd_send(sock, fds, nfds) == -1)
			goto out;
	}

	ret = 0;
out:
	ERRNO_SAVE();
	nv_free(fds);
	nv_free(data);
	ERRNO_RESTORE();
	return (ret);
}
Exemplo n.º 23
0
void
nv_matrix_free(nv_matrix_t **matrix)
{
	if (*matrix != NULL) {
		if ((*matrix)->alias == 0) {
			nv_aligned_free((*matrix)->v);
		}
		nv_free(*matrix);
		*matrix = NULL;
	}
}
Exemplo n.º 24
0
void nv_shapecontext_free(nv_shapecontext_t **sctx)
{
	if (*sctx) {
		nv_matrix_free(&(*sctx)->sctx);
		nv_matrix_free(&(*sctx)->tan_angle);
		nv_matrix_free(&(*sctx)->coodinate);
		nv_matrix_free(&(*sctx)->radius);
		nv_free(*sctx);
		*sctx = NULL;
	}
}
Exemplo n.º 25
0
void
nv_plsi_free(nv_plsi_t **p)
{
	if (*p) {
		nv_matrix_free(&(*p)->z);
		nv_matrix_free(&(*p)->dz);
		nv_matrix_free(&(*p)->wz);
		nv_free(*p);
		*p = NULL;
	}
}
Exemplo n.º 26
0
void nv_mlp_free(nv_mlp_t **mlp)
{
	if (*mlp) {
		nv_matrix_free(&(*mlp)->input_w);
		nv_matrix_free(&(*mlp)->input_bias);
		nv_matrix_free(&(*mlp)->hidden_w);
		nv_matrix_free(&(*mlp)->hidden_bias);
		nv_free(*mlp);
		*mlp = NULL;
	}
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
void 
nv_pstable_free(nv_pstable_t **ps)
{
	if (ps != NULL && *ps != NULL) {
		nv_matrix_free(&(*ps)->a);
		nv_matrix_free(&(*ps)->b);
		nv_matrix_free(&(*ps)->r1);
		nv_matrix_free(&(*ps)->r2);
		nv_free(*ps);
		*ps = NULL;
	}
}
Exemplo n.º 29
0
/*
 * Thread sends requests back to primary node.
 */
static void *
send_thread(void *arg)
{
	struct hast_resource *res = arg;
	struct nv *nvout;
	struct hio *hio;
	void *data;
	size_t length;

	for (;;) {
		pjdlog_debug(2, "send: Taking request.");
		QUEUE_TAKE(send, hio);
		reqlog(LOG_DEBUG, 2, -1, hio, "send: (%p) Got request: ", hio);
		nvout = nv_alloc();
		/* Copy sequence number. */
		nv_add_uint64(nvout, hio->hio_seq, "seq");
		switch (hio->hio_cmd) {
		case HIO_READ:
			if (hio->hio_error == 0) {
				data = hio->hio_data;
				length = hio->hio_length;
				break;
			}
			/*
			 * We send no data in case of an error.
			 */
			/* FALLTHROUGH */
		case HIO_DELETE:
		case HIO_FLUSH:
		case HIO_WRITE:
			data = NULL;
			length = 0;
			break;
		default:
			PJDLOG_ABORT("Unexpected command (cmd=%hhu).",
			    hio->hio_cmd);
		}
		if (hio->hio_error != 0)
			nv_add_int16(nvout, hio->hio_error, "error");
		if (hast_proto_send(res, res->hr_remoteout, nvout, data,
		    length) < 0) {
			secondary_exit(EX_TEMPFAIL, "Unable to send reply.");
		}
		nv_free(nvout);
		pjdlog_debug(2, "send: (%p) Moving request to the free queue.",
		    hio);
		hio_clear(hio);
		QUEUE_INSERT(free, hio);
	}
	/* NOTREACHED */
	return (NULL);
}
Exemplo n.º 30
0
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;
}