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

Commit 659affa2 authored by Pradnya Chaphekar's avatar Pradnya Chaphekar Committed by Gerrit - the friendly Code Review server
Browse files

hal: Add changes for dolby DS2 

-Add device to back end mapping for APQ8084 and MSM8994.
-Set initialization info like sound card number, dmid
 to ds2 dap hal.
-Add mixer control DS2 OnOff to enable or disable DS2
-A property "audio.dolby.ds2.enabled" is added to trigger
 the mixer control.
-Reuse ds1 functions for checking dolby format and getting
 sound codec id.

CRs-Fixed: 661095 661018

Conflicts:
	hal/audio_hw.c
        hal/msm8916/platform.c

Change-Id: Iff5fdc49249eb035c2ccde18e190ccc6c3ff632a
parent 858d316f

hal/Android.mk

+9 −0
Original line number Diff line number Diff line
@@ -150,6 +150,15 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RECORD_PLAY_CONCURRENCY)),true) 
    LOCAL_CFLAGS += -DRECORD_PLAY_CONCURRENCY

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_DS2_DOLBY_DAP)),true)

    LOCAL_CFLAGS += -DDS2_DOLBY_DAP_ENABLED

ifneq ($(strip $(DOLBY_DDP)),true)

    ifneq ($(strip $(DOLBY_DAP)),true)

        LOCAL_SRC_FILES += audio_extn/dolby.c

    endif

endif

endif



LOCAL_SHARED_LIBRARIES := \

	liblog \

	libcutils \

hal/audio_extn/audio_extn.h

+47 −8
Original line number Diff line number Diff line
@@ -259,22 +259,27 @@ void audio_extn_dolby_set_license(struct audio_device *adev); 
#define audio_extn_dolby_set_license(adev)              (0)

#endif



#ifndef DS1_DOLBY_DDP_ENABLED

#ifndef DS1_DOLBY_DAP_ENABLED

#define audio_extn_dolby_set_endpoint(adev)                 (0)

#else

void audio_extn_dolby_set_endpoint(struct audio_device *adev);

#endif



#ifndef DS1_DOLBY_DDP_ENABLED

#define audio_extn_ddp_set_parameters(adev, parms)      (0)

#define audio_extn_is_dolby_format(format)              (0)

#define audio_extn_dolby_get_snd_codec_id(adev, out, format)       (0)

#define audio_extn_dolby_send_ddp_endp_params(adev)     (0)

#else



#if defined(DS1_DOLBY_DDP_ENABLED) || defined(DS2_DOLBY_DAP_ENABLED)

bool audio_extn_is_dolby_format(audio_format_t format);

int audio_extn_dolby_get_snd_codec_id(struct audio_device *adev,

                                      struct stream_out *out,

                                      audio_format_t format);

#else

#define audio_extn_is_dolby_format(format)              (0)

#define audio_extn_dolby_get_snd_codec_id(adev, out, format)       (0)

#endif



#ifndef DS1_DOLBY_DDP_ENABLED

#define audio_extn_ddp_set_parameters(adev, parms)      (0)

#define audio_extn_dolby_send_ddp_endp_params(adev)     (0)

#else

void audio_extn_ddp_set_parameters(struct audio_device *adev,

                                   struct str_parms *parms);

