Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 20fd781c authored by Aditya Bavanari's avatar Aditya Bavanari
Browse files

hal: Update acdb extn and platform to pass Instance ID support info 

Update acdb extn and platform to pass Instance ID support info
in order to enable ACDB loader use this info and call the respective
ACDB SW APIs. Update GEF APIs to support instance ID feature.
Add a property to query the instance ID support and use that
to call ACDB loader for instance ID support.

CRs-Fixed: 2199639
Change-Id: I64b41faf23cb42ec2af1695adb8a7021cad996dc
parent fa269ad6

hal/Android.mk

+4 −0
Original line number Diff line number Diff line
@@ -405,6 +405,10 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FFV)), true) 
    LOCAL_SRC_FILES += audio_extn/ffv.c

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_INSTANCE_ID)), true)

    LOCAL_CFLAGS += -DINSTANCE_ID_ENABLED

endif



LOCAL_CFLAGS += -Wall -Werror



LOCAL_COPY_HEADERS_TO   := mm-audio

hal/acdb.c

+46 −2
Original line number Diff line number Diff line
@@ -28,6 +28,34 @@ 
#include "acdb.h"

#include "platform_api.h"



#ifdef INSTANCE_ID_ENABLED

int check_and_set_instance_id_support(struct mixer* mixer, bool acdb_support)

{

    const char *mixer_ctl_name = "Instance ID Support";

    struct mixer_ctl* ctl;



    ALOGV("%s", __func__);



    /* Check for ACDB and property instance ID support and issue mixer control */

    ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name);

    if (!ctl) {

        ALOGE("%s: Could not get ctl for mixer cmd - %s",

                               __func__, mixer_ctl_name);

        return -EINVAL;

    }



    ALOGD("%s: Final Instance ID support:%d\n", __func__, acdb_support);

    if (mixer_ctl_set_value(ctl, 0, acdb_support) < 0) {

        ALOGE("%s: Could not set Instance ID support %d", __func__,

              acdb_support);

        return -EINVAL;

    }

    return 0;

}

#else

#define check_and_set_instance_id_support(x, y) -ENOSYS

#endif



int acdb_init(int snd_card_num)

{
@@ -83,6 +111,11 @@ int acdb_init_v2(struct mixer *mixer) 


    ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);



    my_data->acdb_init_v4 = (acdb_init_v4_t)dlsym(my_data->acdb_handle,

                                                     "acdb_loader_init_v4");

    if (my_data->acdb_init_v4 == NULL)

        ALOGE("%s: dlsym error %s for acdb_loader_init_v4", __func__, dlerror());



    my_data->acdb_init_v3 = (acdb_init_v3_t)dlsym(my_data->acdb_handle,

                                                     "acdb_loader_init_v3");

    if (my_data->acdb_init_v3 == NULL)
@@ -96,7 +129,7 @@ int acdb_init_v2(struct mixer *mixer) 
    my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle,

                                                 "acdb_loader_init_ACDB");

    if (my_data->acdb_init == NULL && my_data->acdb_init_v2 == NULL

                                                 && my_data->acdb_init_v3 == NULL) {

        && my_data->acdb_init_v3 == NULL && my_data->acdb_init_v4 == NULL) {

        ALOGE("%s: dlsym error %s for acdb_loader_init_ACDB", __func__, dlerror());

        goto cleanup;

    }
