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

Commit 3e5b9e7c authored by Preetam Singh Ranawat's avatar Preetam Singh Ranawat Committed by Gerrit - the friendly Code Review server
Browse files

Hal : Merge DSD and native changes on 8916 platform 

  -Porting of DSD and multiples of native changes on 8916 platfrom
   from 8974

  -Ported changes are I6aa0ef5ea176a0923b0b88924ab046f9a11b7b12,
   Ic8fb0ab9f254d3472fda49dbb824f622d518a451,
   I96702dd1a4ff77440425fa8bfdd5c6f5f0f16ad3,
   I94df832ba5e2a26e9179d66d4639f168b5c30eeb

Change-Id: Idf6362ec1087bd23d545edffa90c3a8a83c0e2a1
parent 8b495d40

hal/msm8916/platform.c

+113 −29
Original line number Diff line number Diff line
@@ -70,7 +70,8 @@ 
#define LIB_ACDB_LOADER "libacdbloader.so"

#define CVD_VERSION_MIXER_CTL "CVD Version"



#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)

#define FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)

#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024 * 1024)

#define MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024)

#define COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING (2 * 1024)

#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
@@ -255,6 +256,8 @@ struct platform_data { 
    int metainfo_key;

    int source_mic_type;

    int max_mic_count;

    bool is_dsd_supported;

    bool is_asrc_supported;

};



static bool is_external_codec = false;
@@ -335,6 +338,7 @@ static const char * const device_table[SND_DEVICE_MAX] = { 
    [SND_DEVICE_OUT_SPEAKER_VBAT] = "vbat-speaker",

    [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",

    [SND_DEVICE_OUT_HEADPHONES] = "headphones",

    [SND_DEVICE_OUT_HEADPHONES_DSD] = "headphones-dsd",

    [SND_DEVICE_OUT_HEADPHONES_44_1] = "headphones-44.1",

    [SND_DEVICE_OUT_LINE] = "line",

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
@@ -466,6 +470,7 @@ static int acdb_device_table[SND_DEVICE_MAX] = { 
    [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,

    [SND_DEVICE_OUT_LINE] = 10,

    [SND_DEVICE_OUT_HEADPHONES] = 10,

    [SND_DEVICE_OUT_HEADPHONES_DSD] = 10,

    [SND_DEVICE_OUT_HEADPHONES_44_1] = 10,

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,

    [SND_DEVICE_OUT_SPEAKER_AND_LINE] = 10,
@@ -597,6 +602,7 @@ static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = { 
    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_VBAT)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_DSD)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_44_1)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_LINE)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},
@@ -1245,12 +1251,15 @@ static void set_platform_defaults(struct platform_data * my_data) 
    backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");

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

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

    backend_tag_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("headphones-dsd");

    backend_tag_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("headphones-44.1");

    backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = strdup("vbat-voice-speaker");

    backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = strdup("vbat-voice-speaker-2");

    backend_tag_table[SND_DEVICE_OUT_BT_A2DP] = strdup("bt-a2dp");

    backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("speaker-and-bt-a2dp");



    hw_interface_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("SLIMBUS_2_RX");

    hw_interface_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("SLIMBUS_5_RX");

    hw_interface_table[SND_DEVICE_OUT_HDMI] = strdup("HDMI_RX");

    hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("SLIMBUS_0_RX-and-HDMI_RX");

    hw_interface_table[SND_DEVICE_OUT_DISPLAY_PORT] = strdup("DISPLAY_PORT_RX");
@@ -1935,6 +1944,10 @@ acdb_init_fail: 
        my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =

            strdup("SLIM_0_RX SampleRate");



    my_data->current_backend_cfg[DSD_NATIVE_BACKEND].bitwidth_mixer_ctl =

        strdup("SLIM_2_RX Format");

    my_data->current_backend_cfg[DSD_NATIVE_BACKEND].samplerate_mixer_ctl =

        strdup("SLIM_2_RX SampleRate");

        my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].bitwidth_mixer_ctl =

            strdup("SLIM_5_RX Format");

        my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].samplerate_mixer_ctl =
@@ -2008,6 +2021,12 @@ acdb_init_fail: 
        }

    }



    if(strstr(snd_card_name, "tavil")) {

        ALOGD("%s:DSD playback is supported", __func__);

        my_data->is_dsd_supported = true;

        my_data->is_asrc_supported = true;

        platform_set_native_support(NATIVE_AUDIO_MODE_MULTIPLE_44_1);

    }

    my_data->edid_info = NULL;

    return my_data;

}
@@ -2338,7 +2357,8 @@ int platform_get_snd_device_bit_width(snd_device_t snd_device) 
}

int platform_set_native_support(int na_mode)