void audio_extn_dolby_send_ddp_endp_params(struct audio_device *adev);
@@ -318,5 +323,39 @@ void audio_extn_utils_update_stream_app_type_cfg(void *platform, 
int audio_extn_utils_send_app_type_cfg(struct audio_usecase *usecase);

void audio_extn_utils_send_audio_calibration(struct audio_device *adev,

                                             struct audio_usecase *usecase);



#ifdef DS2_DOLBY_DAP_ENABLED

#define LIB_DS2_DAP_HAL "vendor/lib/libhwdaphal.so"

#define SET_HW_INFO_FUNC "dap_hal_set_hw_info"

typedef enum {

    SND_CARD            = 0,

    HW_ENDPOINT         = 1,

    DMID                = 2,

    DEVICE_BE_ID_MAP    = 3,

    DAP_BYPASS          = 4,

} dap_hal_hw_info_t;

typedef int (*dap_hal_set_hw_info_t)(int32_t hw_info, void* data);

typedef struct {

     int (*device_id_to_be_id)[2];

     int len;

} dap_hal_device_be_id_map_t;



int audio_extn_dap_hal_init(int snd_card);

int audio_extn_dap_hal_deinit();

void audio_extn_dolby_ds2_set_endpoint(struct audio_device *adev);

int audio_extn_ds2_enable(struct audio_device *adev);

int audio_extn_dolby_set_dap_bypass(struct audio_device *adev, int state);

#else

#define audio_extn_dap_hal_init(snd_card)                             (0)

#define audio_extn_dap_hal_deinit()                                   (0)

#define audio_extn_dolby_ds2_set_endpoint(adev)                       (0)

#define audio_extn_ds2_enable(adev)                                   (0)

#define audio_extn_dolby_set_dap_bypass(adev, state)                  (0)

#endif

typedef enum {

    DAP_STATE_ON = 0,

    DAP_STATE_BYPASS,

};

#ifndef AUDIO_FORMAT_E_AC3_JOC

#define AUDIO_FORMAT_E_AC3_JOC  0x19000000UL

#endif

#endif /* AUDIO_EXTN_H */

hal/audio_extn/dolby.c

+146 −9
Original line number Diff line number Diff line
@@ -243,7 +243,8 @@ void send_ddp_endp_params(struct audio_device *adev, 
            (usecase->devices & ddp_dev) &&

            (usecase->stream.out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&

            ((usecase->stream.out->format == AUDIO_FORMAT_AC3) ||

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3))) {

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3) ||

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC))) {

            send_ddp_endp_params_stream(usecase->stream.out, ddp_dev,

                                        dev_ch_cap, false /* set cache */);

        }
@@ -260,7 +261,8 @@ void audio_extn_dolby_send_ddp_endp_params(struct audio_device *adev) 
            (usecase->devices & AUDIO_DEVICE_OUT_ALL) &&

            (usecase->stream.out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&

            ((usecase->stream.out->format == AUDIO_FORMAT_AC3) ||

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3))) {

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3) ||

             (usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC))) {

            /*

             * Use wfd /hdmi sink channel cap for dolby params if device is wfd

             * or hdmi. Otherwise use stereo configuration
@@ -352,7 +354,9 @@ void audio_extn_ddp_set_parameters(struct audio_device *adev, 
     */

    send_ddp_endp_params(adev, ddp_dev, dev_ch_cap);

}

#endif /* DS1_DOLBY_DDP_ENABLED */



#if defined(DS1_DOLBY_DDP_ENABLED) || defined(DS2_DOLBY_DAP_ENABLED)

int audio_extn_dolby_get_snd_codec_id(struct audio_device *adev,

                                      struct stream_out *out,

                                      audio_format_t format)
