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

Commit f4da6fe4 authored by Haynes Mathew George's avatar Haynes Mathew George Committed by Vicky Sehrawat
Browse files

audio: extend platform parser 

Extend platform parser with support for additional sections.
Supported sections now include acdb ids, pcm device ids and backend names.

Change-Id: Idfbc8a8bb490606686436c107db5b0c7d636ccbe
parent 7de61eb0

hal/audio_extn/spkr_protection.c

+9 −0
Original line number Diff line number Diff line
@@ -668,6 +668,15 @@ void audio_extn_spkr_prot_init(void *adev) 
        handle.thermal_handle = NULL;

        handle.spkr_prot_enable = false;

    }



    if (handle.spkr_prot_enable) {

        char platform[PROPERTY_VALUE_MAX];

        property_get("ro.board.platform", platform, "");

        if (!strncmp("apq8084", platform, sizeof("apq8084"))) {

            platform_set_snd_device_backend(SND_DEVICE_OUT_VOICE_SPEAKER,

                                            "speaker-protected");

        }

    }

}



int audio_extn_spkr_prot_get_acdb_id(snd_device_t snd_device)

hal/msm8916/platform.c

+18 −0
Original line number Diff line number Diff line
@@ -2079,3 +2079,21 @@ bool platform_check_24_bit_support() { 
bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, struct audio_usecase *usecase) {

    return false;

}



int platform_get_usecase_index(const char * usecase __unused)

{

    return -ENOSYS;

}



int platform_set_usecase_pcm_id(audio_usecase_t usecase __unused, int32_t type __unused,

                                int32_t pcm_id __unused)

{

    return -ENOSYS;

}



int platform_set_snd_device_backend(snd_device_t snd_device __unused,

                                    const char * backend __unused)

{

    return -ENOSYS;

}

hal/msm8960/platform.c

+16 −0
Original line number Diff line number Diff line
@@ -959,3 +959,19 @@ bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, struct 
    return false;

}



int platform_get_usecase_index(const char * usecase __unused)

{

    return -ENOSYS;

}



int platform_set_usecase_pcm_id(audio_usecase_t usecase __unused, int32_t type __unused,

                                int32_t pcm_id __unused)

{

    return -ENOSYS;

}



int platform_set_snd_device_backend(snd_device_t snd_device __unused,

                                    const char * backend __unused)

{

    return -ENOSYS;

}

hal/msm8974/platform.c

+134 −43
Original line number Diff line number Diff line
@@ -143,7 +143,7 @@ struct platform_data { 
    struct csd_data *csd;

};



static const int pcm_device_table[AUDIO_USECASE_MAX][2] = {

static int pcm_device_table[AUDIO_USECASE_MAX][2] = {

    [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE,

                                            DEEP_BUFFER_PCM_DEVICE},

    [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
@@ -373,7 +373,7 @@ static int acdb_device_table[SND_DEVICE_MAX] = { 
    [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120,

};



struct snd_device_index {

struct name_to_index {

    char name[100];

    unsigned int index;

};
@@ -381,7 +381,7 @@ struct snd_device_index { 
#define TO_NAME_INDEX(X)   #X, X



/* Used to get index from parsed sting */

struct snd_device_index snd_device_name_index[SND_DEVICE_MAX] = {

static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = {

    {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_EXTERNAL_1)},
@@ -461,6 +461,26 @@ struct snd_device_index snd_device_name_index[SND_DEVICE_MAX] = { 
    {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)},

};



static char * backend_table[SND_DEVICE_MAX] = {0};



static struct name_to_index usecase_name_index[AUDIO_USECASE_MAX] = {

    {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_DEEP_BUFFER)},

    {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_LOW_LATENCY)},

    {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MULTI_CH)},

    {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD)},

    {TO_NAME_INDEX(USECASE_AUDIO_RECORD)},

    {TO_NAME_INDEX(USECASE_AUDIO_RECORD_LOW_LATENCY)},

    {TO_NAME_INDEX(USECASE_VOICE_CALL)},

    {TO_NAME_INDEX(USECASE_VOICE2_CALL)},

    {TO_NAME_INDEX(USECASE_VOLTE_CALL)},

    {TO_NAME_INDEX(USECASE_QCHAT_CALL)},

    {TO_NAME_INDEX(USECASE_VOWLAN_CALL)},

    {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK)},

    {TO_NAME_INDEX(USECASE_INCALL_REC_DOWNLINK)},

    {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK_AND_DOWNLINK)},

    {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO)},

};



