/*
 * 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 "SoundTriggerHALUtil"
#define LOG_NDEBUG 0

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <signal.h>
#include <sys/stat.h>
#include <log/log.h>

#include <errno.h>
#include <linux/errno.h>
#include <sys/ioctl.h>

#include "cvq_ioctl.h"

/* Array for ST route */
static const char * const route_table[ST_ROUTE_MAX] = {

/* Input Port routing definition */
    [ST_MIC_ROUTE_INT_CLK] = "mic-route-internal-clock",
    [ST_MIC_ROUTE_EXT_CLK] = "mic-route-external-clock",
    [ST_BARGEIN_AMP_REF] = "bargein-amp-ref",
    [ST_BARGEIN_AMP_REF_48K] = "bargein-amp-ref-48k",

/* Plugin routing definition */
    [ST_HOTWORD_WITHOUT_BARGEIN] = "hotword-route-without-bargein",
    [ST_HOTWORD_WITH_BARGEIN] = "hotword-route-with-bargein",
    [ST_HOTWORD_BUFFER_WITHOUT_BARGEIN] = "buffer-route-without-bargein",
    [ST_HOTWORD_BUFFER_WITH_BARGEIN] = "buffer-route-with-bargein",
    [ST_AMBIENT_WITHOUT_BARGEIN] = "ambient-route-without-bargein",
    [ST_AMBIENT_WITH_BARGEIN] = "ambient-route-with-bargein",
    [ST_AMBIENT_BUFFER_WITHOUT_BARGEIN] = "downlink-audio-route",
    [ST_AMBIENT_BUFFER_WITH_BARGEIN] = "music-audio-route",
    [ST_BARGEIN_ROUTE] = "bargein-route",
    [ST_CHRE_WITHOUT_BARGEIN] = "chre-route-without-bargein",
    [ST_CHRE_WITH_BARGEIN] = "chre-route-with-bargein",
    [ST_SRC_ROUTE_MIC] = "src-route-mic",
    [ST_SRC_ROUTE_AMP_REF] = "src-route-amp-ref",
    [ST_SENSOR_ROUTE] = "oslo-route",
};

int write_model(struct iaxxx_odsp_hw *odsp_hdl, unsigned char *data,
                int length, int kw_type)
 {
    int err = 0;

    switch(kw_type)
    {
        case 0: //HOTWORD
            ALOGV("+%s+ OK_GOOGLE_KW_ID", __func__);

            err = iaxxx_odsp_plugin_set_parameter_blk(odsp_hdl,
                                        HOTWORD_INSTANCE_ID, HOTWORD_SLOT_ID,
                                        IAXXX_HMD_BLOCK_ID, data, length);
            break;
        case 1: //AMBIENT
            ALOGV("+%s+ AMBIENT_KW_ID", __func__);

            err = iaxxx_odsp_plugin_set_parameter_blk(odsp_hdl,
                                    AMBIENT_INSTANCE_ID, AMBIENT_SLOT_ID,
                                    IAXXX_HMD_BLOCK_ID, data, length);
            break;
        case 2: //ENTITY
            ALOGV("+%s+ Entity_KW_ID", __func__);

            err = iaxxx_odsp_plugin_set_parameter_blk(odsp_hdl,
                                    AMBIENT_INSTANCE_ID, ENTITY_SLOT_ID,
                                    IAXXX_HMD_BLOCK_ID, data, length);
            break;
        case 3: //WAKEUP
            ALOGV("+%s+ WAKEUP_KW_ID", __func__);

            err = iaxxx_odsp_plugin_set_parameter_blk(odsp_hdl,
                                    HOTWORD_INSTANCE_ID, WAKEUP_SLOT_ID,
                                    IAXXX_HMD_BLOCK_ID, data, length);
            break;
        default:
            ALOGE("%s: Unknown KW_ID\n", __func__);
            err = -EINVAL;
            goto exit;
    }

    if (err < 0) {
        ALOGE("%s: Failed to load the keyword with error %s\n",
            __func__, strerror(errno));
        goto exit;
    }

    ALOGV("-%s-", __func__);
exit:
    return err;
}

int get_model_state(struct iaxxx_odsp_hw *odsp_hdl, const uint32_t inst_id,
                    const uint32_t param_val)
{
    int err = 0;
    const uint32_t param_id = AMBIENT_GET_MODEL_STATE_PARAM_ID;
    const uint32_t block_id = IAXXX_HMD_BLOCK_ID;

    err = iaxxx_odsp_plugin_set_parameter(odsp_hdl, inst_id, param_id,
                                          param_val, block_id);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to get the model state", __func__);
    }

    return err;
}

int get_event(struct iaxxx_odsp_hw *odsp_hdl, struct iaxxx_get_event_info *ge)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    err = iaxxx_odsp_evt_getevent(odsp_hdl, ge);
    if (err != 0) {
        ALOGE("%s: ERROR Failed to get event with error %d(%s)",
            __func__, errno, strerror(errno));
    }

    ALOGV("-%s-", __func__);
    return err;
}

int reset_ambient_plugin(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                        AMBIENT_INSTANCE_ID,
                                        AMBIENT_RESET_PARAM_ID,
                                        AMBIENT_SLOT_ID,
                                        IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Set param for ambient lib reset failed %d(%s)",
            __func__, errno, strerror(errno));
    }

    ALOGV("-%s-", __func__);
    return err;
}

