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

Commit b28f2e5c authored by Preetam Singh Ranawat's avatar Preetam Singh Ranawat
Browse files

hal: Add support for Native Audio(44.1kHz) on msm8952 

- Changes for device/Usecase selection
- Add new and combo devices for headphones
- Combo device handling
- Add new backend and logic to handle multiple
  backends
- Remove hardcoded mixers and select them
  dynamically based on the device.
- Port all the above changes from msm8974
  platfrom to msm8916

Change-Id: Ib9c9e8fcd6530e35700fa2369f2029cf2de3199f
parent 36f3d378

hal/msm8916/platform.c

+273 −76
Original line number Diff line number Diff line
@@ -192,6 +192,20 @@ acdb_loader_get_calibration_t acdb_loader_get_calibration; 
typedef int (*acdb_set_audio_cal_t) (void *, void *, uint32_t);

typedef int (*acdb_get_audio_cal_t) (void *, void *, uint32_t*);



typedef struct codec_backend_cfg {

    uint32_t sample_rate;

    uint32_t bit_width;

    char     *bitwidth_mixer_ctl;

    char     *samplerate_mixer_ctl;

} codec_backend_cfg_t;



typedef struct {

    bool platform_na_prop_enabled;

    bool ui_na_prop_enabled;

} native_audio_prop;



static native_audio_prop na_props = {0, 0};



struct platform_data {

    struct audio_device *adev;

    bool fluence_in_spkr_mode;
@@ -226,6 +240,7 @@ struct platform_data { 
    struct csd_data *csd;

    void *edid_info;

    bool edid_valid;

    codec_backend_cfg_t current_backend_cfg[MAX_CODEC_BACKENDS];

};



static bool is_external_codec = false;
@@ -311,6 +326,7 @@ static const char * const device_table[SND_DEVICE_MAX] = { 
    [SND_DEVICE_OUT_SPEAKER_WSA] = "wsa-speaker",

    [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",

    [SND_DEVICE_OUT_HEADPHONES] = "headphones",

    [SND_DEVICE_OUT_HEADPHONES_44_1] = "headphones-44.1",

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = "speaker-and-headphones-ext-1",

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = "speaker-and-headphones-ext-2",
@@ -415,6 +431,7 @@ static int acdb_device_table[SND_DEVICE_MAX] = { 
    [SND_DEVICE_OUT_SPEAKER_WSA] = 135,

    [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,

    [SND_DEVICE_OUT_HEADPHONES] = 10,

    [SND_DEVICE_OUT_HEADPHONES_44_1] = 10,

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = 10,

    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = 10,
@@ -521,6 +538,7 @@ static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = { 
    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_WSA)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_44_1)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1)},

    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2)},
@@ -1075,7 +1093,7 @@ static void set_platform_defaults() 
        backend_table[dev] = NULL;

    }

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

        backend_bit_width_table[dev] = 16;

        backend_bit_width_table[dev] = CODEC_BACKEND_DEFAULT_BIT_WIDTH;

    }



    // TBD - do these go to the platform-info.xml file.
@@ -1097,6 +1115,7 @@ static void set_platform_defaults() 
    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");

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

}



