622 lines
14 KiB
C
622 lines
14 KiB
C
|
// SPDX-License-Identifier: GPL-2.0
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Copyright (c) 2019 MediaTek Inc.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/slab.h>
|
||
|
|
#include <linux/string.h>
|
||
|
|
#include "vpu_algo.h"
|
||
|
|
|
||
|
|
/* list of vlist_type(struct vpu_algo) */
|
||
|
|
static struct list_head vpu_algo_pool[MTK_VPU_CORE];
|
||
|
|
static uint32_t prop_info_data_length;
|
||
|
|
static int debug_algo_id;
|
||
|
|
|
||
|
|
const size_t g_vpu_prop_type_size[VPU_NUM_PROP_TYPES] = {
|
||
|
|
[VPU_PROP_TYPE_CHAR] = sizeof(char),
|
||
|
|
[VPU_PROP_TYPE_INT32] = sizeof(int32_t),
|
||
|
|
[VPU_PROP_TYPE_FLOAT] = sizeof(int32_t),
|
||
|
|
[VPU_PROP_TYPE_INT64] = sizeof(int64_t),
|
||
|
|
[VPU_PROP_TYPE_DOUBLE] = sizeof(int64_t)
|
||
|
|
};
|
||
|
|
|
||
|
|
const char *g_vpu_prop_type_names[VPU_NUM_PROP_TYPES] = {
|
||
|
|
[VPU_PROP_TYPE_CHAR] = "char",
|
||
|
|
[VPU_PROP_TYPE_INT32] = "int32",
|
||
|
|
[VPU_PROP_TYPE_FLOAT] = "float",
|
||
|
|
[VPU_PROP_TYPE_INT64] = "int64",
|
||
|
|
[VPU_PROP_TYPE_DOUBLE] = "double"
|
||
|
|
};
|
||
|
|
|
||
|
|
const char *g_vpu_port_usage_names[VPU_NUM_PORT_USAGES] = {
|
||
|
|
[VPU_PORT_USAGE_IMAGE] = "image",
|
||
|
|
[VPU_PORT_USAGE_DATA] = "data",
|
||
|
|
};
|
||
|
|
|
||
|
|
const char *g_vpu_port_dir_names[VPU_NUM_PORT_DIRS] = {
|
||
|
|
[VPU_PORT_DIR_IN] = "in",
|
||
|
|
[VPU_PORT_DIR_OUT] = "out",
|
||
|
|
[VPU_PORT_DIR_IN_OUT] = "in-out",
|
||
|
|
};
|
||
|
|
|
||
|
|
struct vpu_prop_desc g_vpu_prop_descs[VPU_NUM_PROPS] = {
|
||
|
|
#define INS_PROP(id, name, type, count, access) \
|
||
|
|
{ VPU_PROP_ ## id, VPU_PROP_TYPE_ ## type, \
|
||
|
|
VPU_PROP_ACCESS_ ## access, 0, count, name }
|
||
|
|
|
||
|
|
INS_PROP(RESERVED, "reserved", INT32, 256, RDONLY),
|
||
|
|
#undef INS_PROP
|
||
|
|
};
|
||
|
|
|
||
|
|
int vpu_init_algo(struct vpu_device *vpu_device)
|
||
|
|
{
|
||
|
|
uint16_t i = 0;
|
||
|
|
uint32_t offset = 0;
|
||
|
|
uint32_t prop_data_length;
|
||
|
|
struct vpu_prop_desc *prop_desc;
|
||
|
|
|
||
|
|
for (i = 0; i < MTK_VPU_CORE; i++)
|
||
|
|
INIT_LIST_HEAD(&(vpu_algo_pool[i]));
|
||
|
|
|
||
|
|
for (i = 0; i < VPU_NUM_PROPS; i++) {
|
||
|
|
prop_desc = &g_vpu_prop_descs[i];
|
||
|
|
prop_desc->offset = offset;
|
||
|
|
prop_data_length = prop_desc->count *
|
||
|
|
g_vpu_prop_type_size[prop_desc->type];
|
||
|
|
offset += prop_data_length;
|
||
|
|
}
|
||
|
|
/* the total length = last offset + last data length */
|
||
|
|
prop_info_data_length = offset;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_add_algo_to_pool(int core, struct vpu_algo *algo)
|
||
|
|
{
|
||
|
|
LOG_DBG("[vpu] %s +\n", __func__);
|
||
|
|
list_add_tail(vlist_link(algo, struct vpu_algo), &vpu_algo_pool[core]);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_add_algo_to_user_pool(struct vpu_algo *algo, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
LOG_DBG("[vpu] %s +\n", __func__);
|
||
|
|
list_add_tail(vlist_link(algo, struct vpu_algo), &user->algo_list);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_free_algo_from_user_pool(int core_s, vpu_id_t id, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct list_head *head, *temp;
|
||
|
|
struct vpu_algo *algo_tmp;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
LOG_DBG("[vpu] %s +\n", __func__);
|
||
|
|
list_for_each_safe(head, temp, &user->algo_list) {
|
||
|
|
algo_tmp = vlist_node_of(head, struct vpu_algo);
|
||
|
|
if (algo_tmp->id[core] == id) {
|
||
|
|
list_del(head);
|
||
|
|
vpu_free_algo(algo_tmp);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_find_algo_by_id_from_user(int core_s, vpu_id_t id,
|
||
|
|
struct vpu_algo **ralgo, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo;
|
||
|
|
struct list_head *head;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
list_for_each(head, &user->algo_list)
|
||
|
|
{
|
||
|
|
algo = vlist_node_of(head, struct vpu_algo);
|
||
|
|
if (algo->id[core] == id) {
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*ralgo = NULL;
|
||
|
|
return -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_find_algo_by_name_from_user(int core_s, char *name,
|
||
|
|
struct vpu_algo **ralgo, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo;
|
||
|
|
struct list_head *head;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
list_for_each(head, &user->algo_list)
|
||
|
|
{
|
||
|
|
algo = vlist_node_of(head, struct vpu_algo);
|
||
|
|
if (!strcmp(name, algo->name) && algo->id[core]) {
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*ralgo = NULL;
|
||
|
|
return -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_find_algo_by_id(int core_s, vpu_id_t id,
|
||
|
|
struct vpu_algo **ralgo, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo;
|
||
|
|
struct list_head *head;
|
||
|
|
char *name;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
if (id < 1)
|
||
|
|
goto err;
|
||
|
|
|
||
|
|
|
||
|
|
list_for_each(head, &vpu_algo_pool[core])
|
||
|
|
{
|
||
|
|
algo = vlist_node_of(head, struct vpu_algo);
|
||
|
|
if (algo->id[core] == id) {
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (user != NULL &&
|
||
|
|
vpu_find_algo_by_id_from_user(core, id, ralgo, user) == 0)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
if (vpu_get_name_of_algo(core, id, &name))
|
||
|
|
goto err;
|
||
|
|
|
||
|
|
if (vpu_create_algo(core, name, &algo, false) == 0) {
|
||
|
|
vpu_add_algo_to_pool(core, algo);
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
err:
|
||
|
|
*ralgo = NULL;
|
||
|
|
return -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_find_algo_by_name(int core_s, char *name,
|
||
|
|
struct vpu_algo **ralgo, bool needload, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo;
|
||
|
|
struct list_head *head;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
LOG_DBG("[vpu] %s +\n", __func__);
|
||
|
|
|
||
|
|
if (name == NULL)
|
||
|
|
goto err;
|
||
|
|
|
||
|
|
if (vpu_find_algo_by_name_from_user(core, name, ralgo, user) == 0)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
list_for_each(head, &vpu_algo_pool[core])
|
||
|
|
{
|
||
|
|
algo = vlist_node_of(head, struct vpu_algo);
|
||
|
|
if (!strcmp(name, algo->name)) {
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (vpu_create_algo(core, name, &algo, needload) == 0) {
|
||
|
|
vpu_add_algo_to_pool(core, algo);
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
err:
|
||
|
|
*ralgo = NULL;
|
||
|
|
return -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_get_algo_id_by_name(int core_s, char *name, struct vpu_user *user)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo = NULL;
|
||
|
|
int algo_id = -1;
|
||
|
|
int ret = 0;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
|
||
|
|
if (name == NULL)
|
||
|
|
goto out;
|
||
|
|
|
||
|
|
LOG_DBG("%s core:%d\n", __func__, core);
|
||
|
|
ret = vpu_find_algo_by_name(core, name, &algo, false, user);
|
||
|
|
LOG_DBG("ret:%d\n", ret);
|
||
|
|
if (ret || !algo) {
|
||
|
|
LOG_ERR("vpu_find_algo_by_name fail, name=%s\n", name);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
algo_id = algo->id[core];
|
||
|
|
LOG_INF("vpu(%d)_get algo_id:%d\n", core, algo_id);
|
||
|
|
return algo_id;
|
||
|
|
|
||
|
|
out:
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int vpu_calc_prop_offset(struct vpu_prop_desc *descs,
|
||
|
|
uint32_t count, uint32_t *length)
|
||
|
|
{
|
||
|
|
|
||
|
|
struct vpu_prop_desc *prop_desc;
|
||
|
|
uint32_t offset = 0;
|
||
|
|
uint32_t alignment = 1;
|
||
|
|
uint32_t i, tmp;
|
||
|
|
size_t type_size;
|
||
|
|
|
||
|
|
/* get the alignment of struct packing */
|
||
|
|
for (i = 0; i < count; i++) {
|
||
|
|
prop_desc = &descs[i];
|
||
|
|
type_size = g_vpu_prop_type_size[prop_desc->type];
|
||
|
|
|
||
|
|
if (alignment < type_size)
|
||
|
|
alignment = type_size;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* calculate every prop's offset */
|
||
|
|
for (i = 0; i < count; i++) {
|
||
|
|
prop_desc = &descs[i];
|
||
|
|
type_size = g_vpu_prop_type_size[prop_desc->type];
|
||
|
|
|
||
|
|
/* align offset with next data type */
|
||
|
|
tmp = offset % type_size;
|
||
|
|
if (tmp)
|
||
|
|
offset += type_size - tmp;
|
||
|
|
|
||
|
|
/* padding if the remainder is not enough */
|
||
|
|
tmp = alignment - offset % alignment;
|
||
|
|
if (tmp < type_size)
|
||
|
|
offset += tmp;
|
||
|
|
|
||
|
|
prop_desc->offset = offset;
|
||
|
|
offset += prop_desc->count * type_size;
|
||
|
|
}
|
||
|
|
*length = offset;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_create_algo(int core_s, char *name,
|
||
|
|
struct vpu_algo **ralgo, bool needload)
|
||
|
|
{
|
||
|
|
int ret, id, length;
|
||
|
|
unsigned int mva;
|
||
|
|
unsigned int core = (unsigned int)core_s;
|
||
|
|
struct vpu_algo *algo = NULL;
|
||
|
|
|
||
|
|
LOG_DBG("[vpu] %s + (%d)\n", __func__, needload);
|
||
|
|
|
||
|
|
ret = vpu_get_entry_of_algo(core, name, &id, &mva, &length);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("algo(%s) is not existed in image files!\n", name);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = vpu_alloc_algo(&algo);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_alloc_algo failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
strlcpy(algo->name, name, (sizeof(char)*32));
|
||
|
|
algo->id[core] = id;
|
||
|
|
algo->bin_ptr = mva;
|
||
|
|
algo->bin_length = length;
|
||
|
|
LOG_DBG("[vpu] vpu_hw_load_algo done, (%d/0x%lx/0x%x)\n",
|
||
|
|
id, (unsigned long)mva, length);
|
||
|
|
|
||
|
|
LOG_INF("[vpu_%d] vpu_hw_load_algo done, (%d/0x%lx/0x%x)\n",
|
||
|
|
core, algo->id[core],
|
||
|
|
(unsigned long)(algo->bin_ptr), algo->bin_length);
|
||
|
|
|
||
|
|
if (needload) {
|
||
|
|
ret = vpu_hw_load_algo(core, algo);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_hw_load_algo failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOG_DBG("[vpu_%d] vpu_hw_load_algo done\n", core);
|
||
|
|
|
||
|
|
ret = vpu_hw_get_algo_info(core, algo);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_hw_get_algo_info failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOG_INF("[vpu_%d] vpu_hw_get_algo_info done\n", core);
|
||
|
|
|
||
|
|
ret = vpu_calc_prop_offset(algo->info_descs,
|
||
|
|
algo->info_desc_count, &algo->info_length);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_calc_prop_offset[info] failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOG_INF("[vpu_%d] vpu_calc_prop_offset done, %s(0x%x)\n",
|
||
|
|
core,
|
||
|
|
"algo->info_length", algo->info_length);
|
||
|
|
|
||
|
|
ret = vpu_calc_prop_offset(algo->sett_descs,
|
||
|
|
algo->sett_desc_count, &algo->sett_length);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_calc_prop_offset[sett] failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOG_INF("[vpu_%d] vpu_calc_prop_offset done, %s(0x%x)\n",
|
||
|
|
core,
|
||
|
|
"algo->sett_length", algo->sett_length);
|
||
|
|
}
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
out:
|
||
|
|
*ralgo = NULL;
|
||
|
|
if (algo != NULL)
|
||
|
|
vpu_free_algo(algo);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_add_algo_to_user(struct vpu_user *user,
|
||
|
|
struct vpu_create_algo *create_algo)
|
||
|
|
{
|
||
|
|
int ret = 0;
|
||
|
|
uint32_t core = create_algo->core;
|
||
|
|
struct vpu_algo *algo = NULL;
|
||
|
|
vpu_id_t algo_num;
|
||
|
|
|
||
|
|
ret = vpu_alloc_algo(&algo);
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("vpu_alloc_algo failed!\n");
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
strlcpy(algo->name, create_algo->name, (sizeof(char)*32));
|
||
|
|
vpu_get_default_algo_num(core, &algo_num);
|
||
|
|
|
||
|
|
user->algo_num++;
|
||
|
|
algo->id[core] = user->algo_num + algo_num;
|
||
|
|
algo->bin_ptr = create_algo->algo_ptr;
|
||
|
|
algo->bin_length = create_algo->algo_length;
|
||
|
|
vpu_add_algo_to_user_pool(algo, user);
|
||
|
|
out:
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_free_algo_from_user(struct vpu_user *user,
|
||
|
|
struct vpu_create_algo *create_algo)
|
||
|
|
{
|
||
|
|
unsigned int core = create_algo->core;
|
||
|
|
struct vpu_algo *ralgo;
|
||
|
|
vpu_id_t id;
|
||
|
|
|
||
|
|
if (vpu_find_algo_by_name_from_user(core,
|
||
|
|
create_algo->name, &ralgo, user) == 0) {
|
||
|
|
id = ralgo->id[core];
|
||
|
|
return vpu_free_algo_from_user_pool(core, id, user);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_alloc_algo(struct vpu_algo **ralgo)
|
||
|
|
{
|
||
|
|
struct vpu_algo *algo;
|
||
|
|
|
||
|
|
LOG_DBG("[vpu] %s +\n", __func__);
|
||
|
|
algo = kzalloc(sizeof(vlist_type(struct vpu_algo)) +
|
||
|
|
prop_info_data_length, GFP_KERNEL);
|
||
|
|
if (algo == NULL) {
|
||
|
|
LOG_ERR("%s(), algo=0x%p\n", __func__, algo);
|
||
|
|
return -ENOMEM;
|
||
|
|
}
|
||
|
|
algo->info_ptr = (uintptr_t) algo + sizeof(vlist_type(struct vpu_algo));
|
||
|
|
algo->info_length = prop_info_data_length;
|
||
|
|
|
||
|
|
INIT_LIST_HEAD(vlist_link(algo, struct vpu_algo));
|
||
|
|
*ralgo = algo;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int vpu_free_algo(struct vpu_algo *algo)
|
||
|
|
{
|
||
|
|
if (algo == NULL)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
kfree(algo);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_alloc_request(struct vpu_request **rreq)
|
||
|
|
{
|
||
|
|
struct vpu_request *req;
|
||
|
|
|
||
|
|
req = kzalloc(sizeof(vlist_type(struct vpu_request)), GFP_KERNEL);
|
||
|
|
if (req == NULL) {
|
||
|
|
LOG_ERR("%s(), node=0x%p\n", __func__, req);
|
||
|
|
return -ENOMEM;
|
||
|
|
}
|
||
|
|
|
||
|
|
*rreq = req;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_free_request(struct vpu_request *req)
|
||
|
|
{
|
||
|
|
if (req != NULL)
|
||
|
|
kfree(req);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_dump_algo(struct seq_file *s)
|
||
|
|
{
|
||
|
|
struct vpu_algo *debug_algo;
|
||
|
|
struct vpu_prop_desc *prop_desc;
|
||
|
|
struct vpu_port *port;
|
||
|
|
char *debug_algo_name;
|
||
|
|
uint32_t i, j;
|
||
|
|
uint32_t data_length;
|
||
|
|
char line_buffer[24 + 1] = {0};
|
||
|
|
unsigned char *info_data;
|
||
|
|
int debug_core = 0;
|
||
|
|
int ret = 0;
|
||
|
|
|
||
|
|
if (vpu_get_name_of_algo(debug_core, debug_algo_id,
|
||
|
|
&debug_algo_name)) {
|
||
|
|
vpu_print_seq(s, "vpu_get_name_of_algo fail, id=%d\n",
|
||
|
|
debug_algo_id);
|
||
|
|
goto err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (vpu_create_algo(debug_core, debug_algo_name,
|
||
|
|
&debug_algo, true) == 0) {
|
||
|
|
vpu_print_seq(s, "[Algo: id=%d %s=%s, %s=0x%llx, %s=0x%x]\n",
|
||
|
|
debug_algo_id,
|
||
|
|
"name", debug_algo->name,
|
||
|
|
"address", debug_algo->bin_ptr,
|
||
|
|
"length", debug_algo->bin_length);
|
||
|
|
|
||
|
|
#define LINE_BAR " +-----+---------------+-------+-------+\n"
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, " |%-5s|%-15s|%-7s|%-7s|\n",
|
||
|
|
"Port", "Name", "Dir", "Usage");
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
|
||
|
|
for (i = 0; i < debug_algo->port_count; i++) {
|
||
|
|
port = &debug_algo->ports[i];
|
||
|
|
vpu_print_seq(s, " |%-5d|%-15s|%-7s|%-7s|\n",
|
||
|
|
port->id, port->name,
|
||
|
|
g_vpu_port_dir_names[port->dir],
|
||
|
|
g_vpu_port_usage_names[port->usage]);
|
||
|
|
}
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, "\n");
|
||
|
|
#undef LINE_BAR
|
||
|
|
|
||
|
|
#define LINE_BAR " +-----+---------------+-------+-------+------------------------------+\n"
|
||
|
|
if (debug_algo->info_desc_count) {
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, " |%-5s|%-15s|%-7s|%-7s|%-30s|\n",
|
||
|
|
"Info", "Name", "Type", "Count", "Value");
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < debug_algo->info_desc_count; i++) {
|
||
|
|
prop_desc = &debug_algo->info_descs[i];
|
||
|
|
data_length = prop_desc->count *
|
||
|
|
g_vpu_prop_type_size[prop_desc->type];
|
||
|
|
|
||
|
|
vpu_print_seq(s, " |%-5d|%-15s|%-7s|%-7d|%04XH ",
|
||
|
|
prop_desc->id,
|
||
|
|
prop_desc->name,
|
||
|
|
g_vpu_prop_type_names[prop_desc->type],
|
||
|
|
prop_desc->count,
|
||
|
|
0);
|
||
|
|
|
||
|
|
info_data = (unsigned char *)
|
||
|
|
((uintptr_t)debug_algo->info_ptr +
|
||
|
|
prop_desc->offset);
|
||
|
|
memset(line_buffer, ' ', 24);
|
||
|
|
for (j = 0; j < data_length; j++, info_data++) {
|
||
|
|
unsigned int pos = j % 8;
|
||
|
|
|
||
|
|
if (j && pos == 0) {
|
||
|
|
vpu_print_seq(s,
|
||
|
|
" |%-5s|%-15s|%-7s|%-7s|%04XH ",
|
||
|
|
"", "", "", "", j);
|
||
|
|
}
|
||
|
|
ret = sprintf(line_buffer + pos * 3, "%02X",
|
||
|
|
*info_data);
|
||
|
|
if (ret < 0) {
|
||
|
|
pr_info("%s: vsnprintf: %d\n", __func__, ret);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
line_buffer[pos * 3 + 2] = ' ';
|
||
|
|
if (pos == 7 || j + 1 == data_length)
|
||
|
|
vpu_print_seq(s, "%s|\n", line_buffer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (debug_algo->info_desc_count) {
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, "\n");
|
||
|
|
}
|
||
|
|
#undef LINE_BAR
|
||
|
|
|
||
|
|
#define LINE_BAR " +-----+---------------+-------+-------+-------+\n"
|
||
|
|
if (debug_algo->sett_desc_count < 1)
|
||
|
|
goto out;
|
||
|
|
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, " |%-5s|%-15s|%-7s|%-7s|%-7s|\n",
|
||
|
|
"Sett", "Name", "Offset", "Type", "Count");
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
for (i = 0; i < debug_algo->sett_desc_count; i++) {
|
||
|
|
prop_desc = &debug_algo->sett_descs[i];
|
||
|
|
data_length = prop_desc->count *
|
||
|
|
g_vpu_prop_type_size[prop_desc->type];
|
||
|
|
|
||
|
|
vpu_print_seq(s, " |%-5d|%-15s|%-7d|%-7s|%-7d|\n",
|
||
|
|
prop_desc->id,
|
||
|
|
prop_desc->name,
|
||
|
|
prop_desc->offset,
|
||
|
|
g_vpu_prop_type_names[prop_desc->type],
|
||
|
|
prop_desc->count);
|
||
|
|
}
|
||
|
|
vpu_print_seq(s, LINE_BAR);
|
||
|
|
vpu_print_seq(s, "\n");
|
||
|
|
#undef LINE_BAR
|
||
|
|
out:
|
||
|
|
vpu_free_algo(debug_algo);
|
||
|
|
vpu_debug_func_core_state(debug_core, VCT_IDLE);
|
||
|
|
vpu_shut_down(debug_core);
|
||
|
|
} else {
|
||
|
|
vpu_print_seq(s, "create algo fail, id=%d\n", debug_algo_id);
|
||
|
|
LOG_ERR("create algo fail\n");
|
||
|
|
}
|
||
|
|
err:
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vpu_set_algo_parameter(uint8_t param, int argc, int *args)
|
||
|
|
{
|
||
|
|
int ret = 0;
|
||
|
|
|
||
|
|
switch (param) {
|
||
|
|
case VPU_DEBUG_ALGO_PARAM_DUMP_ALGO:
|
||
|
|
ret = (argc == 1) ? 0 : -EINVAL;
|
||
|
|
if (ret) {
|
||
|
|
LOG_ERR("invalid argument, expected:1, received:%d\n",
|
||
|
|
argc);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
debug_algo_id = args[0];
|
||
|
|
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOG_ERR("unsupport the power parameter:%d\n", param);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
out:
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|