int set_sensor_route(struct audio_route *route_hdl, bool enable)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    if (enable)
        err = audio_route_apply_and_update_path(route_hdl, route_table[ST_SENSOR_ROUTE]);
    else
        err = audio_route_reset_and_update_path(route_hdl, route_table[ST_SENSOR_ROUTE]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int set_ambient_state(struct iaxxx_odsp_hw *odsp_hdl,
                    unsigned int current)
{
    int err = 0;
    ALOGV("+%s+ enable models %x", __func__, current & PLUGIN2_MASK);

    err = iaxxx_odsp_plugin_setevent(odsp_hdl, AMBIENT_INSTANCE_ID,
                                    current & PLUGIN2_MASK, IAXXX_HMD_BLOCK_ID);
    if (err < 0) {
        ALOGE("%s: ERROR: ambient set event failed with error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }
    if (current & AMBIENT_MASK) {
        err = iaxxx_odsp_evt_subscribe(odsp_hdl, AMBIENT_EVT_SRC_ID,
                                    AMBIENT_DETECTION, IAXXX_SYSID_HOST, 0);
        if (err < 0) {
            ALOGE("%s: ERROR: Ambient subscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }

    }
    if (current & ENTITY_MASK) {
        err = iaxxx_odsp_evt_subscribe(odsp_hdl, AMBIENT_EVT_SRC_ID,
                                    ENTITY_DETECTION, IAXXX_SYSID_HOST, 0);
        if (err < 0) {
            ALOGE("%s: ERROR: Entity subscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
    }

exit:
    ALOGV("-%s-", __func__);
    return err;
}

int tear_ambient_state(struct iaxxx_odsp_hw *odsp_hdl,
                    unsigned int current)
{
    int err = 0;
    ALOGV("+%s+ current %x", __func__, current & PLUGIN2_MASK);
    if (current & AMBIENT_MASK) {
        err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, AMBIENT_EVT_SRC_ID,
                                        AMBIENT_DETECTION, IAXXX_SYSID_HOST);
        if (err < 0) {
            ALOGE("%s: ERROR: Ambient unsubscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
        err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                            AMBIENT_INSTANCE_ID,
                                            AMBIENT_UNLOAD_PARAM_ID,
                                            AMBIENT_SLOT_ID,
                                            IAXXX_HMD_BLOCK_ID);
        if (err < 0) {
            ALOGE("%s: ERROR: Ambient model unload failed with error %d(%s)",
                __func__, errno, strerror(errno));
            goto exit;
        }
    }
    if (current & ENTITY_MASK) {
        err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, AMBIENT_EVT_SRC_ID,
                                        ENTITY_DETECTION, IAXXX_SYSID_HOST);
        if (err < 0) {
            ALOGE("%s: ERROR: Entity unsubscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
        err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                            AMBIENT_INSTANCE_ID,
                                            AMBIENT_UNLOAD_PARAM_ID,
                                            ENTITY_SLOT_ID,
                                            IAXXX_HMD_BLOCK_ID);
        if (err < 0) {
            ALOGE("%s: ERROR: Entity model unload failed with error %d(%s)",
                __func__, errno, strerror(errno));
            goto exit;
        }
    }

exit:
    ALOGV("-%s-", __func__);
    return err;
}

int set_ambient_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s bargein %d+", __func__, bargein);

    if (bargein == true)
        err = audio_route_apply_and_update_path(route_hdl,
                                        route_table[ST_AMBIENT_WITH_BARGEIN]);
    else
        err = audio_route_apply_and_update_path(route_hdl,
                                        route_table[ST_AMBIENT_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route apply fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int tear_ambient_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s bargein %d+", __func__, bargein);
    /* check cvq node to send ioctl */
    if (bargein == true)
        err = audio_route_reset_and_update_path(route_hdl,
                                        route_table[ST_AMBIENT_WITH_BARGEIN]);
    else
        err = audio_route_reset_and_update_path(route_hdl,
                                        route_table[ST_AMBIENT_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route reset fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int set_hotword_state(struct iaxxx_odsp_hw *odsp_hdl, unsigned int current)
{
    int err = 0;

    ALOGV("+%s+ current %x", __func__, current & PLUGIN1_MASK);
    // Set the events and params
    err = iaxxx_odsp_plugin_setevent(odsp_hdl, HOTWORD_INSTANCE_ID,
                                    current & PLUGIN1_MASK, IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Hotword set event failed with error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    if (current & HOTWORD_MASK) {
        ALOGD("Registering for Hotword event\n");
        err = iaxxx_odsp_evt_subscribe(odsp_hdl, HOTWORD_EVT_SRC_ID,
                                    HOTWORD_DETECTION, IAXXX_SYSID_HOST, 0);
        if (err < 0) {
            ALOGE("%s: ERROR: HOTWORD subscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }

    }
    if (current & WAKEUP_MASK) {
        ALOGD("Registering for Wakeup event\n");
        err = iaxxx_odsp_evt_subscribe(odsp_hdl, HOTWORD_EVT_SRC_ID,
                                    WAKEUP_DETECTION, IAXXX_SYSID_HOST, 0);
        if (err < 0) {
            ALOGE("%s: ERROR: WAKEUP subscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
    }

    ALOGV("-%s-", __func__);
exit:
    return err;
}

int tear_hotword_state(struct iaxxx_odsp_hw *odsp_hdl, unsigned int current)
{
    int err = 0;

    ALOGV("+%s+ current %x", __func__, current & PLUGIN1_MASK);
    if (current & HOTWORD_MASK) {
        err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, HOTWORD_EVT_SRC_ID,
                                        HOTWORD_DETECTION, IAXXX_SYSID_HOST);
        if (err < 0) {
            ALOGE("%s: ERROR: Hotword unsubscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
        err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                            HOTWORD_INSTANCE_ID,
                                            HOTWORD_UNLOAD_PARAM_ID,
                                            HOTWORD_SLOT_ID,
                                            IAXXX_HMD_BLOCK_ID);

        if (err < 0) {
            ALOGE("%s: ERROR: Ambient model unload failed with error %d(%s)",
                __func__, errno, strerror(errno));
            goto exit;
        }
    }
    if (current & WAKEUP_MASK) {
        err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, HOTWORD_EVT_SRC_ID,
                                        WAKEUP_DETECTION, IAXXX_SYSID_HOST);
        if (err < 0) {
            ALOGE("%s: ERROR: WAKEUP unsubscribe event failed"
                " with error %d(%s)", __func__,
                errno, strerror(errno));
            goto exit;
        }
        err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                            HOTWORD_INSTANCE_ID,
                                            HOTWORD_UNLOAD_PARAM_ID,
                                            WAKEUP_SLOT_ID,
                                            IAXXX_HMD_BLOCK_ID);
        if (err < 0) {
            ALOGE("%s: ERROR: WAKEUP model unload failed with error %d(%s)",
                __func__, errno, strerror(errno));
            goto exit;
        }
    }

    ALOGV("-%s-", __func__);
exit:
    return err;
}

int set_hotword_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s bargein %d+", __func__, bargein);

    if (bargein == true)
        err = audio_route_apply_and_update_path(route_hdl,
                                            route_table[ST_HOTWORD_WITH_BARGEIN]);
    else
        err = audio_route_apply_and_update_path(route_hdl,
                                            route_table[ST_HOTWORD_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route apply fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int tear_hotword_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s bargein %d+", __func__, bargein);
    /* check cvq node to send ioctl */
    if (bargein == true)
        err = audio_route_reset_and_update_path(route_hdl,
                                            route_table[ST_HOTWORD_WITH_BARGEIN]);
    else
        err = audio_route_reset_and_update_path(route_hdl,
                                            route_table[ST_HOTWORD_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route reset fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int set_chre_audio_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    if (bargein)
        err = audio_route_apply_and_update_path(route_hdl,
                                        route_table[ST_CHRE_WITH_BARGEIN]);
    else
        err = audio_route_apply_and_update_path(route_hdl,
                                        route_table[ST_CHRE_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route apply fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int tear_chre_audio_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    if (bargein == true)
        err = audio_route_reset_and_update_path(route_hdl,
                                        route_table[ST_CHRE_WITH_BARGEIN]);
    else
        err = audio_route_reset_and_update_path(route_hdl,
                                        route_table[ST_CHRE_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route reset fail %d", __func__, err);

    ALOGV("-%s-", __func__);
    return err;
}

int sensor_event_init_params(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGV("+%s+", __func__);
    // Set the events and params
    err = iaxxx_odsp_plugin_setevent(odsp_hdl, SENSOR_INSTANCE_ID, 0x1F,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor set event with error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("Registering for 3 sensor mode switch events\n");

    // Subscribe for events
    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                SENSOR_PRESENCE_MODE, IAXXX_SYSID_SCRIPT_MGR,
                                0x1201);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (presence mode) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Subscribe for events
    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                SENSOR_DETECTED_MODE, IAXXX_SYSID_SCRIPT_MGR,
                                0x1202);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (detection mode) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Subscribe for events
    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                SENSOR_MAX_MODE, IAXXX_SYSID_HOST, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (max mode) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_DATA_EVENT_ID, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (oslo data event) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_CONFIGURED, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (oslo configured) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_DESTROYED, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor subscribe (oslo destroyed) %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, IAXXX_SYSID_HOST_1,
                                   OSLO_EP_DISCONNECT, IAXXX_SYSID_HOST_0, 0);
    if (err == -1) {
        ALOGE("%s: ERROR: oslo event subscription (oslo ep disconnect) failed with"
              " error %d(%s)", __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_trigger(odsp_hdl, OSLO_EVT_SRC_ID, OSLO_CONFIGURED, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: olso event trigger (oslo configured) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGV("-%s-", __func__);

exit:
    return err;
}

static int sensor_event_deinit_params(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID, SENSOR_MAX_MODE,
                                    IAXXX_SYSID_HOST);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
            " error %d(%s)", __func__, OSLO_EVT_SRC_ID,
            SENSOR_MAX_MODE, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                SENSOR_DETECTED_MODE, IAXXX_SYSID_SCRIPT_MGR);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " error %d(%s)", __func__, OSLO_EVT_SRC_ID,
              SENSOR_DETECTED_MODE, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                SENSOR_PRESENCE_MODE, IAXXX_SYSID_SCRIPT_MGR);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " error %d(%s)", __func__, OSLO_EVT_SRC_ID,
              SENSOR_PRESENCE_MODE, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_DATA_EVENT_ID, IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " from host %d error %d(%s)", __func__, OSLO_EVT_SRC_ID,
              OSLO_DATA_EVENT_ID, IAXXX_SYSID_HOST_1, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_CONFIGURED, IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " from host %d error %d(%s)", __func__, OSLO_EVT_SRC_ID,
              OSLO_CONFIGURED, IAXXX_SYSID_HOST_1, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, OSLO_EVT_SRC_ID,
                                OSLO_DESTROYED, IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " from host %d error %d(%s)", __func__, OSLO_EVT_SRC_ID,
              OSLO_DESTROYED, IAXXX_SYSID_HOST_1, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, IAXXX_SYSID_HOST_1,
                                OSLO_EP_DISCONNECT, IAXXX_SYSID_HOST_0);
    if (err != 0) {
        ALOGE("%s: Failed to unsubscribe sensor event (src id %d event id %d)"
              " from host %d with the error %d(%s)", __func__, IAXXX_SYSID_HOST_1,
              OSLO_EP_DISCONNECT, IAXXX_SYSID_HOST_0, errno, strerror(errno));
         goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int flush_model(struct iaxxx_odsp_hw *odsp_hdl, int kw_type)
{
    int err = 0;

    ALOGV("+%s+", __func__);

    switch(kw_type)
    {
        case 0: //HOTWORD
            err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                                HOTWORD_INSTANCE_ID,
                                                HOTWORD_UNLOAD_PARAM_ID,
                                                HOTWORD_SLOT_ID,
                                                IAXXX_HMD_BLOCK_ID);
            break;
        case 1: //AMBIENT
            err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                                AMBIENT_INSTANCE_ID,
                                                AMBIENT_UNLOAD_PARAM_ID,
                                                AMBIENT_SLOT_ID,
                                                IAXXX_HMD_BLOCK_ID);
            break;
        case 2: //ENTITY
            err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                                AMBIENT_INSTANCE_ID,
                                                AMBIENT_UNLOAD_PARAM_ID,
                                                ENTITY_SLOT_ID,
                                                IAXXX_HMD_BLOCK_ID);
            break;
        case 3: //WAKEUP
            err = iaxxx_odsp_plugin_set_parameter(odsp_hdl,
                                                HOTWORD_INSTANCE_ID,
                                                HOTWORD_UNLOAD_PARAM_ID,
                                                WAKEUP_SLOT_ID,
                                                IAXXX_HMD_BLOCK_ID);
            break;
        default:
            ALOGE("%s: Unknown KW_ID\n", __func__);
            err = -1;
            errno = -EINVAL;
            break;
    }

    if (err < 0) {
        ALOGE("%s: ERROR: model unload set param failed with error %d(%s)",
            __func__, errno, strerror(errno));
    }

    ALOGV("-%s-", __func__);
    return err;
}

int setup_buffer_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_package_load(odsp_hdl, BUFFER_PACKAGE, BUF_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load Buffer package %d(%s)",
                __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_buffer_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_package_unload(odsp_hdl, BUF_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload Buffer package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_hotword_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    // Download packages for ok google
    err = iaxxx_odsp_package_load(odsp_hdl, AMBIENT_EC_PACKAGE,
                                HOTWORD_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load Hotword package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Hotword plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, HOTWORD_INSTANCE_ID, HOTWORD_PRIORITY,
                                HOTWORD_PKG_ID, HOTWORD_PLUGIN_IDX,
                                IAXXX_HMD_BLOCK_ID, PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Hotword plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_set_parameter(odsp_hdl, HOTWORD_INSTANCE_ID, 0,
                                          0, IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Hotword init frontend failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_hotword_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, HOTWORD_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy Hotword plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Unload hotword package
    err = iaxxx_odsp_package_unload(odsp_hdl, HOTWORD_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload Hotword package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

unsigned int get_hotword_version(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;
    const uint32_t inst_id = HOTWORD_INSTANCE_ID;
    const uint32_t param_id = HOTWORD_GET_VERSION_PARAM_ID;
    const uint32_t block_id = IAXXX_HMD_BLOCK_ID;
    unsigned int param_val = HOTWORD_DEFAULT_VER;

    err = setup_hotword_package(odsp_hdl);
    if (err != 0) {
        if (errno == EEXIST) {
            ALOGW("%s: WARN: Hotword package existed already", __func__);
            err = iaxxx_odsp_plugin_get_parameter(odsp_hdl, inst_id, param_id,
                                                  block_id, &param_val);
            if (err != 0) {
                ALOGE("%s: Failed to get parameter for id %u with error %d: %s",
                      __func__, param_id, err, strerror(errno));
            } else {
                ALOGD("%s: Value of parameter id %u is %u", __func__, param_id,
                      param_val);
            }
        } else {
            ALOGE("%s: ERROR: setup hotword package failed", __func__);
        }
    } else {
        err = iaxxx_odsp_plugin_get_parameter(odsp_hdl, inst_id, param_id,
                                              block_id, &param_val);
        if (err != 0) {
            ALOGE("%s: Failed to get parameter for id %u with error %d: %s",
                  __func__, param_id, err, strerror(errno));
        } else {
            ALOGD("%s: Value of parameter id %u is %u", __func__, param_id,
                  param_val);
        }
        err = destroy_hotword_package(odsp_hdl);
        if (err != 0)
            ALOGE("%s: ERROR: destroy hotword package failed", __func__);
    }

    return param_val;
}

int setup_ambient_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    // Download packages for ambient
    err = iaxxx_odsp_package_load(odsp_hdl, AMBIENT_DA_PACKAGE,
                                AMBIENT_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load Ambient package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Ambient plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, AMBIENT_INSTANCE_ID,
                                AMBIENT_PRIORITY, AMBIENT_PKG_ID,
                                AMBIENT_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Ambient plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_set_parameter(odsp_hdl, AMBIENT_INSTANCE_ID,
                                        0, 0, IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Ambient init frontend failed %d(%s)",
              __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_ambient_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, AMBIENT_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy Ambient plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_package_unload(odsp_hdl, AMBIENT_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload Ambient package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

unsigned int get_ambient_version(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;
    const uint32_t inst_id = AMBIENT_INSTANCE_ID;
    const uint32_t param_id = AMBIENT_GET_VERSION_PARAM_ID;
    const uint32_t block_id = IAXXX_HMD_BLOCK_ID;
    unsigned int param_val = AMBIENT_DEFAULT_VER;

    err = setup_ambient_package(odsp_hdl);
    if (err != 0) {
        if (errno == EEXIST) {
            ALOGW("%s: WARN: Ambient package existed already", __func__);
            err = iaxxx_odsp_plugin_get_parameter(odsp_hdl, inst_id, param_id,
                                              block_id, &param_val);
            if (err != 0) {
                ALOGE("%s: Failed to get parameter for id %u with error %d: %s",
                      __func__, param_id, err, strerror(errno));
            } else {
                ALOGD("%s: Value of parameter id %u is %u", __func__, param_id,
                      param_val);
            }
        } else {
            ALOGE("%s: ERROR: setup Ambient package failed", __func__);
        }
    } else {
        err = iaxxx_odsp_plugin_get_parameter(odsp_hdl, inst_id, param_id,
                                              block_id, &param_val);
        if (err != 0) {
            ALOGE("%s: Failed to get parameter for id %u with error %d: %s",
                  __func__, param_id, err, strerror(errno));
        } else {
            ALOGD("%s: Value of parameter id %u is %u", __func__, param_id,
                  param_val);
        }
        err = destroy_ambient_package(odsp_hdl);
        if (err != 0)
            ALOGE("%s: ERROR: destroy Ambient package failed", __func__);
    }

    return param_val;
}

int setup_aec_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_package_load(odsp_hdl, ECHOCANCELLER_PACKAGE,
                                AEC_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load AEC passthrough package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // AEC PT Plugin Create
    err = iaxxx_odsp_plugin_create(odsp_hdl, AEC_INSTANCE_ID, AEC_PRIORITY,
                                AEC_PKG_ID, AEC_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create AEC plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_aec_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, AEC_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy AEC plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_package_unload(odsp_hdl, AEC_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload AEC package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_chre_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;
    struct iaxxx_create_config_data cdata;

    ALOGD("+%s+", __func__);

    /* Create CHRE plugins */
    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = BUFFER_CONFIG_VAL_CHRE;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                                CHRE_INSTANCE_ID,
                                                IAXXX_HMD_BLOCK_ID,
                                                cdata);
    if (err != 0) {
        ALOGE("%s: ERROR: CHRE Buffer configuration failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create CHRE Buffer plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, CHRE_INSTANCE_ID, BUF_PRIORITY,
                                   BUF_PKG_ID, CHRE_PLUGIN_IDX,
                                   IAXXX_HMD_BLOCK_ID, PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create CHRE buffer %d(%s)",
           __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_set_parameter(odsp_hdl, CHRE_INSTANCE_ID,
                                CHRE_EVT_PARAM_ID, CHRE_BUF_SIZE,
                                IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: CHRE buffer set param failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_setevent(odsp_hdl, CHRE_INSTANCE_ID,
                                CHRE_EVT_MASK, IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: CHRE set event failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Subscribe for events
    err = iaxxx_odsp_evt_subscribe(odsp_hdl, CHRE_EVT_SRC_ID,
                                CHRE_EVT_ID, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_EVT_ID, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, CHRE_EVT_SRC_ID,
                                CHRE_CONFIGURED, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_CONFIGURED, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, CHRE_EVT_SRC_ID,
                                CHRE_DESTROYED, IAXXX_SYSID_HOST_1, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_DESTROYED, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_subscribe(odsp_hdl, IAXXX_SYSID_HOST_1,
                                   CHRE_EP_DISCONNECT, IAXXX_SYSID_HOST_0, 0);
    if (err == -1) {
        ALOGE("%s: ERROR: CHRE event subscription (CHRE EP disconnect) failed "
              " with error %d(%s)", __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_trigger(odsp_hdl, CHRE_EVT_SRC_ID, CHRE_CONFIGURED, 0);
    if (err != 0) {
        ALOGE("%s: ERROR: CHRE event trigger (chre configured) failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_chre_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, CHRE_EVT_SRC_ID, CHRE_EVT_ID,
                                    IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_UNSUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_EVT_ID, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, CHRE_EVT_SRC_ID, CHRE_CONFIGURED,
                                    IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_UNSUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_CONFIGURED, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, CHRE_EVT_SRC_ID, CHRE_DESTROYED,
                                    IAXXX_SYSID_HOST_1);
    if (err != 0) {
        ALOGE("%s: ERROR: ODSP_EVENT_UNSUBSCRIBE (for event_id %d, src_id %d)"
            " IOCTL failed %d(%s)", __func__, CHRE_DESTROYED, CHRE_EVT_SRC_ID,
            errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, IAXXX_SYSID_HOST_1,
                                     CHRE_EP_DISCONNECT, IAXXX_SYSID_HOST_0);
    if (err == -1) {
        ALOGE("%s: ERROR: ODSP_EVENT_UNSUBSCRIBE (for event_id %d, src_id %d)"
              " IOCTL failed with error %d(%s)", __func__, CHRE_EP_DISCONNECT,
              IAXXX_SYSID_HOST_1, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, CHRE_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy buffer plugin for CHRE %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int trigger_chre_destroy_event(struct iaxxx_odsp_hw *odsp_hdl) {
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_evt_trigger(odsp_hdl, CHRE_EVT_SRC_ID, CHRE_DESTROYED, 0);
    if (err == -1) {
        ALOGE("%s: ERROR: CHRE event trigger (chre destroyed) failed with "
              "error %d(%s)", __func__, errno, strerror(errno));
        goto exit;
    }

exit:
    ALOGD("-%s-", __func__);
    return err;
}

int setup_sensor_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;
    struct iaxxx_create_config_data cdata;

    ALOGD("+%s+", __func__);

    // Download sensor packages
    err = iaxxx_odsp_package_load(odsp_hdl, SENSOR_PACKAGE, SENSOR_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load Sensor package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    /* Create plugins */
    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = BUFFER_CONFIG_OSLO_VAL;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                                OSLO_BUF_INSTANCE_ID,
                                                IAXXX_HMD_BLOCK_ID,
                                                cdata);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor buffer configuration failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Buffer plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, OSLO_BUF_INSTANCE_ID,
                                   OSLO_BUF_PRIORITY, BUF_PKG_ID,
                                   BUF_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                   PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Sensor Buffer %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = SENSOR_CONFIG_VAL;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                                SENSOR_INSTANCE_ID,
                                                IAXXX_HMD_BLOCK_ID,
                                                cdata);
    if (err == -1) {
        ALOGE("%s: ERROR: Sensor configuration %d(%s)",
            __func__, errno, strerror(errno));
        return err;
    }

    // Create Dummy sensor plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, SENSOR_INSTANCE_ID,
                                   SENSOR_PRIORITY, SENSOR_PKG_ID,
                                   SENSOR_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                   PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Sensor plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = sensor_event_init_params(odsp_hdl);
    if (err) {
        ALOGE("%s: ERROR: Sensor event init failed %d", __func__, err);
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_sensor_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = sensor_event_deinit_params(odsp_hdl);
    if (err != 0) {
        ALOGE("%s: ERROR: Sensor event uninit failed %d", __func__, err);
        goto exit;
    }

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, SENSOR_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy sensor plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, OSLO_BUF_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy sensor buffer plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_package_unload(odsp_hdl, SENSOR_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload sensor package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int trigger_sensor_destroy_event(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_evt_trigger(odsp_hdl, OSLO_EVT_SRC_ID, OSLO_DESTROYED, 0);
    if (err == -1)
        ALOGE("%s: ERROR: oslo event trigger (oslo destroyed) failed with "
              "error %d(%s)", __func__, errno, strerror(errno));

    ALOGD("-%s-", __func__);
    return err;
}

int setup_mixer_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    // Load package for Mixer
    err = iaxxx_odsp_package_load(odsp_hdl, MIXER_PACKAGE, MIXER_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load Mixer package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Mixer Plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, MIXER_INSTANCE_ID,
                                MIXER_PRIORITY, MIXER_PKG_ID,
                                MIXER_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Mixer plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;

}

int destroy_mixer_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    // Destroy Mixer Plugin
    err = iaxxx_odsp_plugin_destroy(odsp_hdl, MIXER_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy Mixer buffer plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Unload package for Mixer
    err = iaxxx_odsp_package_unload(odsp_hdl, MIXER_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload sensor package error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_src_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_package_load(odsp_hdl, SRC_PACKAGE, SRC_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to load SRC package %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;

}

int destroy_src_package(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_package_unload(odsp_hdl, SRC_PKG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to unload SRC package error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_music_buffer(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;
    struct iaxxx_create_config_data cdata;

    ALOGD("+%s+", __func__);

    // Create the 8 seconds Buffer plugin for Downlink Audio
    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = BUFFER_CONFIG_VAL_MULTI_SEC;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                DA_BUF_INSTANCE_ID,
                                IAXXX_HMD_BLOCK_ID,
                                cdata);
    if (err != 0) {
        ALOGE("%s: ERROR: DA buffer configuration failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Buffer plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl,
                              DA_BUF_INSTANCE_ID,
                              BUF_PRIORITY, BUF_PKG_ID,
                              BUF_PLUGIN_IDX,
                              IAXXX_HMD_BLOCK_ID,
                              PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create DA Buffer error %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }
    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_music_buffer(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);
    err = iaxxx_odsp_plugin_destroy(odsp_hdl,
                                DA_BUF_INSTANCE_ID,
                                IAXXX_HMD_BLOCK_ID);
    if (err == -1) {
        ALOGE("%s: ERROR: Failed to destroy DA buffer plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_howord_buffer(struct iaxxx_odsp_hw *odsp_hdl)
{
    struct iaxxx_create_config_data cdata;
    int err = 0;

    ALOGD("+%s+", __func__);

    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = BUFFER_CONFIG_VAL_2_SEC;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                                BUF_INSTANCE_ID,
                                                IAXXX_HMD_BLOCK_ID,
                                                cdata);
    if (err != 0) {
        ALOGE("%s: ERROR: 8 sec buffer configuration failed %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    // Create Buffer plugin
    err = iaxxx_odsp_plugin_create(odsp_hdl, BUF_INSTANCE_ID,
                                   BUF_PRIORITY, BUF_PKG_ID, BUF_PLUGIN_IDX,
                                   IAXXX_HMD_BLOCK_ID, PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create Buffer Plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_howord_buffer(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);

    // Destroy Buffer plugin
    err = iaxxx_odsp_plugin_destroy(odsp_hdl, BUF_INSTANCE_ID,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy 8 sec buffer %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int setup_src_plugin(struct iaxxx_odsp_hw *odsp_hdl, enum src_type st)
{
    int err = 0;
    int plugin_instant_id = 0;
    struct iaxxx_create_config_data cdata;

    if (st == SRC_MIC) {
        plugin_instant_id = SRC_MIC_INSTANCE_ID;
    } else if (st == SRC_AMP_REF) {
        plugin_instant_id = SRC_AMP_INSTANCE_ID;
    } else {
        ALOGE("%s: Invalid src type %d", __func__, st);
        err = -EINVAL;
        goto exit;
    }

    ALOGD("+%s+ src type %d", __func__, st);

    // set src config
    cdata.type = CONFIG_FILE;
    cdata.data.fdata.filename = SRC_CONFIG;
    err = iaxxx_odsp_plugin_set_creation_config(odsp_hdl,
                                plugin_instant_id,
                                IAXXX_HMD_BLOCK_ID,
                                cdata);
    if (err != 0) {
        ALOGE("%s: ERROR: SRC-%d configuration failed %d(%s)",
            __func__, st, errno, strerror(errno));
        goto exit;
    }

    err = iaxxx_odsp_plugin_create(odsp_hdl, plugin_instant_id,
                                SRC_PRIORITY, SRC_PKG_ID,
                                SRC_PLUGIN_IDX, IAXXX_HMD_BLOCK_ID,
                                PLUGIN_DEF_CONFIG_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to create SRC-%d plugin %d(%s)",
            __func__, st, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int destroy_src_plugin(struct iaxxx_odsp_hw *odsp_hdl, enum src_type st)
{
    int err = 0;
    int plugin_instant_id = 0;

    if (st == SRC_MIC) {
        plugin_instant_id = SRC_MIC_INSTANCE_ID;
    } else if (st == SRC_AMP_REF) {
        plugin_instant_id = SRC_AMP_INSTANCE_ID;
    } else {
        ALOGE("%s: Invalid src type %d", __func__, st);
        err = -EINVAL;
        goto exit;
    }
    ALOGD("+%s+ src type %d", __func__, st);

    err = iaxxx_odsp_plugin_destroy(odsp_hdl, plugin_instant_id,
                                    IAXXX_HMD_BLOCK_ID);
    if (err != 0) {
        ALOGE("%s: ERROR: Failed to destroy SRC plugin %d(%s)",
            __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGD("-%s-", __func__);

exit:
    return err;
}

int set_hotword_buffer_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGD("+%s %d+", __func__, bargein);

    if (bargein == true)
        err = audio_route_apply_and_update_path(route_hdl,
                                                route_table[ST_HOTWORD_BUFFER_WITH_BARGEIN]);
    else
        err = audio_route_apply_and_update_path(route_hdl,
                                                route_table[ST_HOTWORD_BUFFER_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int tear_hotword_buffer_route(struct audio_route *route_hdl, bool bargein)
{
    int err = 0;

    ALOGD("+%s %d+", __func__, bargein);

    if (bargein == true)
        err = audio_route_reset_and_update_path(route_hdl,
                                                route_table[ST_HOTWORD_BUFFER_WITH_BARGEIN]);
    else
        err = audio_route_reset_and_update_path(route_hdl,
                                                route_table[ST_HOTWORD_BUFFER_WITHOUT_BARGEIN]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int enable_bargein_route(struct audio_route *route_hdl, bool enable)
{
    int err = 0;

    ALOGV("+%s+ %d", __func__, enable);
    if (enable)
        err = audio_route_apply_and_update_path(route_hdl, route_table[ST_BARGEIN_ROUTE]);
    else
        err = audio_route_reset_and_update_path(route_hdl, route_table[ST_BARGEIN_ROUTE]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int enable_amp_ref_route(struct audio_route *route_hdl, bool enable,
                         enum strm_type strmt)
{
    int err = 0;

    ALOGV("+%s+ %d strm type %d", __func__, enable, strmt);
    if (strmt == STRM_16K) {
        if (enable)
            err = audio_route_apply_and_update_path(route_hdl, route_table[ST_BARGEIN_AMP_REF]);
        else
            err = audio_route_reset_and_update_path(route_hdl, route_table[ST_BARGEIN_AMP_REF]);
    } else if (strmt == STRM_48K) {
        if (enable)
            err = audio_route_apply_and_update_path(route_hdl, route_table[ST_BARGEIN_AMP_REF_48K]);
        else
            err = audio_route_reset_and_update_path(route_hdl, route_table[ST_BARGEIN_AMP_REF_48K]);
    } else {
        ALOGE("%s: ERROR: Invalid strm type", __func__);
        err = -EINVAL;
    }

    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int set_music_buffer_route(struct audio_route *route_hdl, bool downlink)
{
    int err = 0;

    ALOGD("+%s+ %d", __func__, downlink);
    if (downlink)
        err = audio_route_apply_and_update_path(route_hdl,
                                                route_table[ST_AMBIENT_BUFFER_WITHOUT_BARGEIN]);
    else
        err = audio_route_apply_and_update_path(route_hdl,
                                                route_table[ST_AMBIENT_BUFFER_WITH_BARGEIN]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int tear_music_buffer_route(struct audio_route *route_hdl, bool downlink)
{
    int err = 0;

    ALOGD("+%s+ %d", __func__, downlink);
    if (downlink)
        err = audio_route_reset_and_update_path(route_hdl,
                                                route_table[ST_AMBIENT_BUFFER_WITHOUT_BARGEIN]);
    else
        err = audio_route_reset_and_update_path(route_hdl,
                                                route_table[ST_AMBIENT_BUFFER_WITH_BARGEIN]);
    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int enable_src_route(struct audio_route *route_hdl, bool enable, enum src_type st)
{
    int err = 0;

    ALOGV("+%s+ %d src type %d", __func__, enable, st);

    if (st == SRC_MIC) {
        if (enable)
            err = audio_route_apply_and_update_path(route_hdl, route_table[ST_SRC_ROUTE_MIC]);
        else
            err = audio_route_reset_and_update_path(route_hdl, route_table[ST_SRC_ROUTE_MIC]);
    } else if (st == SRC_AMP_REF) {
        if (enable)
            err = audio_route_apply_and_update_path(route_hdl, route_table[ST_SRC_ROUTE_AMP_REF]);
        else
            err = audio_route_reset_and_update_path(route_hdl, route_table[ST_SRC_ROUTE_AMP_REF]);

    } else {
        ALOGE("%s: ERROR: Invalid src type", __func__);
        err = -EINVAL;
    }

    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int enable_mic_route(struct audio_route *route_hdl, bool enable,
                    enum clock_type ct)
{
    int err = 0;

    ALOGD("+%s+ %d clock type %d", __func__, enable, ct);

    if (ct == EXTERNAL_OSCILLATOR) {
        if (enable) {
            err = audio_route_apply_and_update_path(route_hdl,
                                                    route_table[ST_MIC_ROUTE_EXT_CLK]);
        } else {
            err = audio_route_reset_and_update_path(route_hdl,
                                                    route_table[ST_MIC_ROUTE_EXT_CLK]);
        }
    } else if (ct == INTERNAL_OSCILLATOR) {
        if (enable) {
            err = audio_route_apply_and_update_path(route_hdl,
                                                    route_table[ST_MIC_ROUTE_INT_CLK]);
        } else {
            err = audio_route_reset_and_update_path(route_hdl,
                                                    route_table[ST_MIC_ROUTE_INT_CLK]);
        }
    } else {
        ALOGE("%s: ERROR: Invalid clock type", __func__);
        err = -EINVAL;
    }

    if (err)
        ALOGE("%s: route fail %d", __func__, err);

    ALOGD("-%s-", __func__);
    return err;
}

int get_entity_param_blk(struct iaxxx_odsp_hw *odsp_hdl, void *payload,
                unsigned int payload_size)
{
    int err = 0;
    err = iaxxx_odsp_plugin_get_parameter_blk(odsp_hdl,
                                            AMBIENT_INSTANCE_ID,
                                            IAXXX_HMD_BLOCK_ID,
                                            100, payload,
                                            payload_size);

    if (err < 0) {
        ALOGE("%s: Failed to get param blk error %s\n",
            __func__, strerror(errno));
    }
    return err;
}

int get_wakeup_param_blk(struct iaxxx_odsp_hw *odsp_hdl, void *payload,
                unsigned int payload_size)
{
    int err = 0;
    err = iaxxx_odsp_plugin_get_parameter_blk(odsp_hdl,
                                            HOTWORD_INSTANCE_ID,
                                            IAXXX_HMD_BLOCK_ID,
                                            100, payload,
                                            payload_size);

    if (err < 0) {
        ALOGE("%s: Failed to get param blk error %s\n",
            __func__, strerror(errno));
    }
    return err;
}

int set_default_apll_clk(struct mixer *mixer) {

    int ret = 0;
    struct mixer_ctl* ctl;

    ALOGD("+Entering %s+", __func__);

    if (!mixer) {
        ALOGE("%s mixer is NULL", __func__);
        return -EINVAL;
    }

    ctl = mixer_get_ctl_by_name(mixer, "Port ApllCLK");
    if (ctl) {
       ret = mixer_ctl_set_enum_by_string(ctl, "IAXXX_ACLK_FREQ_24576");
       if (ret)
          ALOGE("%s: update ApllCLK fail! ret = %d", __func__, ret);
    } else {
          ALOGE("%s: get Port ApllCL control fail", __func__);
          ret = -ENODEV;
    }

    ALOGD("-Exiting %s-", __func__);
    return ret;
}

int get_fw_status(struct iaxxx_odsp_hw *odsp_hdl, unsigned int *status)
{
    int err;

    ALOGD("+%s+", __func__);

    err = iaxxx_odsp_get_fw_status(odsp_hdl,
                                   status);
    if (err == -1) {
        ALOGE("%s: ERROR: Failed to get fw status with error %d(%s)",
                __func__, errno, strerror(errno));
        goto exit;
    }

    ALOGE("Firmware status is %d", *status);

exit:
    ALOGD("-%s-", __func__);
    return err;
}

int reset_fw(struct iaxxx_odsp_hw *odsp_hdl)
{
    int err;

    ALOGD("+%s+", __func__);
    err = iaxxx_odsp_reset_fw(odsp_hdl);
    if (err == -1) {
        ALOGE("%s: ERROR: Failed to reset fw with error %d(%s)",
                __func__, errno, strerror(errno));
        goto exit;
    }

exit:
    ALOGD("-%s-", __func__);
    return err;
}

int reset_all_route(struct audio_route *route_hdl)
{
    int err = 0;

    ALOGD("+%s+", __func__);
    for (int i = ST_ROUTE_MIN; i < ST_ROUTE_MAX; i++) {
        audio_route_force_reset_and_update_path(route_hdl, route_table[i]);
    }
    ALOGD("-%s-", __func__);
    return err;
}

int setup_slpi_wakeup_event(struct iaxxx_odsp_hw *odsp_hdl, bool enabled)
{
    int err;

    ALOGD("+%s+", __func__);

    if (enabled) {
        err = iaxxx_odsp_evt_subscribe(odsp_hdl, IAXXX_SYSID_CTRL_MGR_CM4,
                                    IAXXX_HOST1_WAKEUP_EVENT_ID,
                                    IAXXX_SYSID_HOST_1, 0);
        if (err != 0) {
            ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d)"
                " IOCTL failed %d(%s)", __func__, IAXXX_HOST1_WAKEUP_EVENT_ID,
                IAXXX_SYSID_CTRL_MGR_CM4, errno, strerror(errno));
            goto exit;
        }
    } else {
        err = iaxxx_odsp_evt_unsubscribe(odsp_hdl, IAXXX_SYSID_CTRL_MGR_CM4,
                                        IAXXX_HOST1_WAKEUP_EVENT_ID,
                                        IAXXX_SYSID_HOST_1);
        if (err != 0) {
            ALOGE("%s: ERROR: ODSP_EVENT_UNSUBSCRIBE (for event_id %d, src_id %d)"
                " IOCTL failed %d(%s)", __func__, IAXXX_HOST1_WAKEUP_EVENT_ID,
                IAXXX_SYSID_CTRL_MGR_CM4, errno, strerror(errno));
            goto exit;
        }
    }
exit:
    ALOGD("-%s-", __func__);
    return err;
}