@@ -370,19 +374,20 @@ int audio_extn_dolby_get_snd_codec_id(struct audio_device *adev, 
    switch (format) {

    case AUDIO_FORMAT_AC3:

        id = SND_AUDIOCODEC_AC3;

#ifdef DS1_DOLBY_DDP_ENABLED

        send_ddp_endp_params_stream(out, out->devices,

                            channel_cap, true /* set_cache */);

#ifndef DS1_DOLBY_DAP_ENABLED

        audio_extn_dolby_set_dmid(adev);

#endif

        audio_extn_dolby_set_dmid(adev);

        break;

    case AUDIO_FORMAT_E_AC3:

    case AUDIO_FORMAT_E_AC3_JOC:

        id = SND_AUDIOCODEC_EAC3;

#ifdef DS1_DOLBY_DDP_ENABLED

        send_ddp_endp_params_stream(out, out->devices,

                            channel_cap, true /* set_cache */);

#ifndef DS1_DOLBY_DAP_ENABLED

        audio_extn_dolby_set_dmid(adev);

#endif

        audio_extn_dolby_set_dmid(adev);

        break;

    default:

        ALOGE("%s: Unsupported audio format :%x", __func__, format);
@@ -394,13 +399,13 @@ int audio_extn_dolby_get_snd_codec_id(struct audio_device *adev, 
bool audio_extn_is_dolby_format(audio_format_t format)

{

    if (format == AUDIO_FORMAT_AC3 ||

            format == AUDIO_FORMAT_E_AC3)

            format == AUDIO_FORMAT_E_AC3 ||

            format == AUDIO_FORMAT_E_AC3_JOC)

        return true;

    else

        return false;

}



#endif /* DS1_DOLBY_DDP_ENABLED */

#endif /* DS1_DOLBY_DDP_ENABLED || DS2_DOLBY_DAP_ENABLED */



#ifdef DS1_DOLBY_DAP_ENABLED

void audio_extn_dolby_set_endpoint(struct audio_device *adev)
@@ -499,3 +504,135 @@ void audio_extn_dolby_set_license(struct audio_device *adev) 
    return;

}

#endif /* DS1_DOLBY_DDP_ENABLED || DS1_DOLBY_DAP_ENABLED */



#ifdef DS2_DOLBY_DAP_ENABLED

struct ds2_extn_module  {

   void *ds2_handle;

   dap_hal_set_hw_info_t dap_hal_set_hw_info;

};



static struct ds2_extn_module ds2extnmod = {

    .ds2_handle = NULL,

    .dap_hal_set_hw_info = NULL,

};



int audio_extn_dap_hal_init(int snd_card) {

    char c_dmid[128] = {0};

    void *handle = NULL;

    int i_dmid, ret = -EINVAL;

    dap_hal_device_be_id_map_t device_be_id_map;



    ALOGV("%s: opening DAP HAL lib\n", __func__);

    ds2extnmod.ds2_handle = dlopen(LIB_DS2_DAP_HAL, RTLD_NOW);

    if (ds2extnmod.ds2_handle == NULL) {

        ALOGE("%s: DLOPEN failed for %s error %s", __func__, LIB_DS2_DAP_HAL,

              dlerror());

        goto ret;

    }

    ds2extnmod.dap_hal_set_hw_info = (dap_hal_set_hw_info_t)dlsym(ds2extnmod.ds2_handle, SET_HW_INFO_FUNC);

    if (ds2extnmod.dap_hal_set_hw_info == NULL) {

           ALOGE("%s: dlsym error %s for %s", __func__, SET_HW_INFO_FUNC,

                 dlerror());

           goto close;

    }

    ds2extnmod.dap_hal_set_hw_info(SND_CARD, (void*)(&snd_card));

    ALOGV("%s Sound card number is:%d",__func__,snd_card);



    property_get("dmid",c_dmid,"0");

    i_dmid = atoi(c_dmid);

    ds2extnmod.dap_hal_set_hw_info(DMID, (void*)(&i_dmid));

    ALOGV("%s Dolby device manufacturer id is:%d",__func__,i_dmid);



    platform_get_device_to_be_id_map(&device_be_id_map.device_id_to_be_id, &device_be_id_map.len);

    ds2extnmod.dap_hal_set_hw_info(DEVICE_BE_ID_MAP, (void*)(&device_be_id_map));

    ALOGV("%s Set be id map len:%d",__func__,device_be_id_map.len);

    ret = 0;

    goto ret;



close:

    dlclose(ds2extnmod.ds2_handle);

    ds2extnmod.ds2_handle = NULL;

    ds2extnmod.dap_hal_set_hw_info = NULL;

ret:

    return ret;

}



int audio_extn_dap_hal_deinit() {

    if (ds2extnmod.ds2_handle != NULL) {

       dlclose(ds2extnmod.ds2_handle);

       ds2extnmod.ds2_handle = NULL;

    }

    ds2extnmod.dap_hal_set_hw_info = NULL;

    return 0;

}



void audio_extn_dolby_ds2_set_endpoint(struct audio_device *adev) {

    struct listnode *node;

    struct audio_usecase *usecase;

    struct mixer_ctl *ctl;

    const char *mixer_ctl_name = "DS1 DAP Endpoint";

    int endpoint = 0, ret;

    bool send = false;



    list_for_each(node, &adev->usecase_list) {

        usecase = node_to_item(node, struct audio_usecase, list);

        if ((usecase->type == PCM_PLAYBACK) &&

            (usecase->id != USECASE_AUDIO_PLAYBACK_LOW_LATENCY)) {

            endpoint |= usecase->devices & AUDIO_DEVICE_OUT_ALL;

            send = true;

        }

    }

    if (!send)

        return;



    if (ds2extnmod.dap_hal_set_hw_info) {

        ds2extnmod.dap_hal_set_hw_info(HW_ENDPOINT, (void*)(&endpoint));

        ALOGE("%s: Dolby set endpint :0x%x",__func__, endpoint);

    } else {

        ALOGE("%s: dap_hal_set_hw_info is NULL",__func__);

    }



    return;

}



int audio_extn_ds2_enable(struct audio_device *adev) {



    char value[PROPERTY_VALUE_MAX] = {0};

    bool ds2_enabled = false;

    const char *mixer_ctl_name = "DS2 OnOff";

    struct mixer_ctl *ctl;



    property_get("audio.dolby.ds2.enabled", value, NULL);

    ds2_enabled = atoi(value) || !strncmp("true", value, 4);



    ALOGV("%s:", __func__);

    if(ds2_enabled) {

        ALOGD("%s:ds2_enabled %d", __func__, ds2_enabled);

        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);

        if (!ctl) {

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

                                   __func__, mixer_ctl_name);

            return -EINVAL;

        }



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

            ALOGE("%s: Could not set ds2 enable %d",

                            __func__, ds2_enabled);

            return -EINVAL;

        }

    }

    return 0;

}