void get_cvd_version(char *cvd_version, struct audio_device *adev)
@@ -1231,6 +1250,7 @@ void *platform_init(struct audio_device *adev) 
    char *cvd_version = NULL;

    const char *mixer_ctl_name = "Set HPX ActiveBe";

    struct mixer_ctl *ctl = NULL;

    int idx;



    my_data = calloc(1, sizeof(struct platform_data));

    if (!my_data) {
@@ -1473,6 +1493,26 @@ acdb_init_fail: 
    /* init audio device arbitration */

    audio_extn_dev_arbi_init();



    my_data->edid_info = NULL;



    /* initialize backend config */

    for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {

        my_data->current_backend_cfg[idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

        if (idx == HEADPHONE_44_1_BACKEND)

            my_data->current_backend_cfg[idx].sample_rate = OUTPUT_SAMPLING_RATE_44100;

        my_data->current_backend_cfg[idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;

    }



    my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =

        strdup("SLIM_0_RX Format");

    my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =

        strdup("SLIM_0_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 =

        strdup("SLIM_5_RX SampleRate");



    my_data->edid_info = NULL;

    return my_data;

}
@@ -1730,14 +1770,107 @@ int platform_get_snd_device_bit_width(snd_device_t snd_device) 
    return backend_bit_width_table[snd_device];

}



int platform_set_native_support(bool codec_support __unused)

int platform_set_native_support(bool codec_support)

{

    na_props.platform_na_prop_enabled = na_props.ui_na_prop_enabled

        = codec_support;

    ALOGV("%s: na_props.platform_na_prop_enabled: %d", __func__,

           na_props.platform_na_prop_enabled);

    return 0;

}



int platform_get_backend_index(snd_device_t snd_device __unused)

int platform_get_native_support()

{

    return 0;

    int ret;

    if (na_props.platform_na_prop_enabled) {

        ret = na_props.ui_na_prop_enabled;

    } else {

        ret = na_props.platform_na_prop_enabled;

    }

    ALOGV("%s: na_props.ui_na_prop_enabled: %d", __func__,

           na_props.ui_na_prop_enabled);

    return ret;

}



void native_audio_get_params(struct str_parms *query,

                             struct str_parms *reply,

                             char *value, int len)

{

    int ret;

    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,

                            value, len);

    if (ret >= 0) {

        if (na_props.platform_na_prop_enabled) {

            str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,

                          na_props.ui_na_prop_enabled ? "true" : "false");

            ALOGV("%s: na_props.ui_na_prop_enabled: %d", __func__,

                   na_props.ui_na_prop_enabled);

        } else {

            str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,

                              "false");

            ALOGV("%s: native audio not supported: %d", __func__,

                   na_props.platform_na_prop_enabled);

        }

    }

}



int native_audio_set_params(struct platform_data *platform,

                            struct str_parms *parms, char *value, int len)

{

    int ret = 0;

    struct audio_usecase *usecase;

    struct listnode *node;



    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,

                             value, len);

    if (ret >= 0) {

        if (na_props.platform_na_prop_enabled) {

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

                na_props.ui_na_prop_enabled = true;

            else

                na_props.ui_na_prop_enabled = false;



            str_parms_del(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO);



            /* Iterate through the usecase list and trigger device switch for

            all the appropriate usecases */

            list_for_each(node, &(platform->adev)->usecase_list) {

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



                 if (is_offload_usecase(usecase->id) &&

                    (usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||

                    usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) &&

                    OUTPUT_SAMPLING_RATE_44100 == usecase->stream.out->sample_rate) {

                         select_devices(platform->adev, usecase->id);

                         ALOGV("%s: triggering dynamic device switch for usecase: "

                               "%d, device: %d", __func__, usecase->id,

                               usecase->stream.out->devices);

                 }

            }

        } else {

              ALOGV("%s: native audio not supported: %d", __func__,

                     na_props.platform_na_prop_enabled);

        }

    }

    return ret;

}



int platform_get_backend_index(snd_device_t snd_device)

{

    int32_t port = DEFAULT_CODEC_BACKEND;



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

        if (backend_table[snd_device] != NULL &&

            !strcmp(backend_table[snd_device], "headphones-44.1"))

            port = HEADPHONE_44_1_BACKEND;

        else

            port = DEFAULT_CODEC_BACKEND;

    } else {

        ALOGV("%s: Invalid device - %d ", __func__, snd_device);

    }



    ALOGV("%s: backend port - %d", __func__, port);

    return port;

}