{

    if (NATIVE_AUDIO_MODE_SRC == na_mode || NATIVE_AUDIO_MODE_TRUE_44_1 == na_mode) {

    if (NATIVE_AUDIO_MODE_SRC == na_mode || NATIVE_AUDIO_MODE_TRUE_44_1 == na_mode

        || NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode) {

        na_props.platform_na_prop_enabled = na_props.ui_na_prop_enabled = true;

        na_props.na_mode = na_mode;

        ALOGD("%s:napb: native audio playback enabled in (%s) mode v2.0", __func__,
@@ -2351,6 +2371,16 @@ int platform_set_native_support(int na_mode) 


    return 0;

}

bool platform_check_codec_dsd_support(void *platform)

{

    struct platform_data *my_data = (struct platform_data *)platform;

    return my_data->is_dsd_supported;

}

bool platform_check_codec_asrc_support(void *platform)

{

    struct platform_data *my_data = (struct platform_data *)platform;

    return my_data->is_asrc_supported;

}



int platform_get_native_support()

{
@@ -2404,6 +2434,8 @@ int native_audio_set_params(struct platform_data *platform, 
            mode = NATIVE_AUDIO_MODE_SRC;

        else if (value && !strncmp(value, "true", sizeof("true")))

            mode = NATIVE_AUDIO_MODE_TRUE_44_1;

        else if (value && !strncmp(value, "multiple", sizeof("multiple")))

            mode = NATIVE_AUDIO_MODE_MULTIPLE_44_1;

        else {

            mode = NATIVE_AUDIO_MODE_INVALID;

            ALOGE("%s:napb:native_audio_mode in platform info xml,invalid mode string",
@@ -2514,6 +2546,9 @@ int platform_get_backend_index(snd_device_t snd_device) 
                if (strncmp(backend_tag_table[snd_device], "headphones-44.1",

                            sizeof("headphones-44.1")) == 0)

                        port = HEADPHONE_44_1_BACKEND;

                else if (strncmp(backend_tag_table[snd_device], "headphones-dsd",

                            sizeof("headphones-dsd")) == 0)

                        port = DSD_NATIVE_BACKEND;

                else if (strncmp(backend_tag_table[snd_device], "headphones",

                            sizeof("headphones")) == 0)

                        port = HEADPHONE_BACKEND;
@@ -3134,7 +3169,8 @@ snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *o 
    }



    if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||

        devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {

        devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||

        devices & AUDIO_DEVICE_OUT_LINE) {

        if (OUTPUT_SAMPLING_RATE_44100 == sample_rate &&

            NATIVE_AUDIO_MODE_SRC == na_mode &&

            !audio_extn_get_anc_enabled()) {
@@ -3155,6 +3191,15 @@ snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *o 
                else

                    snd_device = SND_DEVICE_OUT_ANC_HEADSET;

            }

        } else if (NATIVE_AUDIO_MODE_SRC == na_mode &&

                   OUTPUT_SAMPLING_RATE_44100 == sample_rate) {

                snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;

        } else if (NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode &&

                   (sample_rate % OUTPUT_SAMPLING_RATE_44100 == 0) &&

                   (out->format != AUDIO_FORMAT_DSD)) {

                snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;

        } else if (out->format == AUDIO_FORMAT_DSD) {

                snd_device = SND_DEVICE_OUT_HEADPHONES_DSD;

        }  else {

#ifdef RECORD_PLAY_CONCURRENCY

            if (use_voip_out_devices)
@@ -4217,18 +4262,21 @@ uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info) 
        fragment_size = info->offload_buffer_size;

    }



    // For FLAC use max size since it is loss less, and has sampling rates

    // upto 192kHZ

    if (info != NULL && !info->has_video &&

        info->format == AUDIO_FORMAT_FLAC) {

       fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;

       ALOGV("FLAC fragment size %d", fragment_size);

    }



    if (info != NULL && info->has_video && info->is_streaming) {

    if (info != NULL && !info->has_video) {

        if (info->is_streaming) {

            fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING;

            ALOGV("%s: offload fragment size reduced for AV streaming to %d",

                   __func__, fragment_size);

        } else if (info->format == AUDIO_FORMAT_FLAC) {

            fragment_size = FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE;

            ALOGV("FLAC fragment size %d", fragment_size);

        } else if (info->format == AUDIO_FORMAT_DSD) {

            fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;

            if((property_get("audio.native.dsd.buffer.size.kb", value, "")) &&

                    atoi(value))

                fragment_size =  atoi(value) * 1024;

            ALOGV("DSD fragment size %d", fragment_size);

        }

    }



    fragment_size = ALIGN( fragment_size, 1024);
@@ -4457,6 +4505,17 @@ static int platform_set_codec_backend_cfg(struct audio_device* adev, 
            mixer_ctl_set_enum_by_string(ctl, "LPCM");

        }

    }

    if (snd_device == SND_DEVICE_OUT_HEADPHONES || snd_device ==

        SND_DEVICE_OUT_HEADPHONES_44_1) {

        if (sample_rate > 48000 ||

            (bit_width >= 24 && (sample_rate == 48000  || sample_rate == 44100))) {

            ALOGV("%s: apply HPH HQ mode\n", __func__);

            audio_route_apply_and_update_path(adev->audio_route, "hph-highquality-mode");

        } else {

            ALOGV("%s: apply HPH LP mode\n", __func__);

            audio_route_apply_and_update_path(adev->audio_route, "hph-lowpower-mode");

        }

    }



    return ret;

}
@@ -4553,6 +4612,7 @@ static bool platform_check_codec_backend_cfg(struct audio_device* adev, 
    bool passthrough_enabled = false;

    int backend_idx = DEFAULT_CODEC_BACKEND;

    struct platform_data *my_data = (struct platform_data *)adev->platform;

    int na_mode = platform_get_native_support();

    bool channels_updated = false;



    backend_idx = platform_get_backend_index(snd_device);
@@ -4572,6 +4632,7 @@ static bool platform_check_codec_backend_cfg(struct audio_device* adev, 
              __func__);

        bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;

        sample_rate =  CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

        channels = CODEC_BACKEND_DEFAULT_CHANNELS;

    } else {

        /*

         * The backend should be configured at highest bit width and/or
@@ -4633,9 +4694,31 @@ static bool platform_check_codec_backend_cfg(struct audio_device* adev, 
                 ALOGD("%s:becf: afe: true napb active set rate to 44.1 khz",

                       __func__);

            }

        } else if (OUTPUT_SAMPLING_RATE_44100 == sample_rate) {

                 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

                 ALOGD("%s:becf: afe: napb not active - set (48k) default rate",

        } else if (na_mode != NATIVE_AUDIO_MODE_MULTIPLE_44_1) {

            /*

             * Map native sampling rates to upper limit range

             * if multiple of native sampling rates are not supported.

             * This check also indicates that this is not tavil codec

             * And 32bit/384kHz is only supported on tavil

             * Hence reset 32b/384kHz to 24b/192kHz.

             */

            switch (sample_rate) {

                case 44100:

                    sample_rate = 48000;

                    break;

                case 88200:

                    sample_rate = 96000;

                    break;

                case 176400:

                case 352800:

                case 384000:

                    sample_rate = 192000;

                    break;

            }

            if (bit_width > 24)

                bit_width = 24;



            ALOGD("%s:becf: afe: napb not active - set non fractional rate",

                       __func__);

        }

    } else if ((usecase->devices & AUDIO_DEVICE_OUT_SPEAKER) ||
@@ -4748,6 +4831,17 @@ bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, 
    /*this is populated by check_codec_backend_cfg hence set default value to false*/

    backend_cfg.passthrough_enabled = false;



    /* Set Backend sampling rate to 176.4 for DSD64 and

     * 352.8Khz for DSD128.

     * Set Bit Width to 16

     */

    if ((backend_idx == DSD_NATIVE_BACKEND) && (backend_cfg.format == AUDIO_FORMAT_DSD)) {

        backend_cfg.bit_width = 16;

        if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD64)

            backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD64;

        else if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD128)

            backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD128;

    }

    ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d"

          ", backend_idx %d usecase = %d device (%s)", __func__, backend_cfg.bit_width,

          backend_cfg.sample_rate,  backend_cfg.channels, backend_idx, usecase->id,
@@ -5631,16 +5725,6 @@ void platform_update_aanc_path(struct audio_device *adev __unused, 
   return;

}



bool platform_check_codec_dsd_support(void *platform __unused)

{

    return false;

}



bool platform_check_codec_asrc_support(void *platform __unused)

{

    return false;

}



int platform_send_audio_cal(void* platform __unused,

        int acdb_dev_id __unused, int acdb_device_type __unused,

        int app_type __unused, int topology_id __unused,

hal/msm8916/platform.h

+1 −0
Original line number Diff line number Diff line
@@ -88,6 +88,7 @@ enum { 
    SND_DEVICE_OUT_SPEAKER_VBAT,

    SND_DEVICE_OUT_LINE,

    SND_DEVICE_OUT_HEADPHONES,

    SND_DEVICE_OUT_HEADPHONES_DSD,

    SND_DEVICE_OUT_HEADPHONES_44_1,

    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,

    SND_DEVICE_OUT_SPEAKER_AND_LINE,