int audio_extn_dolby_set_dap_bypass(struct audio_device *adev, int state) {



    ALOGV("%s: state %d", __func__, state);

    if (ds2extnmod.dap_hal_set_hw_info) {

        ds2extnmod.dap_hal_set_hw_info(DAP_BYPASS, (void*)(&state));

        ALOGV("%s: Dolby set bypas :0x%x", __func__, state);

    } else {

        ALOGV("%s: dap_hal_set_hw_info is NULL", __func__);

    }

    return 0;

}

#endif

hal/audio_hw.c

+8 −0
Original line number Diff line number Diff line
@@ -210,6 +210,12 @@ static const struct string_to_enum out_channels_name_to_enum_table[] = { 
    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),

};



static const struct string_to_enum out_formats_name_to_enum_table[] = {

    STRING_TO_ENUM(AUDIO_FORMAT_AC3),

    STRING_TO_ENUM(AUDIO_FORMAT_E_AC3),

    STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),

};



static struct audio_device *adev = NULL;

static pthread_mutex_t adev_init_lock;

static unsigned int audio_device_ref_count;
@@ -360,6 +366,7 @@ int enable_audio_route(struct audio_device *adev, 
    audio_extn_dolby_set_dmid(adev);

    audio_extn_dolby_set_endpoint(adev);

#endif

    audio_extn_dolby_ds2_set_endpoint(adev);

    audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);

    audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_BUSY);

    audio_extn_utils_send_audio_calibration(adev, usecase);
@@ -3401,6 +3408,7 @@ static int adev_open(const hw_module_t *module, const char *name, 


    adev->bt_wb_speech_enabled = false;



    audio_extn_ds2_enable(adev);

    *device = &adev->device.common;



    audio_extn_utils_update_streams_output_cfg_list(adev->platform, adev->mixer,

hal/msm8916/platform.c

+124 −0
Original line number Diff line number Diff line
@@ -458,6 +458,64 @@ struct snd_device_index snd_device_name_index[SND_DEVICE_MAX] = { 
    {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)},

};



#define NO_COLS 2

static int msm_be_id_array_len;

static int (*msm_device_to_be_id)[];



/* Below table lists output device to BE_ID mapping*/

/* Update the table based on the board configuration*/



static int msm_device_to_be_id_internal_codec [][NO_COLS] = {

       {AUDIO_DEVICE_OUT_EARPIECE                       ,       34},

       {AUDIO_DEVICE_OUT_SPEAKER                        ,       34},

       {AUDIO_DEVICE_OUT_WIRED_HEADSET                  ,       34},

       {AUDIO_DEVICE_OUT_WIRED_HEADPHONE                ,       34},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO                  ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET          ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT           ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP                 ,       -1},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES      ,       -1},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER         ,       -1},

       {AUDIO_DEVICE_OUT_AUX_DIGITAL                    ,       4},

       {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET              ,       9},

       {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET              ,       9},

       {AUDIO_DEVICE_OUT_USB_ACCESSORY                  ,       -1},

       {AUDIO_DEVICE_OUT_USB_DEVICE                     ,       -1},

       {AUDIO_DEVICE_OUT_REMOTE_SUBMIX                  ,       9},

       {AUDIO_DEVICE_OUT_PROXY                          ,       9},

       {AUDIO_DEVICE_OUT_FM                             ,       7},

       {AUDIO_DEVICE_OUT_FM_TX                          ,       8},

       {AUDIO_DEVICE_OUT_ALL                            ,      -1},

       {AUDIO_DEVICE_NONE                               ,      -1},

       {AUDIO_DEVICE_OUT_DEFAULT                        ,      -1},

};