#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)

#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
@@ -663,6 +683,30 @@ static bool platform_is_i2s_ext_modem(const char *snd_card_name, 
    return plat_data->is_i2s_ext_modem;

}



static void set_platform_defaults(struct platform_data * my_data)

{

    int32_t dev;

    for (dev = 0; dev < SND_DEVICE_MAX; dev++) {

        backend_table[dev] = NULL;

    }



    // TBD - do these go to the platform-info.xml file.

    // will help in avoiding strdups here

    backend_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("bt-sco");

    backend_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("bt-sco-wb");

    backend_table[SND_DEVICE_OUT_BT_SCO] = strdup("bt-sco");

    backend_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("bt-sco-wb");

    backend_table[SND_DEVICE_OUT_HDMI] = strdup("hdmi");

    backend_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("speaker-and-hdmi");

    backend_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("afe-proxy");

    backend_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("usb-headphones");

    backend_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] =

        strdup("speaker-and-usb-headphones");

    backend_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");

    backend_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("capture-fm");

    backend_table[SND_DEVICE_OUT_TRANSMISSION_FM] = strdup("transmission-fm");

}



void *platform_init(struct audio_device *adev)

{

    char value[PROPERTY_VALUE_MAX];
@@ -823,6 +867,8 @@ void *platform_init(struct audio_device *adev) 
            my_data->acdb_init(snd_card_name);

    }



    set_platform_defaults(my_data);



    /* Initialize ACDB ID's */

    if (my_data->is_i2s_ext_modem)

        platform_info_init(PLATFORM_INFO_XML_PATH_I2S);
@@ -853,6 +899,14 @@ void platform_deinit(void *platform) 
    hw_info_deinit(my_data->hw_info);

    close_csd_client(my_data->csd);



    int32_t dev;

    for (dev = 0; dev < SND_DEVICE_MAX; dev++) {

        if (backend_table[dev]) {

            free(backend_table[dev]);

            backend_table[dev]= NULL;

        }

    }



    free(platform);

    /* deinit usb */

    audio_extn_usb_deinit();
@@ -884,37 +938,16 @@ int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device, 


void platform_add_backend_name(char *mixer_path, snd_device_t snd_device)

{

    if (snd_device == SND_DEVICE_IN_BT_SCO_MIC)

        strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB)

        strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);

    else if(snd_device == SND_DEVICE_OUT_BT_SCO)

        strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);

    else if(snd_device == SND_DEVICE_OUT_BT_SCO_WB)

        strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_HDMI)

        strlcat(mixer_path, " hdmi", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI)

        strcat(mixer_path, " speaker-and-hdmi");

    else if (snd_device == SND_DEVICE_OUT_AFE_PROXY)

        strlcat(mixer_path, " afe-proxy", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_USB_HEADSET)

        strlcat(mixer_path, " usb-headphones", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)

        strlcat(mixer_path, " speaker-and-usb-headphones",

                MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_IN_USB_HEADSET_MIC)

        strlcat(mixer_path, " usb-headset-mic", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_IN_CAPTURE_FM)

        strlcat(mixer_path, " capture-fm", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_TRANSMISSION_FM)

        strlcat(mixer_path, " transmission-fm", MIXER_PATH_MAX_LENGTH);

    else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER &&

             audio_extn_spkr_prot_is_enabled() ) {

        char platform[PROPERTY_VALUE_MAX];

        property_get("ro.board.platform", platform, "");

        if (!strncmp("apq8084", platform, sizeof("apq8084")))

            strlcat(mixer_path, " speaker-protected", MIXER_PATH_MAX_LENGTH);

    if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {

        ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);

        return;

    }



    const char * suffix = backend_table[snd_device];



    if (suffix != NULL) {

        strlcat(mixer_path, " ", MIXER_PATH_MAX_LENGTH);

        strlcat(mixer_path, suffix, MIXER_PATH_MAX_LENGTH);

    }

}
@@ -928,25 +961,36 @@ int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type) 
    return device_id;

}