@@ -140,8 +173,16 @@ int acdb_init_v2(struct mixer *mixer) 
    int key = 0;

    struct listnode *node = NULL;

    struct meta_key_list *key_info = NULL;

    static bool acdb_instance_id_support = false;



    my_data->acdb_init_data.cvd_version = cvd_version;

    my_data->acdb_init_data.snd_card_name = strdup(snd_card_name);

    my_data->acdb_init_data.meta_key_list = &my_data->acdb_meta_key_list;

    my_data->acdb_init_data.is_instance_id_supported = &acdb_instance_id_support;



    if (my_data->acdb_init_v3) {

    if (my_data->acdb_init_v4) {

        result = my_data->acdb_init_v4(&my_data->acdb_init_data, ACDB_LOADER_INIT_V4);

    } else if (my_data->acdb_init_v3) {

        result = my_data->acdb_init_v3(snd_card_name, cvd_version,

                                       &my_data->acdb_meta_key_list);

    } else if (my_data->acdb_init_v2) {
@@ -152,6 +193,9 @@ int acdb_init_v2(struct mixer *mixer) 
    } else {

        result = my_data->acdb_init();

    }

    ALOGD("%s: ACDB Instance ID support after ACDB init:%d\n",

          __func__, acdb_instance_id_support);

    check_and_set_instance_id_support(mixer, acdb_instance_id_support);



cleanup:

    if (NULL != my_data) {

hal/acdb.h

+18 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#ifndef ACDB_H

#define ACDB_H



#include <stdbool.h>

#include <linux/msm_audio_calibration.h>



#define MAX_CVD_VERSION_STRING_SIZE 100
@@ -34,11 +35,19 @@ 
#endif



struct mixer;

enum {

        ACDB_LOADER_INIT_V1 = 1,

        ACDB_LOADER_INIT_V2,

        ACDB_LOADER_INIT_V3,

        ACDB_LOADER_INIT_V4,

};



/* Audio calibration related functions */

typedef void (*acdb_deallocate_t)();

typedef int  (*acdb_init_t)();

typedef int  (*acdb_init_v2_t)(const char *, char *, int);

typedef int  (*acdb_init_v3_t)(const char *, char *, struct listnode *);

typedef int  (*acdb_init_v4_t)(void *, int);

typedef void (*acdb_send_audio_cal_t)(int, int, int , int);

typedef void (*acdb_send_audio_cal_v3_t)(int, int, int, int, int);

typedef void (*acdb_send_voice_cal_t)(int, int);
@@ -59,13 +68,22 @@ struct meta_key_list { 
    char name[ACDB_METAINFO_KEY_MODULE_NAME_LEN];

};



struct acdb_init_data_v4 {

        char                   *cvd_version;

        char                   *snd_card_name;

        struct listnode        *meta_key_list;

        bool                   *is_instance_id_supported;

};



struct acdb_platform_data {

    /* Audio calibration related functions */

    void                       *acdb_handle;

    acdb_init_t                acdb_init;

    acdb_init_v2_t             acdb_init_v2;

    acdb_init_v3_t             acdb_init_v3;

    acdb_init_v4_t             acdb_init_v4;

    struct listnode acdb_meta_key_list;

    struct acdb_init_data_v4   acdb_init_data;

};



int acdb_init(int);

hal/audio_extn/audio_extn.h

+39 −8
Original line number Diff line number Diff line
@@ -798,6 +798,8 @@ int audio_extn_keep_alive_set_parameters(struct audio_device *adev, 
#define audio_extn_gef_init(adev) (0)

#define audio_extn_gef_deinit() (0)

#define audio_extn_gef_notify_device_config(devices, cmask, sample_rate, acdb_id) (0)



#ifndef INSTANCE_ID_ENABLED

#define audio_extn_gef_send_audio_cal(dev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, param_id, data, length, persist) (0)

#define audio_extn_gef_get_audio_cal(adev, acdb_dev_id, acdb_device_type,\
@@ -806,6 +808,20 @@ int audio_extn_keep_alive_set_parameters(struct audio_device *adev, 
    app_type, topology_id, sample_rate, module_id, param_id, data, length) (0)

#define audio_extn_gef_retrieve_audio_cal(adev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, param_id, data, length) (0)

#else

#define audio_extn_gef_send_audio_cal(dev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, instance_id, param_id, data,\

    length, persist) (0)

#define audio_extn_gef_get_audio_cal(adev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, instance_id, param_id, data,\

    length, persist) (0)

#define audio_extn_gef_store_audio_cal(adev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, instance_id, param_id, data,\

    length) (0)

#define audio_extn_gef_retrieve_audio_cal(adev, acdb_dev_id, acdb_device_type,\

    app_type, topology_id, sample_rate, module_id, instance_id, param_id, data,\

    length) (0)

#endif



#else
@@ -814,18 +830,33 @@ void audio_extn_gef_deinit(); 


void audio_extn_gef_notify_device_config(audio_devices_t audio_device,

    audio_channel_mask_t channel_mask, int sample_rate, int acdb_id);

#ifndef INSTANCE_ID_ENABLED

int audio_extn_gef_send_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id, uint32_t param_id,

    void* data, int length, bool persist);

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint32_t param_id, void* data, int length, bool persist);

int audio_extn_gef_get_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id, uint32_t param_id,

    void* data, int* length, bool persist);

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint32_t param_id, void* data, int* length, bool persist);

int audio_extn_gef_store_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id, uint32_t param_id,

    void* data, int length);

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint32_t param_id, void* data, int length);

int audio_extn_gef_retrieve_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id, uint32_t param_id,

    void* data, int* length);

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint32_t param_id, void* data, int* length);

#else

int audio_extn_gef_send_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint16_t instance_id, uint32_t param_id, void* data, int length, bool persist);

int audio_extn_gef_get_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint16_t instance_id, uint32_t param_id, void* data, int* length, bool persist);

int audio_extn_gef_store_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint16_t instance_id, uint32_t param_id, void* data, int length);

int audio_extn_gef_retrieve_audio_cal(void* adev, int acdb_dev_id, int acdb_device_type,

    int app_type, int topology_id, int sample_rate, uint32_t module_id,

    uint16_t instance_id, uint32_t param_id, void* data, int* length);

#endif



