1789 lines
52 KiB
C
Executable File
1789 lines
52 KiB
C
Executable File
/*
|
|
* Copyright (C) 2018 Knowles Electronics
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "iaxxx_odsp_hw"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <log/log.h>
|
|
#include <sys/ioctl.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "iaxxx_odsp_hw.h"
|
|
|
|
#define DEV_NODE "/dev/iaxxx-odsp-celldrv"
|
|
#define FUNCTION_ENTRY_LOG ALOGV("Entering %s", __func__);
|
|
#define FUNCTION_EXIT_LOG ALOGV("Exiting %s", __func__);
|
|
|
|
#define IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_IDENTIFIER_MASK 0x0000ffff
|
|
#define IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_IDENTIFIER_POS 0
|
|
#define IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_TYPE_MASK 0x00070000
|
|
#define IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_TYPE_POS 16
|
|
|
|
struct iaxxx_odsp_hw {
|
|
FILE *dev_node;
|
|
};
|
|
|
|
/**
|
|
* Initialize the ODSP HAL
|
|
*
|
|
* Input - NA
|
|
* Output - Handle to iaxxx_odsp_hw on success, NULL on failure
|
|
*/
|
|
struct iaxxx_odsp_hw* iaxxx_odsp_init()
|
|
{
|
|
struct iaxxx_odsp_hw *ioh = NULL;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
ioh = (struct iaxxx_odsp_hw *)malloc(sizeof(struct iaxxx_odsp_hw));
|
|
if (ioh == NULL) {
|
|
ALOGE("%s: ERROR: Failed to allocate memory for iaxxx_odsp_hw",
|
|
__func__);
|
|
goto func_exit;
|
|
}
|
|
|
|
ioh->dev_node = fopen(DEV_NODE, "rw");
|
|
if (ioh->dev_node == NULL) {
|
|
ALOGE("%s: ERROR: Failed to open %s", __func__, DEV_NODE);
|
|
free(ioh);
|
|
ioh = NULL;
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return ioh;
|
|
}
|
|
|
|
/**
|
|
* De-Initialize the ODSP HAL
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_deinit(struct iaxxx_odsp_hw *odsp_hw_hdl)
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
if (odsp_hw_hdl->dev_node) {
|
|
fclose(odsp_hw_hdl->dev_node);
|
|
}
|
|
|
|
free(odsp_hw_hdl);
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Load a package
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* pkg_name - Relative path to the Package binary (Should be placed in
|
|
* the firmware location)
|
|
* pkg_id - Package ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_package_load(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const char *pkg_name, const uint32_t pkg_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_pkg_mgmt_info pkg_info;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
if (pkg_name == NULL) {
|
|
ALOGE("%s: ERROR: Package name cannot be null", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Package name %s, package id %u",
|
|
__func__, pkg_name, pkg_id);
|
|
|
|
strlcpy(pkg_info.pkg_name, pkg_name, NAME_MAX_SIZE);
|
|
pkg_info.pkg_id = pkg_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_LOAD_PACKAGE, (unsigned long)&pkg_info);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Unload a package
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* pkg_name - Relative path to the Package binary (Should be placed in
|
|
* the firmware location)
|
|
* pkg_id - Package ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_package_unload(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t pkg_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_pkg_mgmt_info pkg_info;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: package id %u", __func__, pkg_id);
|
|
|
|
pkg_info.pkg_id = pkg_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_UNLOAD_PACKAGE, (unsigned long)&pkg_info);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get package version
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* version - Package version string buffer
|
|
* len - String buffer size
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_package_version(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint8_t inst_id, char *version,
|
|
uint32_t len)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_get_package_version v;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
if (len > sizeof(v.version)) {
|
|
ALOGW("%s: WARNING: Too large len %u, limit it to %zu", __func__, len,
|
|
sizeof(v.version));
|
|
len = sizeof(v.version);
|
|
}
|
|
|
|
ALOGV("%s: inst_id %u", __func__, inst_id);
|
|
|
|
v.inst_id = inst_id;
|
|
v.len = len;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_PACKAGE_VERSION, (unsigned long)&v);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
memcpy(version, v.version, len);
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get plugin version
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* version - Plugin version string buffer
|
|
* len - String buffer size
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_plugin_version(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint8_t inst_id, char *version,
|
|
uint32_t len)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_get_plugin_version v;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
if (len > sizeof(v.version)) {
|
|
ALOGW("%s: WARNING: Too large len %u, limit it to %zu", __func__, len,
|
|
sizeof(v.version));
|
|
len = sizeof(v.version);
|
|
}
|
|
|
|
ALOGV("%s: inst_id %u", __func__, inst_id);
|
|
|
|
v.inst_id = inst_id;
|
|
v.len = len;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_PLUGIN_VERSION, (unsigned long)&v);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
memcpy(version, v.version, len);
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Create a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* priority - Priority of the plugin
|
|
* pkg_id - Package ID
|
|
* plg_idx - Plugin Index*
|
|
* block_id - Block ID
|
|
* config_id - Config ID
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_create(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t priority,
|
|
const uint32_t pkg_id,
|
|
const uint32_t plg_idx,
|
|
const uint32_t block_id,
|
|
const uint32_t config_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Plugin index %u, package id %u, block id %u, instance id %u"
|
|
" priority %u", __func__, plg_idx, pkg_id, block_id, inst_id, priority);
|
|
|
|
pi.plg_idx = plg_idx;
|
|
pi.pkg_id = pkg_id;
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
pi.priority = priority;
|
|
pi.config_id = config_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_CREATE, (unsigned long)&pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set the creation configuration on a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* cdata - Creation configuration data
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_creation_config(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id,
|
|
struct iaxxx_create_config_data cdata)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_create_cfg pcc;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
pcc.inst_id = inst_id;
|
|
pcc.block_id = block_id;
|
|
pcc.cfg_size = 0;
|
|
switch (cdata.type) {
|
|
case CONFIG_FILE:
|
|
strlcpy(pcc.file_name, cdata.data.fdata.filename, NAME_MAX_SIZE);
|
|
ALOGV("%s: Configuration file name %s", __func__, pcc.file_name);
|
|
break;
|
|
case CONFIG_VALUE:
|
|
pcc.cfg_size = cdata.data.vdata.config_val_sz;
|
|
pcc.cfg_val = cdata.data.vdata.config_val;
|
|
ALOGV("%s: Configuration value %"PRId64, __func__, pcc.cfg_val);
|
|
break;
|
|
default:
|
|
ALOGE("%s: ERROR: Invalid type of configuration type", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
break;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u", __func__, inst_id, block_id);
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_CREATE_CFG, (unsigned long)&pcc);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Destroy the plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_destroy(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: instance id %u, block id %u", __func__, inst_id, block_id);
|
|
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_DESTROY, (unsigned long) &pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Enable the plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_enable(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: instance id %u, block id %u", __func__, inst_id, block_id);
|
|
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_ENABLE, (unsigned long)&pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Disable the plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_disable(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: instance id %u, block id %u", __func__, inst_id, block_id);
|
|
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_DISABLE, (unsigned long)&pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Reset the plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_reset(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: instance id %u, block id %u", __func__, inst_id, block_id);
|
|
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_RESET, (unsigned long)&pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set a parameter on a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* param_id - Parameter ID
|
|
* param_val - Parameter Value*
|
|
* block_id - Block ID
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_parameter(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t param_id,
|
|
const uint32_t param_val,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_param pp;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u param_id %u param_val %u",
|
|
__func__, inst_id, block_id, param_id, param_val);
|
|
|
|
pp.inst_id = inst_id;
|
|
pp.block_id = block_id;
|
|
pp.param_id = param_id;
|
|
pp.param_val = param_val;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_PARAM, (unsigned long)&pp);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get the value of parameter on a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* param_id - Parameter ID
|
|
* block_id - Block ID*
|
|
* param_val - Parameter Value
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_parameter(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t param_id,
|
|
const uint32_t block_id,
|
|
uint32_t *param_val)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_param pp;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
pp.inst_id = inst_id;
|
|
pp.block_id = block_id;
|
|
pp.param_id = param_id;
|
|
pp.param_val = 0;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_PARAM, (unsigned long)&pp);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
goto func_exit;
|
|
}
|
|
|
|
*param_val = pp.param_val;
|
|
|
|
ALOGV("%s: Instance id %u, block id %u param_id %u param_val %u",
|
|
__func__, inst_id, block_id, param_id, *param_val);
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set a parameter block on a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* param_blk_id - Parameter block id
|
|
* block_id - Block ID
|
|
* param_buf - Pointer to the parameter block
|
|
* param_buf_sz - Parameter block size
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_parameter_blk(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t param_blk_id,
|
|
const uint32_t block_id,
|
|
const void *param_buf,
|
|
const uint32_t param_buf_sz)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_param_blk ppb;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u, param_buf_sz %u, parm_blk_id %u",
|
|
__func__, inst_id, block_id, param_buf_sz, param_blk_id);
|
|
|
|
ppb.inst_id = inst_id;
|
|
ppb.block_id = block_id;
|
|
ppb.param_size = param_buf_sz;
|
|
ppb.param_blk = (uintptr_t)param_buf;
|
|
ppb.id = param_blk_id;
|
|
ppb.file_name[0] = '\0';
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_PARAM_BLK, (unsigned long)&ppb);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set a parameter block on a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* param_blk_id - Parameter block id
|
|
* block_id - Block ID
|
|
* file_name - Relative path to the Parameter File(Should be placed in
|
|
* the firmware location)
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_parameter_blk_from_file(
|
|
struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t param_blk_id,
|
|
const uint32_t block_id,
|
|
const char *file_name)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_param_blk ppb;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u, file_name %s, parm_blk_id %u",
|
|
__func__, inst_id, block_id, file_name, param_blk_id);
|
|
|
|
ppb.param_size = 0;
|
|
ppb.param_blk = (uintptr_t) NULL;
|
|
ppb.inst_id = inst_id;
|
|
ppb.block_id = block_id;
|
|
ppb.id = param_blk_id;
|
|
strlcpy(ppb.file_name, file_name, NAME_MAX_SIZE);
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_PARAM_BLK, (unsigned long)&ppb);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Set custom configuration for plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* param_blk_id - Parameter block id
|
|
* custom_config_id - Id for what type of custom configuration
|
|
* filename - Name of file with custom config data
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_custom_cfg(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id,
|
|
const uint32_t param_blk_id,
|
|
const uint32_t custom_config_id,
|
|
const char *filename)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_custom_cfg pcc;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u, param blk id %u"
|
|
" custom-config id %u filename %s",
|
|
__func__, inst_id, block_id, param_blk_id,custom_config_id, filename);
|
|
|
|
strlcpy(pcc.file_name, filename, NAME_MAX_SIZE);
|
|
pcc.inst_id = inst_id;
|
|
pcc.block_id = block_id;
|
|
pcc.param_blk_id = param_blk_id;
|
|
pcc.custom_config_id = custom_config_id;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_CUSTOM_CFG, (unsigned long)&pcc);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Subscribe to an event
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* src_id - System Id of event source
|
|
* event_id - Event Id
|
|
* dst_id - System Id of event destination
|
|
* dst_opaque - Info sought by destination task when even occurs
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_subscribe(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint16_t src_id,
|
|
const uint16_t event_id,
|
|
const uint16_t dst_id,
|
|
const uint32_t dst_opaque)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_evt_info ei;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: src id %u, event id %u, dst_id %u dst_opq %u",
|
|
__func__, src_id, event_id, dst_id, dst_opaque);
|
|
|
|
ei.src_id = src_id;
|
|
ei.event_id = event_id;
|
|
ei.dst_id = dst_id;
|
|
ei.dst_opaque = dst_opaque;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_EVENT_SUBSCRIBE, (unsigned long)&ei);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Unsubscribe an event
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* src_id - System Id of event source
|
|
* event_id - Event Id
|
|
* dst_id - System Id of event destination
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_unsubscribe(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint16_t src_id,
|
|
const uint16_t event_id,
|
|
const uint16_t dst_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_evt_info ei;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: src id %u, event id %u, dst_id %u",
|
|
__func__, src_id, event_id, dst_id);
|
|
|
|
ei.src_id = src_id;
|
|
ei.event_id = event_id;
|
|
ei.dst_id = dst_id;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_EVENT_UNSUBSCRIBE, (unsigned long)&ei);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Retrieve an event
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* event_info - Struct to return event info
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_getevent(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
struct iaxxx_get_event_info *event_info)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_get_event ei;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_EVENT, (unsigned long) &ei);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
ALOGV("%s: event id %u, data %u",
|
|
__func__, ei.event_id, ei.data);
|
|
event_info->event_id = ei.event_id;
|
|
event_info->data = ei.data;
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a plugin for a statically loaded package
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* priority - Priority of the plugin
|
|
* pkg_id - Package ID
|
|
* plg_idx - Plugin Index*
|
|
* block_id - Block ID
|
|
* config_id - Config ID
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_create_static_package(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t priority,
|
|
const uint32_t pkg_id,
|
|
const uint32_t plg_idx,
|
|
const uint32_t block_id,
|
|
const uint32_t config_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_info pi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Plugin index %u, package id %u, block id %u, instance id %u"
|
|
" priority %u", __func__, plg_idx, pkg_id, block_id, inst_id, priority);
|
|
|
|
pi.plg_idx = plg_idx;
|
|
pi.pkg_id = pkg_id;
|
|
pi.block_id = block_id;
|
|
pi.inst_id = inst_id;
|
|
pi.priority = priority;
|
|
pi.config_id = config_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_CREATE_STATIC_PACKAGE, (unsigned long)&pi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get a parameter block from a plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* block_id - Block ID
|
|
* param_blk_id - Parameter block id
|
|
* param_buf - Pointer to the parameter block
|
|
* param_buf_sz - Parameter block size in words
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_parameter_blk(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t block_id,
|
|
const uint32_t param_blk_id,
|
|
uint32_t *param_buf,
|
|
const uint32_t param_buf_sz)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_param_blk ppb;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u, param_buf_sz %u, id %u",
|
|
__func__, inst_id, block_id, param_buf_sz, param_blk_id);
|
|
|
|
ppb.inst_id = inst_id;
|
|
ppb.block_id = block_id;
|
|
ppb.id = param_blk_id;
|
|
ppb.param_size = param_buf_sz;
|
|
ppb.param_blk = (uintptr_t)param_buf;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_PARAM_BLK, (unsigned long)&ppb);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set Event for the plugin
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* eventEnableMask - event Mask
|
|
* block_id - Block ID
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_setevent(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t eventEnableMask,
|
|
const uint32_t block_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_set_event se;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: instance id %u, eventEnableMask %x, block id %u",
|
|
__func__, inst_id, eventEnableMask, block_id);
|
|
|
|
se.block_id = block_id;
|
|
se.event_enable_mask = eventEnableMask;
|
|
se.inst_id = inst_id;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_EVENT, (unsigned long)&se);
|
|
if (err == -1) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
return err;
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Trigger an event. This may be most useful when debugging the system,
|
|
* but can also be used to trigger simultaneous behavior in entities which
|
|
* have subscribed, or to simply provide notifications regarding host status:
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* src_id - SystemId of event source
|
|
* evt_id - Id of event
|
|
* src_opaque - Source opaque to pass with event notification
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_trigger(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint16_t src_id,
|
|
uint16_t evt_id,
|
|
uint32_t src_opaque)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_evt_trigger et;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: src_id=%u, evt_id=%u, src_opaque=%u", __func__, src_id, evt_id,
|
|
src_opaque);
|
|
|
|
et.src_id = src_id;
|
|
et.evt_id = evt_id;
|
|
et.src_opaque = src_opaque;
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node), ODSP_EVENT_TRIGGER,
|
|
(unsigned long)&et);
|
|
if (err == -1) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Fetches next event subscription entry from the last read position
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* src_id - System Id of event source
|
|
* evt_id - Event Id
|
|
* dst_id - System Id of event destination
|
|
* dst_opaque - Destination opaque data
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_read_subscription(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint16_t *src_id,
|
|
uint16_t *evt_id,
|
|
uint16_t *dst_id,
|
|
uint32_t *dst_opaque)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_evt_read_subscription ers;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node), ODSP_EVENT_READ_SUBSCRIPTION,
|
|
(unsigned long) &ers);
|
|
if (err == -1) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
ALOGV("%s: src_id=%u, evt_id=%u, dst_id=%u, dst_opaque=%u", __func__,
|
|
ers.src_id, ers.evt_id, ers.dst_id, ers.dst_opaque);
|
|
|
|
*src_id = ers.src_id;
|
|
*evt_id = ers.evt_id;
|
|
*dst_id = ers.dst_id;
|
|
*dst_opaque = ers.dst_opaque;
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Reset index for retrieving subscription entries
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_reset_read_index(struct iaxxx_odsp_hw *odsp_hw_hdl)
|
|
{
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node), ODSP_EVENT_RESET_READ_INDEX,
|
|
NULL);
|
|
if (err == -1) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Retrieve an event notification
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* src_id - pointer to uint16_t for reporting SystemId of
|
|
* event source
|
|
* evt_dd - pointer to uint16_t for reporting Id of event
|
|
* src_opaque - pointer to the first parameter of event
|
|
* dst_opaque - pointer to the second parameter of event
|
|
* This will be destOpaque in case if event is
|
|
* subscribed with valid destOpaque otherwise
|
|
* it will be used as second parameter.
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_evt_retrieve_notification(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint16_t *src_id,
|
|
uint16_t *evt_id,
|
|
uint32_t *src_opaque,
|
|
uint32_t *dst_opaque)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_evt_retrieve_notification ern;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_EVENT_RETRIEVE_NOTIFICATION, (unsigned long)&ern);
|
|
if (err == -1) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
ALOGV("%s: src_id=%u, evt_id=%u, src_opaque=%u, dst_opaque=%u",
|
|
__func__, ern.src_id, ern.evt_id, ern.src_opaque, ern.dst_opaque);
|
|
|
|
*src_id = ern.src_id;
|
|
*evt_id = ern.evt_id;
|
|
*src_opaque = ern.src_opaque;
|
|
*dst_opaque = ern.dst_opaque;
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/* Read Plugin Error Info
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* error_code - Pointer to uint32 to return error code
|
|
* error_instance - Pointer to uint8 to return plugin instance
|
|
* where error occurred.
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_read_error(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t block_id,
|
|
uint32_t *error_code,
|
|
uint8_t *error_instance)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_error_info pei;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Block id %u", __func__, block_id);
|
|
|
|
pei.block_id = block_id;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_READ_PLUGIN_ERROR, (unsigned long)&pei);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
*error_code = pei.error_code;
|
|
*error_instance = pei.error_instance;
|
|
ALOGV("%s: Plugin error code:%x instance=%d", __func__,
|
|
pei.error_code, pei.error_instance);
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/* Read the timestamps of all output endpoint
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* proc_id - Proc id
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_ep_timestamps(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint64_t *timestamps,
|
|
uint8_t proc_id)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_endpoint_timestamps pet = {
|
|
.proc_id = proc_id
|
|
};
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Proc id %u", __func__, proc_id);
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_ENDPOINT_TIMESTAMPS, (unsigned long)&pet);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
memcpy(timestamps, pet.timestamps, sizeof(pet.timestamps));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Set a parameter block on a plugin and get ack to
|
|
* ensure the data has been sent and retry if not.
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* param_blk_id - Parameter block id
|
|
* block_id - Block ID
|
|
* set_param_buf - Pointer to the parameter block
|
|
* set_param_buf_sz - Parameter block size in bytes
|
|
* response_data_buf - Buffer for response data from plugin
|
|
* response_data_sz - Size of Buffer in uint32 words for
|
|
* response data from plugin
|
|
* max_no_retries - Max number of retries in case of busy
|
|
* response from plugin.
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_set_parameter_blk_with_ack(
|
|
struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint32_t param_blk_id,
|
|
const uint32_t block_id,
|
|
const void *set_param_buf,
|
|
const uint32_t set_param_buf_sz,
|
|
uint32_t* response_data_buf,
|
|
const uint32_t response_data_sz,
|
|
const uint32_t max_no_retries)
|
|
{
|
|
|
|
int err = 0;
|
|
struct iaxxx_plugin_set_param_blk_with_ack_info pspbwa;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u, block id %u, param blk id %u max-retries:%u",
|
|
__func__, inst_id, block_id, param_blk_id, max_no_retries);
|
|
|
|
pspbwa.inst_id = inst_id;
|
|
pspbwa.block_id = block_id;
|
|
pspbwa.param_blk_id = param_blk_id;
|
|
pspbwa.set_param_blk_buffer = (uintptr_t)set_param_buf;
|
|
pspbwa.set_param_blk_size = set_param_buf_sz;
|
|
pspbwa.response_buffer = (uintptr_t)response_data_buf;
|
|
pspbwa.response_buf_size = response_data_sz;
|
|
pspbwa.max_retries = max_no_retries;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_SET_PARAM_BLK_WITH_ACK, (unsigned long)&pspbwa);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get Plugin status information.
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* plugin_status_data - Pointer to struct to return plugin status.
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_status_info(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
struct iaxxx_plugin_status_data *plugin_status_data)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_status_info psi;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u", __func__, inst_id);
|
|
|
|
psi.inst_id = inst_id;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_STATUS_INFO, (unsigned long) &psi);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
goto func_exit;
|
|
}
|
|
|
|
plugin_status_data->block_id = psi.block_id;
|
|
plugin_status_data->create_status = psi.create_status;
|
|
plugin_status_data->enable_status = psi.enable_status;
|
|
plugin_status_data->process_count = psi.process_count;
|
|
plugin_status_data->process_err_count = psi.process_err_count;
|
|
plugin_status_data->in_frames_consumed = psi.in_frames_consumed;
|
|
plugin_status_data->out_frames_produced = psi.out_frames_produced;
|
|
plugin_status_data->private_memsize = psi.private_memsize;
|
|
plugin_status_data->frame_notification_mode = psi.frame_notification_mode;
|
|
plugin_status_data->state_management_mode = psi.state_management_mode;
|
|
|
|
ALOGV("%s: block_id:%u create_status:%d enable_status:%d",
|
|
__func__, psi.block_id, psi.create_status, psi.enable_status);
|
|
ALOGV("%s: in_frames_consumed:%u out_frames_produced:%u",
|
|
__func__, psi.in_frames_consumed, psi.out_frames_produced);
|
|
ALOGV("%s: process_count:%u process_err_count=%u private_memsize=%u",
|
|
__func__, psi.process_count, psi.process_err_count,
|
|
psi.private_memsize);
|
|
ALOGV("%s: frame_notification_mode:%u state_management_mode=%u",
|
|
__func__, psi.frame_notification_mode, psi.state_management_mode);
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Get Plugin endpoint status information.
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* inst_id - Instance ID
|
|
* ep_index - Index of Endpoint
|
|
* direction - If Input endpoint or Output endpoint
|
|
* 0 => input, 1 => output
|
|
* plugin_ep_status_data - Pointer to struct to return plugin
|
|
* endpoint status.
|
|
*
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_plugin_get_endpoint_status(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
const uint32_t inst_id,
|
|
const uint8_t ep_index,
|
|
const uint8_t direction,
|
|
struct iaxxx_plugin_endpoint_status_data *plugin_ep_status_data)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_plugin_endpoint_status_info plugin_ep_status_info;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Instance id %u", __func__, inst_id);
|
|
|
|
plugin_ep_status_info.inst_id = inst_id;
|
|
plugin_ep_status_info.ep_index = ep_index;
|
|
plugin_ep_status_info.direction = direction;
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_PLG_GET_ENDPOINT_STATUS,
|
|
(unsigned long) &plugin_ep_status_info);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
goto func_exit;
|
|
}
|
|
|
|
plugin_ep_status_data->status
|
|
= plugin_ep_status_info.status;
|
|
plugin_ep_status_data->frame_status
|
|
= plugin_ep_status_info.frame_status;
|
|
plugin_ep_status_data->endpoint_status
|
|
= plugin_ep_status_info.endpoint_status;
|
|
plugin_ep_status_data->usage
|
|
= plugin_ep_status_info.usage;
|
|
plugin_ep_status_data->mandatory
|
|
= plugin_ep_status_info.mandatory;
|
|
plugin_ep_status_data->counter
|
|
= plugin_ep_status_info.counter;
|
|
|
|
if(direction) {
|
|
plugin_ep_status_data->op_encoding
|
|
= plugin_ep_status_info.op_encoding;
|
|
plugin_ep_status_data->op_sample_rate
|
|
= plugin_ep_status_info.op_sample_rate;
|
|
plugin_ep_status_data->op_frame_length
|
|
= plugin_ep_status_info.op_frame_length;
|
|
}
|
|
|
|
ALOGV("%s: status:%u frame_status:%d endpoint_status:%d",
|
|
__func__, plugin_ep_status_data->status,
|
|
plugin_ep_status_info.frame_status,
|
|
plugin_ep_status_info.endpoint_status);
|
|
|
|
ALOGV("%s: usage:%d mandatory:%d counter:%u",
|
|
__func__, plugin_ep_status_data->usage,
|
|
plugin_ep_status_info.mandatory,
|
|
plugin_ep_status_info.counter);
|
|
|
|
if(direction)
|
|
ALOGV("%s: op_encoding:%d op_sample_rate:%d op_frame_length:%u",
|
|
__func__, plugin_ep_status_data->op_encoding,
|
|
plugin_ep_status_info.op_sample_rate,
|
|
plugin_ep_status_info.op_frame_length);
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns the execution status of given processor
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* proc_id - Proc id
|
|
* status - Execution status of the processor
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_get_proc_execution_status(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint8_t proc_id,
|
|
uint32_t *status)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_proc_execution_status s = {
|
|
.proc_id = proc_id
|
|
};
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
ALOGV("%s: Proc id %u", __func__, proc_id);
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_PROC_EXECUTION_STATUS, (unsigned long)&s);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
uint32_t id, type;
|
|
|
|
*status = s.status;
|
|
|
|
id = ((*status & IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_IDENTIFIER_MASK)
|
|
>> IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_IDENTIFIER_POS);
|
|
type = ((*status & IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_TYPE_MASK)
|
|
>> IAXXX_DEBUG_BLOCK_0_EXEC_STATUS_TYPE_POS);
|
|
switch (type) {
|
|
case 0:
|
|
ALOGI("%s() Proc %d is running Firmware\n",
|
|
__func__, s.proc_id);
|
|
break;
|
|
case 1:
|
|
ALOGI("%s() Proc %d is running ISR %d\n",
|
|
__func__, s.proc_id, id);
|
|
break;
|
|
case 2:
|
|
ALOGI("%s() Proc %d is running Package ID %d\n",
|
|
__func__, s.proc_id, id);
|
|
break;
|
|
case 3:
|
|
ALOGI("%s() Proc %d is running Plugin inst ID %d\n",
|
|
__func__, s.proc_id, id);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Returns Rom version number, Rom version string
|
|
* Application version number, Application version string
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* rom_ver_num - Rom version number
|
|
* rom_ver_str - Rom version string
|
|
* rom_ver_str_len - Rom version string length
|
|
* app_ver_num - App version number
|
|
* app_ver_str - App version string
|
|
* app_ver_str_len - App version string length
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_get_sys_versions(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint32_t *rom_ver_num,
|
|
char *rom_ver_str,
|
|
uint32_t rom_ver_str_len,
|
|
uint32_t *app_ver_num,
|
|
char *app_ver_str,
|
|
uint32_t app_ver_str_len)
|
|
{
|
|
int err = 0;
|
|
struct iaxxx_sys_versions v = {
|
|
.app_ver_str_len =
|
|
(app_ver_str ? app_ver_str_len : IAXXX_MAX_VER_STR_SIZE),
|
|
.rom_ver_str_len =
|
|
(rom_ver_str ? rom_ver_str_len : IAXXX_MAX_VER_STR_SIZE)
|
|
};
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_SYS_VERSIONS, (unsigned long)&v);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
} else {
|
|
if (rom_ver_num)
|
|
*rom_ver_num = v.rom_ver_num;
|
|
if (rom_ver_str)
|
|
memcpy(rom_ver_str, v.rom_ver_str, v.rom_ver_str_len);
|
|
if (app_ver_num)
|
|
*app_ver_num = v.app_ver_num;
|
|
if (app_ver_str)
|
|
memcpy(app_ver_str, v.app_ver_str, v.app_ver_str_len);
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Returns Device ID
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* device_id - Returned Device ID
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_get_device_id(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint32_t *device_id)
|
|
{
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_SYS_DEVICE_ID, (unsigned long)device_id);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Returns System mode
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* mode - Returned system mode
|
|
* 0: System is in reset mode.
|
|
* 1: System is currently in bootloader mode.
|
|
* 2: System has entered application mode.
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_get_sys_mode(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint32_t *mode)
|
|
{
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (odsp_hw_hdl == NULL) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_SYS_MODE, (unsigned long)mode);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Returns Firmware status
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
* mode - Returned firmware status
|
|
* 0: Firmware has crashed
|
|
* 1: Firmware is idle
|
|
* 2: Firmware is active
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_get_fw_status(struct iaxxx_odsp_hw *odsp_hw_hdl,
|
|
uint32_t *status)
|
|
{
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (NULL == odsp_hw_hdl) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node),
|
|
ODSP_GET_FW_STATUS, (unsigned long)status);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Resets the firmware by redownloading the firmware
|
|
*
|
|
* Input - odsp_hw_hdl - Handle to odsp hw structure
|
|
*
|
|
* Output - 0 on success, on failure < 0
|
|
*/
|
|
int iaxxx_odsp_reset_fw(struct iaxxx_odsp_hw *odsp_hw_hdl)
|
|
{
|
|
int err = 0;
|
|
|
|
FUNCTION_ENTRY_LOG;
|
|
|
|
if (NULL == odsp_hw_hdl) {
|
|
ALOGE("%s: ERROR: Invalid handle to iaxxx_odsp_hw", __func__);
|
|
err = -1;
|
|
goto func_exit;
|
|
}
|
|
|
|
err = ioctl(fileno(odsp_hw_hdl->dev_node), ODSP_RESET_FW);
|
|
if (err < 0) {
|
|
ALOGE("%s: ERROR: Failed with error %s", __func__, strerror(errno));
|
|
}
|
|
|
|
func_exit:
|
|
FUNCTION_EXIT_LOG;
|
|
return err;
|
|
}
|
|
|