int platform_send_audio_calibration(void *platform, struct audio_usecase *usecase,
@@ -2033,6 +2166,7 @@ snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *o 
    audio_mode_t mode = adev->mode;

    snd_device_t snd_device = SND_DEVICE_NONE;

    audio_devices_t devices = out->devices;

    unsigned int sample_rate = out->sample_rate;

#ifdef RECORD_PLAY_CONCURRENCY

    bool use_voip_out_devices = false;

    bool prop_rec_play_enabled = false;
@@ -2153,7 +2287,10 @@ 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) {

        if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET

        if (OUTPUT_SAMPLING_RATE_44100 == sample_rate &&

            platform_get_native_support()) {

            snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;

        }else if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET

            && audio_extn_get_anc_enabled()) {

#ifdef RECORD_PLAY_CONCURRENCY

            if (use_voip_out_devices) {
@@ -2767,6 +2904,7 @@ static int parse_audiocal_cfg(struct str_parms *parms, acdb_audio_cal_cfg_t *cal 


static void set_audiocal(void *platform, struct str_parms *parms, char *value, int len) {

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

    struct stream_out out={0};

    acdb_audio_cal_cfg_t cal={0};

    uint8_t *dptr = NULL;

    int32_t dlen;
@@ -2803,7 +2941,8 @@ static void set_audiocal(void *platform, struct str_parms *parms, char *value, i 
          if(audio_is_input_device(cal.dev_id)) {

              cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);

          } else {

              cal.snd_dev_id = platform_get_output_snd_device(platform, cal.dev_id);

              out.devices = cal.dev_id;

              cal.snd_dev_id = platform_get_output_snd_device(platform, &out);

          }

        }

        cal.acdb_dev_id = platform_get_snd_device_acdb_id(cal.snd_dev_id);
@@ -2896,6 +3035,7 @@ int platform_set_parameters(void *platform, struct str_parms *parms) 
        }

    }

#endif

    native_audio_set_params(platform, parms, value, sizeof(value));

    ALOGV("%s: exit with code(%d)", __func__, ret);

    return ret;

}
@@ -3002,6 +3142,7 @@ int platform_update_lch(void *platform, struct voice_session *session, 


static void get_audiocal(void *platform, void *keys, void *pReply) {

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

    struct stream_out out={0};

    struct str_parms *query = (struct str_parms *)keys;

    struct str_parms *reply=(struct str_parms *)pReply;

    acdb_audio_cal_cfg_t cal={0};
@@ -3032,7 +3173,8 @@ static void get_audiocal(void *platform, void *keys, void *pReply) { 
    if(cal.dev_id & AUDIO_DEVICE_BIT_IN) {

        cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);

    } else if(cal.dev_id) {

        cal.snd_dev_id = platform_get_output_snd_device(platform, cal.dev_id);

        out.devices = cal.dev_id;

        cal.snd_dev_id = platform_get_output_snd_device(platform, &out);

    }

    cal.acdb_dev_id =  platform_get_snd_device_acdb_id(cal.snd_dev_id);

    if (cal.acdb_dev_id < 0) {
@@ -3128,6 +3270,7 @@ void platform_get_parameters(void *platform, 


        str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value);

    }

    native_audio_get_params(query, reply, value, sizeof(value));



    ret = str_parms_get_str(query, AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED,

                                    value, sizeof(value));
@@ -3388,29 +3531,59 @@ uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info) 
    return fragment_size;

}



int platform_set_codec_backend_cfg(struct audio_device* adev,

                         unsigned int bit_width, unsigned int sample_rate)

int platform_is_external_codec (char *snd_card_name)

{

    ALOGV("%s bit width: %d, sample rate: %d", __func__, bit_width, sample_rate);



    int ret = 0;

    const char *snd_card_name = mixer_get_name(adev->mixer);



    if (bit_width != adev->cur_codec_backend_bit_width) {

        const char * mixer_ctl_name;

    if (!strncmp(snd_card_name, "msm8952-tomtom-snd-card",

        sizeof("msm8952-tomtom-snd-card")) ||

        !strncmp(snd_card_name, "msm8976-tasha-snd-card",

                sizeof("msm8976-tasha-snd-card"))) {

            mixer_ctl_name = "SLIM_0_RX Format";

        sizeof("msm8976-tasha-snd-card")))

    {

        /* external codec, for rest/old of the external codecs

           we dont support this funtionality(chaning AFE params)

           at the monment

         */

        return 1;

    }

        else

            mixer_ctl_name = "MI2S_RX Format";

    else {

        /* internal codec */

        return 0;

    }

}