static int msm_device_to_be_id_external_codec [][NO_COLS] = {

       {AUDIO_DEVICE_OUT_EARPIECE                       ,       2},

       {AUDIO_DEVICE_OUT_SPEAKER                        ,       2},

       {AUDIO_DEVICE_OUT_WIRED_HEADSET                  ,       2},

       {AUDIO_DEVICE_OUT_WIRED_HEADPHONE                ,       2},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO                  ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET          ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT           ,       11},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP                 ,       -1},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES      ,       -1},

       {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER         ,       -1},

       {AUDIO_DEVICE_OUT_AUX_DIGITAL                    ,       4},

       {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET              ,       9},

       {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET              ,       9},

       {AUDIO_DEVICE_OUT_USB_ACCESSORY                  ,       -1},

       {AUDIO_DEVICE_OUT_USB_DEVICE                     ,       -1},

       {AUDIO_DEVICE_OUT_REMOTE_SUBMIX                  ,       9},

       {AUDIO_DEVICE_OUT_PROXY                          ,       9},

       {AUDIO_DEVICE_OUT_FM                             ,       7},

       {AUDIO_DEVICE_OUT_FM_TX                          ,       8},

       {AUDIO_DEVICE_OUT_ALL                            ,      -1},

       {AUDIO_DEVICE_NONE                               ,      -1},

       {AUDIO_DEVICE_OUT_DEFAULT                        ,      -1},

};





#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)

#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
@@ -468,49 +526,105 @@ static void query_platform(const char *snd_card_name, 
                 sizeof("msm8x16-snd-card-mtp"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,

                sizeof(MIXER_XML_PATH_MTP));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8x16-skuh-snd-card",

                 sizeof("msm8x16-skuh-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUH,

                sizeof(MIXER_XML_PATH_QRD_SKUH));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8x16-skui-snd-card",

                 sizeof("msm8x16-skui-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUI,

                sizeof(MIXER_XML_PATH_QRD_SKUI));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8x16-skuhf-snd-card",

                 sizeof("msm8x16-skuhf-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUHF,

                sizeof(MIXER_XML_PATH_QRD_SKUHF));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8939-snd-card-mtp",

                 sizeof("msm8939-snd-card-mtp"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,

                sizeof(MIXER_XML_PATH_MTP));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8939-snd-card-skuk",

                 sizeof("msm8939-snd-card-skuk"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUK,

                sizeof(MIXER_XML_PATH_SKUK));

        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8939-tapan-snd-card",

                 sizeof("msm8939-tapan-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9306,

                sizeof(MIXER_XML_PATH_WCD9306));

        msm_device_to_be_id = msm_device_to_be_id_external_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_external_codec) / sizeof(msm_device_to_be_id_external_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8939-tapan9302-snd-card",

                 sizeof("msm8939-tapan9302-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9306,

                sizeof(MIXER_XML_PATH_WCD9306));



        msm_device_to_be_id = msm_device_to_be_id_external_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_external_codec) / sizeof(msm_device_to_be_id_external_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8939-tomtom9330-snd-card",

                 sizeof("msm8939-tomtom9330-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9330,

                sizeof(MIXER_XML_PATH_WCD9330));

        msm_device_to_be_id = msm_device_to_be_id_external_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_external_codec) / sizeof(msm_device_to_be_id_external_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8909-skua-snd-card",

                 sizeof("msm8909-skua-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUA,

                sizeof(MIXER_XML_PATH_SKUA));

        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_external_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else if (!strncmp(snd_card_name, "msm8909-skuc-snd-card",

                 sizeof("msm8909-skuc-snd-card"))) {

        strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUC,

                sizeof(MIXER_XML_PATH_SKUC));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_external_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    } else {

        strlcpy(mixer_xml_path, MIXER_XML_PATH,

                sizeof(MIXER_XML_PATH));



        msm_device_to_be_id = msm_device_to_be_id_internal_codec;

        msm_be_id_array_len  =

            sizeof(msm_device_to_be_id_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]);



    }

}
@@ -2459,6 +2573,16 @@ uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info) 
    return fragment_size;

}



void platform_get_device_to_be_id_map(int **device_to_be_id, int *length)

{

     *device_to_be_id = msm_device_to_be_id;

     *length = msm_be_id_array_len;

}



bool platform_check_24_bit_support() {

    return false;

}



bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev __unused,

                                              struct audio_usecase *usecase __unused)

{