int platform_get_snd_device_index(char *snd_device_index_name)

static int find_index(struct name_to_index * table, int32_t len, const char * name)

{

    int ret = 0;

    int i;

    int32_t i;



    if (snd_device_index_name == NULL) {

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

    if (table == NULL) {

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

        ret = -ENODEV;

        goto done;

    }



    for (i=0; i < SND_DEVICE_MAX; i++) {

        if(strcmp(snd_device_name_index[i].name, snd_device_index_name) == 0) {

            ret = snd_device_name_index[i].index;

    if (name == NULL) {

        ALOGE("null key");

        ret = -ENODEV;

        goto done;

    }



    for (i=0; i < len; i++) {

        const char* tn = table[i].name;

        int32_t len = strlen(tn);

        if (strncmp(tn, name, len) == 0) {

            if (strlen(name) != len) {

                continue; // substring

            }

            ret = table[i].index;

            goto done;

        }

    }

    ALOGE("%s: Could not find index for snd_device_index_name = %s",

            __func__, snd_device_index_name);

    ALOGE("%s: Could not find index for name = %s",

            __func__, name);

    ret = -ENODEV;

done:

    return ret;
@@ -1009,6 +1053,16 @@ int platform_get_fluence_type(void *platform, char *value, uint32_t len) 
    return ret;

}



int platform_get_snd_device_index(char *device_name)

{

    return find_index(snd_device_name_index, SND_DEVICE_MAX, device_name);

}



int platform_get_usecase_index(const char *usecase_name)

{

    return find_index(usecase_name_index, AUDIO_USECASE_MAX, usecase_name);

}



int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)

{

    int ret = 0;
@@ -2408,3 +2462,40 @@ bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, struct 


    return false;

}



int platform_set_snd_device_backend(snd_device_t device, const char *backend)

{

    int ret = 0;



    if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {

        ALOGE("%s: Invalid snd_device = %d",

            __func__, device);

        ret = -EINVAL;

        goto done;

    }



    if (backend_table[device]) {

        free(backend_table[device]);

    }

    backend_table[device] = strdup(backend);

done:

    return ret;

}



int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id)

{

    int ret = 0;

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        ret = -EINVAL;

        goto done;

    }



    if ((type != 0) && (type != 1)) {

        ALOGE("%s: invalid usecase type", __func__);

        ret = -EINVAL;

    }

    pcm_device_table[usecase][type] = pcm_id;

done:

    return ret;

}

hal/platform_api.h

+5 −0
Original line number Diff line number Diff line
@@ -76,6 +76,8 @@ int platform_update_usecase_from_source(int source, audio_usecase_t usecase); 
bool platform_listen_device_needs_event(snd_device_t snd_device);

bool platform_listen_usecase_needs_event(audio_usecase_t uc_id);



int platform_set_snd_device_backend(snd_device_t snd_device, const char * backend);



/* From platform_info_parser.c */

int platform_info_init(const char *filename);
@@ -85,4 +87,7 @@ uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info); 


bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, struct audio_usecase *usecase);

bool platform_check_24_bit_support();

int platform_get_usecase_index(const char * usecase);

int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id);



#endif // AUDIO_PLATFORM_API_H