int platform_set_codec_backend_cfg(struct audio_device* adev,

                         snd_device_t snd_device,

                         unsigned int bit_width, unsigned int sample_rate)

{

    int ret = 0;

    int backend_idx = DEFAULT_CODEC_BACKEND;

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

    ALOGV("%s bit width: %d, sample rate: %d\n", __func__, bit_width, sample_rate);



    const char *snd_card_name = mixer_get_name(adev->mixer);

    int is_external_codec = platform_is_external_codec(snd_card_name);







    backend_idx = platform_get_backend_index(snd_device);

    ALOGV("%s bit width: %d, sample rate: %d backend_idx - %d\n",

            __func__, bit_width, sample_rate, backend_idx);



    if (bit_width !=

        my_data->current_backend_cfg[backend_idx].bit_width) {



        struct  mixer_ctl *ctl;

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

        if (!is_external_codec) {

            ctl = mixer_get_ctl_by_name(adev->mixer,

                        "MI2S_RX Format");



        } else {

            ctl = mixer_get_ctl_by_name(adev->mixer,

                        my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);

        }

        if (!ctl) {

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

                    __func__, mixer_ctl_name);

                    __func__, my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);

            return -EINVAL;

        }
@@ -3418,10 +3591,12 @@ int platform_set_codec_backend_cfg(struct audio_device* adev, 
                mixer_ctl_set_enum_by_string(ctl, "S24_LE");

        } else {

            mixer_ctl_set_enum_by_string(ctl, "S16_LE");

            if (backend_idx != HEADPHONE_44_1_BACKEND)

                sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

        }

        adev->cur_codec_backend_bit_width = bit_width;

        ALOGE("Backend bit width is set to %d ", bit_width);

        my_data->current_backend_cfg[backend_idx].bit_width = bit_width;

        ALOGD("%s: %s mixer set to %d bit", __func__,

            my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width);

    }



    /*
@@ -3433,9 +3608,12 @@ int platform_set_codec_backend_cfg(struct audio_device* adev, 
     * Upper limit is inclusive in the sample rate range.

     */

    // TODO: This has to be more dynamic based on policy file

    if (sample_rate != adev->cur_codec_backend_samplerate) {



    if ((sample_rate != my_data->current_backend_cfg[(int)backend_idx].sample_rate) &&

        (is_external_codec) ) {

            /* sample rate update is needed only for external codecs which

               support 24 bit playback*/

            char *rate_str = NULL;

            const char * mixer_ctl_name = "SLIM_0_RX SampleRate";

            struct  mixer_ctl *ctl;



            switch (sample_rate) {
@@ -3444,10 +3622,12 @@ int platform_set_codec_backend_cfg(struct audio_device* adev, 
            case 16000:

            case 22050:

            case 32000:

            case 44100:

            case 48000:

                rate_str = "KHZ_48";

                break;

            case 44100:

                rate_str = "KHZ_44P1";

                break;

            case 64000:

            case 88200:

            case 96000:
@@ -3462,32 +3642,46 @@ int platform_set_codec_backend_cfg(struct audio_device* adev, 
                break;

            }



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

            ctl = mixer_get_ctl_by_name(adev->mixer,

                my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);

            if(!ctl) {

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

                    __func__, mixer_ctl_name);

                    __func__, my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);

                return -EINVAL;

            }



            ALOGV("Set sample rate as rate_str = %s", rate_str);

            ALOGD("%s: %s set to %s", __func__,

                my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl, rate_str);

            mixer_ctl_set_enum_by_string(ctl, rate_str);

            adev->cur_codec_backend_samplerate = sample_rate;

            my_data->current_backend_cfg[backend_idx].sample_rate = sample_rate;

    }



    return ret;

}



