| /* |
| * 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; |
| } |
| |