#endif /* AUDIO_GENERIC_EFFECT_FRAMEWORK_ENABLED */

hal/audio_extn/gef.c

+162 −12
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.

 * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are
@@ -170,25 +170,31 @@ ERROR_RETURN: 
}





#ifdef INSTANCE_ID_ENABLED

//this will be called from GEF to exchange calibration using acdb

int audio_extn_gef_send_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint32_t param_id, void* data, int length, bool persist)

    uint32_t module_id, uint16_t instance_id, uint32_t param_id,

    void* data, int length, bool persist)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    //send cal

    ret = platform_send_audio_cal(adev->platform, acdb_dev_id,

    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, data, length, persist);

        module_id, instance_id, param_id, true);



    ret = platform_send_audio_cal(adev->platform, &cal, data, length, persist);



    pthread_mutex_unlock(&adev->lock);
@@ -200,21 +206,154 @@ int audio_extn_gef_send_audio_cal(void* dev, int acdb_dev_id, 
//this will be called from GEF to exchange calibration using acdb

int audio_extn_gef_get_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint32_t param_id, void* data, int* length, bool persist)

    uint32_t module_id, uint16_t instance_id, uint32_t param_id,

    void* data, int* length, bool persist)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    ret = platform_get_audio_cal(adev->platform, acdb_dev_id,

    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, data, length, persist);

        module_id, instance_id, param_id, false);



    ret = platform_get_audio_cal(adev->platform, &cal, data, length, persist);



    pthread_mutex_unlock(&adev->lock);



    ALOGV("%s: Exit with error %d", __func__, ret);



    return ret;

}



//this will be called from GEF to store into acdb

int audio_extn_gef_store_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint16_t instance_id,

    uint32_t param_id, void* data, int length)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, instance_id, param_id, true);



    ret = platform_store_audio_cal(adev->platform, &cal, data, length);



    pthread_mutex_unlock(&adev->lock);



    ALOGV("%s: Exit with error %d", __func__, ret);



    return ret;

}



//this will be called from GEF to retrieve calibration using acdb

int audio_extn_gef_retrieve_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint16_t instance_id, uint32_t param_id, void* data, int* length)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, instance_id, param_id, true);



    ret = platform_retrieve_audio_cal(adev->platform, &cal, data, length);



    pthread_mutex_unlock(&adev->lock);



    ALOGV("%s: Exit with error %d", __func__, ret);



    return ret;

}

#else

//this will be called from GEF to exchange calibration using acdb

int audio_extn_gef_send_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint32_t param_id, void* data, int length,

    bool persist)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, true);



    ret = platform_send_audio_cal(adev->platform, &cal, data, length, persist);



    pthread_mutex_unlock(&adev->lock);



    ALOGV("%s: Exit with error %d", __func__, ret);



    return ret;

}



//this will be called from GEF to exchange calibration using acdb

int audio_extn_gef_get_audio_cal(void* dev, int acdb_dev_id,

    int gef_cal_type, int app_type, int topology_id, int sample_rate,

    uint32_t module_id, uint32_t param_id, void* data, int* length,

    bool persist)

{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, false);



    ret = platform_get_audio_cal(adev->platform, &cal, data, length, persist);



    pthread_mutex_unlock(&adev->lock);
@@ -230,17 +369,22 @@ int audio_extn_gef_store_audio_cal(void* dev, int acdb_dev_id, 
{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    ret = platform_store_audio_cal(adev->platform, acdb_dev_id,

    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, data, length);

        module_id, param_id, true);



    ret = platform_store_audio_cal(adev->platform, &cal, data, length);



    pthread_mutex_unlock(&adev->lock);
@@ -256,17 +400,22 @@ int audio_extn_gef_retrieve_audio_cal(void* dev, int acdb_dev_id, 
{

    int ret = 0;

    struct audio_device *adev = (struct audio_device*)dev;

    acdb_audio_cal_cfg_t cal;

    int acdb_device_type =

        make_acdb_device_type_from_gef_cal_type(gef_cal_type);



    ALOGV("%s: Enter", __func__);

    memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));



    //lock adev

    pthread_mutex_lock(&adev->lock);



    ret = platform_retrieve_audio_cal(adev->platform, acdb_dev_id,

    //pack cal

    platform_make_cal_cfg(&cal, acdb_dev_id,

        acdb_device_type, app_type, topology_id, sample_rate,

        module_id, param_id, data, length);

        module_id, param_id, true);



    ret = platform_retrieve_audio_cal(adev->platform, &cal, data, length);



    pthread_mutex_unlock(&adev->lock);
@@ -274,6 +423,7 @@ int audio_extn_gef_retrieve_audio_cal(void* dev, int acdb_dev_id, 


    return ret;

}

#endif



//this will be called from HAL to notify GEF of new device configuration

void audio_extn_gef_notify_device_config(audio_devices_t audio_device,