bool platform_check_codec_backend_cfg(struct audio_device* adev,

                                   struct audio_usecase* usecase __unused,

                                   struct audio_usecase* usecase,

                                   snd_device_t snd_device,

                                   unsigned int* new_bit_width,

                                   unsigned int* new_sample_rate)

{

    bool backend_change = false;

    struct listnode *node;

    struct stream_out *out = NULL;

    unsigned int bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;

    unsigned int sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

    char value[PROPERTY_VALUE_MAX] = {0};

    unsigned int bit_width;

    unsigned int sample_rate;

    int backend_idx = DEFAULT_CODEC_BACKEND;

    int usecase_backend_idx = DEFAULT_CODEC_BACKEND;

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



    backend_idx = platform_get_backend_index(snd_device);



    bit_width = *new_bit_width;

    sample_rate = *new_sample_rate;



    ALOGI("%s Codec selected backend: %d current bit width: %d and sample rate: %d",

               __func__, backend_idx, bit_width, sample_rate);



    // For voice calls use default configuration

    // force routing is not required here, caller will do it anyway
@@ -3508,39 +3702,34 @@ bool platform_check_codec_backend_cfg(struct audio_device* adev, 
        list_for_each(node, &adev->usecase_list) {

            struct audio_usecase *curr_usecase;

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

            if (curr_usecase->type == PCM_PLAYBACK) {

            if (curr_usecase->type == PCM_PLAYBACK &&

                usecase != curr_usecase) {

                struct stream_out *out =

                           (struct stream_out*) curr_usecase->stream.out;

                if (out != NULL ) {

                    ALOGV("Offload playback running bw %d sr %d",

                              out->bit_width, out->sample_rate);

                usecase_backend_idx = platform_get_backend_index(curr_usecase->out_snd_device);



                if (out != NULL &&

                    usecase_backend_idx == backend_idx) {

                    ALOGV("%s: usecase Offload playback running bw %d sr %d device %s be_idx %d",

                            __func__, out->bit_width, out->sample_rate,

                            platform_get_snd_device_name(curr_usecase->out_snd_device), usecase_backend_idx);

                        if (bit_width < out->bit_width)

                            bit_width = out->bit_width;

                        if (sample_rate < out->sample_rate)

                            sample_rate = out->sample_rate;

                        if (out->sample_rate < OUTPUT_SAMPLING_RATE_44100)

                            sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

                }

            }

        }

    }



    // 16 bit playback on speakers is allowed through 48 khz backend only

    if (backend_idx != HEADPHONE_44_1_BACKEND) {

        // 16 bit playbacks are allowed through 16 bit/48 khz backend only for

        // all non-native streams

        if (16 == bit_width) {

            sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

    }



    //check if mulitchannel clip needs to be down sampled to 48k

    property_get("audio.playback.mch.downsample",value,"");

    if (!strncmp("true", value, sizeof("true"))) {

        out = usecase->stream.out;

        if ((popcount(out->channel_mask) > 2) &&

                      (out->sample_rate > CODEC_BACKEND_DEFAULT_SAMPLE_RATE) &&

                      !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH)) {

           sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

          /* update out sample rate to reflect current backend sample rate  */

           out->sample_rate = sample_rate;

           ALOGD("%s: MCH session defaulting sample rate to %d",

                        __func__, sample_rate);

         }

            ALOGD("%s: resetting sample_rate back to default, "

                   "backend_idx: %d", __func__, backend_idx);

        }



        // 24 bit playback on speakers is allowed through 48 khz backend only
@@ -3550,10 +3739,13 @@ bool platform_check_codec_backend_cfg(struct audio_device* adev, 
            bit_width = (uint32_t)platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER);

            sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;

        }

    }

    ALOGI("%s Codec selected backend: %d updated bit width: %d and sample rate: %d",

               __func__, backend_idx, bit_width, sample_rate);

    // Force routing if the expected bitwdith or samplerate

    // is not same as current backend comfiguration

    if ((bit_width != adev->cur_codec_backend_bit_width) ||

        (sample_rate != adev->cur_codec_backend_samplerate)) {

    if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||

        (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate)) {

        *new_bit_width = bit_width;

        *new_sample_rate = sample_rate;

        backend_change = true;
@@ -3565,21 +3757,26 @@ bool platform_check_codec_backend_cfg(struct audio_device* adev, 
}



bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev,

                                              struct audio_usecase *usecase,

                                              snd_device_t snd_device __unused)

    struct audio_usecase *usecase, snd_device_t snd_device)

{

    ALOGV("platform_check_and_set_codec_backend_cfg usecase = %d",usecase->id );

    unsigned int new_bit_width;

    unsigned int new_sample_rate;

    int backend_idx = DEFAULT_CODEC_BACKEND;

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



    ALOGV("%s: usecase = %d", __func__, usecase->id );



    unsigned int new_bit_width, old_bit_width;

    unsigned int new_sample_rate, old_sample_rate;

    backend_idx = platform_get_backend_index(snd_device);



    new_bit_width = old_bit_width = adev->cur_codec_backend_bit_width;

    new_sample_rate = old_sample_rate = adev->cur_codec_backend_samplerate;

    new_bit_width = usecase->stream.out->bit_width;

    new_sample_rate = usecase->stream.out->sample_rate;



    ALOGW("Codec backend bitwidth %d, samplerate %d", old_bit_width, old_sample_rate);

    if (platform_check_codec_backend_cfg(adev, usecase,

    ALOGI("%s: Usecase bitwidth %d, samplerate %d, backend_idx %d",

        __func__, new_bit_width, new_sample_rate, backend_idx);

    if (platform_check_codec_backend_cfg(adev, usecase, snd_device,

                                      &new_bit_width, &new_sample_rate)) {

        platform_set_codec_backend_cfg(adev, new_bit_width, new_sample_rate);

        platform_set_codec_backend_cfg(adev, snd_device,

                                       new_bit_width, new_sample_rate);

        return true;

    }

hal/msm8916/platform.h

+10 −3
Original line number Diff line number Diff line
@@ -37,7 +37,11 @@ enum { 
/*

 * Below are the devices for which is back end is same, SLIMBUS_0_RX.

 * All these devices are handled by the internal HW codec. We can

 * enable any one of these devices at any time

 * enable any one of these devices at any time. An exception here is

 * 44.1k headphone which uses different backend. This is filtered

 * as different hal internal device in the code but remains same

 * as standard android device AUDIO_DEVICE_OUT_WIRED_HEADPHONE

 * for other layers.

 */

#define AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND \

    (AUDIO_DEVICE_OUT_EARPIECE | AUDIO_DEVICE_OUT_SPEAKER | \
@@ -164,12 +168,15 @@ enum { 


#define DEFAULT_OUTPUT_SAMPLING_RATE 48000

#define OUTPUT_SAMPLING_RATE_44100      44100



#define MAX_PORT                        6

#define ALL_CODEC_BACKEND_PORT          0

#define HEADPHONE_44_1_BACKEND_PORT     5

enum {

    DEFAULT_CODEC_BACKEND,

    HEADPHONE_44_1_BACKEND,

    MAX_CODEC_BACKENDS

};

#define AUDIO_PARAMETER_KEY_NATIVE_AUDIO "audio.nat.codec.enabled"



#define ALL_SESSION_VSID                0xFFFFFFFF

#define DEFAULT_MUTE_RAMP_DURATION_MS   20

hal/audio_hw.c

+1 −1

File changed.

Contains only whitespace changes.