diff options
Diffstat (limited to 'audio/hal/msm8916/platform.c')
| -rw-r--r-- | audio/hal/msm8916/platform.c | 2735 |
1 files changed, 2735 insertions, 0 deletions
diff --git a/audio/hal/msm8916/platform.c b/audio/hal/msm8916/platform.c new file mode 100644 index 0000000..fa6bc8f --- /dev/null +++ b/audio/hal/msm8916/platform.c @@ -0,0 +1,2735 @@ +/* + * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. + * Not a Contribution. + * + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "msm8916_platform" +/*#define LOG_NDEBUG 0*/ +#define LOG_NDDEBUG 0 + +#include <stdlib.h> +#include <dlfcn.h> +#include <fcntl.h> +#include <sys/ioctl.h> +#include <cutils/log.h> +#include <cutils/properties.h> +#include <cutils/str_parms.h> +#include <audio_hw.h> +#include <platform_api.h> +#include "platform.h" +#include "audio_extn.h" +#include "voice_extn.h" +#include "sound/msmcal-hwdep.h" +#define SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID (100) + +#define MIXER_XML_PATH "/system/etc/mixer_paths.xml" +#define MIXER_XML_PATH_MTP "/system/etc/mixer_paths_mtp.xml" +#define MIXER_XML_PATH_SBC "/system/etc/mixer_paths_sbc.xml" +#define MIXER_XML_PATH_MSM8909_PM8916 "/system/etc/mixer_paths_msm8909_pm8916.xml" +#define MIXER_XML_PATH_QRD_SKUH "/system/etc/mixer_paths_qrd_skuh.xml" +#define MIXER_XML_PATH_QRD_SKUI "/system/etc/mixer_paths_qrd_skui.xml" +#define MIXER_XML_PATH_QRD_SKUHF "/system/etc/mixer_paths_qrd_skuhf.xml" +#define MIXER_XML_PATH_SKUK "/system/etc/mixer_paths_skuk.xml" +#define MIXER_XML_PATH_SKUA "/system/etc/mixer_paths_skua.xml" +#define MIXER_XML_PATH_SKUC "/system/etc/mixer_paths_skuc.xml" +#define MIXER_XML_PATH_SKUE "/system/etc/mixer_paths_skue.xml" +#define MIXER_XML_PATH_SKUL "/system/etc/mixer_paths_skul.xml" +#define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml" +#define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml" +#define MIXER_XML_PATH_WCD9306 "/system/etc/mixer_paths_wcd9306.xml" +#define MIXER_XML_PATH_WCD9330 "/system/etc/mixer_paths_wcd9330.xml" +#define PLATFORM_INFO_XML_PATH "/system/etc/audio_platform_info.xml" +#define LIB_ACDB_LOADER "libacdbloader.so" +#define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID" +#define CVD_VERSION_MIXER_CTL "CVD Version" + +#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 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) +/* Used in calculating fragment size for pcm offload */ +#define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV 2000 /* 2 secs */ +#define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING 100 /* 100 millisecs */ + +/* MAX PCM fragment size cannot be increased further due + * to flinger's cblk size of 1mb,and it has to be a multiple of + * 24 - lcm of channels supported by DSP + */ +#define MAX_PCM_OFFLOAD_FRAGMENT_SIZE (240 * 1024) +#define MIN_PCM_OFFLOAD_FRAGMENT_SIZE (32 * 1024) + +#define ALIGN( num, to ) (((num) + (to-1)) & (~(to-1))) +/* + * This file will have a maximum of 38 bytes: + * + * 4 bytes: number of audio blocks + * 4 bytes: total length of Short Audio Descriptor (SAD) blocks + * Maximum 10 * 3 bytes: SAD blocks + */ +#define MAX_SAD_BLOCKS 10 +#define SAD_BLOCK_SIZE 3 +#define MAX_CVD_VERSION_STRING_SIZE 100 + +/* EDID format ID for LPCM audio */ +#define EDID_FORMAT_LPCM 1 + +/* fallback app type if the default app type from acdb loader fails */ +#define DEFAULT_APP_TYPE 0x11130 + +/* Retry for delay in FW loading*/ +#define RETRY_NUMBER 20 +#define RETRY_US 500000 +#define MAX_SND_CARD 8 + +#define SAMPLE_RATE_8KHZ 8000 +#define SAMPLE_RATE_16KHZ 16000 + +#define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence" +#define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable" +#define AUDIO_PARAMETER_KEY_HD_VOICE "hd_voice" +#define AUDIO_PARAMETER_KEY_VOLUME_BOOST "volume_boost" +#define MAX_CAL_NAME 20 +#define APP_TYPE_SYSTEM_SOUNDS 0x00011131 +#define APP_TYPE_GENERAL_RECORDING 0x00011132 + +char cal_name_info[WCD9XXX_MAX_CAL][MAX_CAL_NAME] = { + [WCD9XXX_ANC_CAL] = "anc_cal", + [WCD9XXX_MBHC_CAL] = "mbhc_cal", + [WCD9XXX_MAD_CAL] = "mad_cal", +}; + +#define AUDIO_PARAMETER_KEY_REC_PLAY_CONC "rec_play_conc_on" + +enum { + VOICE_FEATURE_SET_DEFAULT, + VOICE_FEATURE_SET_VOLUME_BOOST +}; + +struct audio_block_header +{ + int reserved; + int length; +}; + +/* Audio calibration related functions */ +typedef void (*acdb_deallocate_t)(); +typedef int (*acdb_init_t)(char *, char *, int); +typedef void (*acdb_send_audio_cal_t)(int, int, int, int); +typedef void (*acdb_send_voice_cal_t)(int, int); +typedef int (*acdb_reload_vocvoltable_t)(int); +typedef int (*acdb_get_default_app_type_t)(void); +typedef int (*acdb_loader_get_calibration_t)(char *attr, int size, void *data); +acdb_loader_get_calibration_t acdb_loader_get_calibration; + +struct platform_data { + struct audio_device *adev; + bool fluence_in_spkr_mode; + bool fluence_in_voice_call; + bool fluence_in_voice_rec; + bool fluence_in_audio_rec; + int fluence_type; + char fluence_cap[PROPERTY_VALUE_MAX]; + int fluence_mode; + bool slowtalk; + bool hd_voice; + bool ec_ref_enabled; + /* Audio calibration related functions */ + void *acdb_handle; + int voice_feature_set; + acdb_init_t acdb_init; + acdb_deallocate_t acdb_deallocate; + acdb_send_audio_cal_t acdb_send_audio_cal; + acdb_send_voice_cal_t acdb_send_voice_cal; + acdb_reload_vocvoltable_t acdb_reload_vocvoltable; + acdb_get_default_app_type_t acdb_get_default_app_type; +#ifdef RECORD_PLAY_CONCURRENCY + bool rec_play_conc_set; +#endif + void *hw_info; + struct csd_data *csd; +}; + +static bool is_external_codec = false; +static const int pcm_device_table_of_ext_codec[AUDIO_USECASE_MAX][2] = { + [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE_OF_EXT_CODEC, QCHAT_CALL_PCM_DEVICE_OF_EXT_CODEC} +}; + +/* List of use cases that has different PCM device ID's for internal and external codecs */ +static const int misc_usecase[AUDIO_USECASE_MAX] = { USECASE_QCHAT_CALL }; + +static const 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, + LOWLATENCY_PCM_DEVICE}, + [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE, + MULTIMEDIA2_PCM_DEVICE}, + [USECASE_AUDIO_PLAYBACK_OFFLOAD] = + {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE}, + [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE}, + [USECASE_AUDIO_RECORD_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, COMPRESS_CAPTURE_DEVICE}, + [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE, + LOWLATENCY_PCM_DEVICE}, + [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE, + MULTIMEDIA2_PCM_DEVICE}, + [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE}, + [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX}, + [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX}, + [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE}, + [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE}, + [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE}, + [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE}, + [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE}, + [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE}, + [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE, + AUDIO_RECORD_PCM_DEVICE}, + [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, + AUDIO_RECORD_PCM_DEVICE}, + [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, + AUDIO_RECORD_PCM_DEVICE}, + [USECASE_INCALL_REC_UPLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, + COMPRESS_CAPTURE_DEVICE}, + [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, + COMPRESS_CAPTURE_DEVICE}, + [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, + COMPRESS_CAPTURE_DEVICE}, + [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE, + INCALL_MUSIC_UPLINK_PCM_DEVICE}, + [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE, + INCALL_MUSIC_UPLINK2_PCM_DEVICE}, + [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1}, + [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE}, +}; + +/* Array to store sound devices */ +static const char * const device_table[SND_DEVICE_MAX] = { + [SND_DEVICE_NONE] = "none", + /* Playback sound devices */ + [SND_DEVICE_OUT_HANDSET] = "handset", + [SND_DEVICE_OUT_SPEAKER] = "speaker", + [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse", + [SND_DEVICE_OUT_HEADPHONES] = "headphones", + [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones", + [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset", + [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker", + [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones", + [SND_DEVICE_OUT_HDMI] = "hdmi", + [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi", + [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset", + [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb", + [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones", + [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones", + [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset", + [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy", + [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones", + [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones", + [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm", + [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones", + [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones", + [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones", + [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones", + [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones", + [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset", + [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected", +#ifdef RECORD_PLAY_CONCURRENCY + [SND_DEVICE_OUT_VOIP_HANDSET] = "voip-handset", + [SND_DEVICE_OUT_VOIP_SPEAKER] = "voip-speaker", + [SND_DEVICE_OUT_VOIP_HEADPHONES] = "voip-headphones", +#endif + + /* Capture sound devices */ + [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic", + [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic", + [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic", + [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic", + [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire", + [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire", + [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire", + [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire", + [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic", + [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic", + [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic", + [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic", + [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire", + [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire", + [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire", + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire", + [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic", + [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic", + [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic", + [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic", + [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic", + [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic", + [SND_DEVICE_IN_BT_SCO_MIC_NREC] = "bt-sco-mic", + [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb", + [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = "bt-sco-mic-wb", + [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic", + [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef", + [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef", + [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic", + [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic", + [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic", + [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic", + [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic", + [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic", + [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef", + [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence", + [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic", + [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm", + [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic", + [SND_DEVICE_IN_QUAD_MIC] = "quad-mic", + [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef", + [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef", + [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback", + [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = "voice-speaker-dmic-broadside", + [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = "speaker-dmic-broadside", + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = "speaker-dmic-broadside", + [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = "speaker-dmic-broadside", + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = "speaker-dmic-broadside", + [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = "aanc-fluence-dmic-handset", +}; + +/* ACDB IDs (audio DSP path configuration IDs) for each sound device */ +static int acdb_device_table[SND_DEVICE_MAX] = { + [SND_DEVICE_NONE] = -1, + [SND_DEVICE_OUT_HANDSET] = 7, + [SND_DEVICE_OUT_SPEAKER] = 14, + [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14, + [SND_DEVICE_OUT_HEADPHONES] = 10, + [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10, + [SND_DEVICE_OUT_VOICE_HANDSET] = 7, + [SND_DEVICE_OUT_VOICE_SPEAKER] = 14, + [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10, + [SND_DEVICE_OUT_HDMI] = 18, + [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14, + [SND_DEVICE_OUT_BT_SCO] = 22, + [SND_DEVICE_OUT_BT_SCO_WB] = 39, + [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17, + [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17, + [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37, + [SND_DEVICE_OUT_AFE_PROXY] = 0, + [SND_DEVICE_OUT_USB_HEADSET] = 45, + [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14, + [SND_DEVICE_OUT_TRANSMISSION_FM] = 0, + [SND_DEVICE_OUT_ANC_HEADSET] = 26, + [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27, + [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26, + [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27, + [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26, + [SND_DEVICE_OUT_ANC_HANDSET] = 103, + [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 101, +#ifdef RECORD_PLAY_CONCURRENCY + [SND_DEVICE_OUT_VOIP_HANDSET] = 133, + [SND_DEVICE_OUT_VOIP_SPEAKER] = 132, + [SND_DEVICE_OUT_VOIP_HEADPHONES] = 134, +#endif + + [SND_DEVICE_IN_HANDSET_MIC] = 4, + [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106, + [SND_DEVICE_IN_HANDSET_MIC_NS] = 107, + [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108, + [SND_DEVICE_IN_HANDSET_DMIC] = 41, + [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109, + [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110, + [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111, + [SND_DEVICE_IN_SPEAKER_MIC] = 11, + [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112, + [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113, + [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114, + [SND_DEVICE_IN_SPEAKER_DMIC] = 43, + [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115, + [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116, + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117, + [SND_DEVICE_IN_HEADSET_MIC] = 8, + [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47, + [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11, + [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8, + [SND_DEVICE_IN_HDMI_MIC] = 4, + [SND_DEVICE_IN_BT_SCO_MIC] = 21, + [SND_DEVICE_IN_BT_SCO_MIC_NREC] = 122, + [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38, + [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = 123, + [SND_DEVICE_IN_CAMCORDER_MIC] = 4, + [SND_DEVICE_IN_VOICE_DMIC] = 41, + [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43, + [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19, + [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16, + [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36, + [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16, + [SND_DEVICE_IN_VOICE_REC_MIC] = 4, + [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107, + [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34, + [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41, + [SND_DEVICE_IN_USB_HEADSET_MIC] = 44, + [SND_DEVICE_IN_CAPTURE_FM] = 0, + [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104, + [SND_DEVICE_IN_QUAD_MIC] = 46, + [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34, + [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35, + [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102, + [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = 12, + [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = 12, + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = 119, + [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = 121, + [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120, + [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = 135, +}; + +struct snd_device_index { + char name[100]; + unsigned int 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] = { + {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HEADPHONES)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_HDMI)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_AFE_PROXY)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_TRANSMISSION_FM)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_FB_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HANDSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)}, +#ifdef RECORD_PLAY_CONCURRENCY + {TO_NAME_INDEX(SND_DEVICE_OUT_VOIP_HANDSET)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOIP_SPEAKER)}, + {TO_NAME_INDEX(SND_DEVICE_OUT_VOIP_HEADPHONES)}, +#endif + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_FLUENCE)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_HEADSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_NREC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB)}, + {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_CAMCORDER_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_QMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_NS)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)}, + {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_FM)}, + {TO_NAME_INDEX(SND_DEVICE_IN_AANC_HANDSET_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_QUAD_MIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_STEREO_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_STEREO_DMIC)}, + {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)}, + {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC)}, +}; + +#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) + +static bool is_misc_usecase(audio_usecase_t usecase) { + bool ret = false; + int i; + + for (i = 0; i < AUDIO_USECASE_MAX; i++) { + if(usecase == misc_usecase[i]) { + ret = true; + break; + } + } + return ret; +} + + +static void update_codec_type(const char *snd_card_name) { + + if (!strncmp(snd_card_name, "msm8939-tapan-snd-card", + sizeof("msm8939-tapan-snd-card")) || + !strncmp(snd_card_name, "msm8939-tapan9302-snd-card", + sizeof("msm8939-tapan9302-snd-card"))|| + !strncmp(snd_card_name, "msm8939-tomtom9330-snd-card", + sizeof("msm8939-tomtom9330-snd-card"))) { + ALOGI("%s: snd_card_name: %s",__func__,snd_card_name); + is_external_codec = true; + } +} +static void query_platform(const char *snd_card_name, + char *mixer_xml_path) +{ + if (!strncmp(snd_card_name, "msm8x16-snd-card-mtp", + 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-snd-card-sbc", + sizeof("msm8x16-snd-card-sbc"))) { + strlcpy(mixer_xml_path, MIXER_XML_PATH_SBC, + sizeof(MIXER_XML_PATH_SBC)); + + 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_internal_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_internal_codec) / sizeof(msm_device_to_be_id_internal_codec[0]); + + } else if (!strncmp(snd_card_name, "msm8909-pm8916-snd-card", + sizeof("msm8909-pm8916-snd-card"))) { + strlcpy(mixer_xml_path, MIXER_XML_PATH_MSM8909_PM8916, + sizeof(MIXER_XML_PATH_MSM8909_PM8916)); + 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, "msm8909-skue-snd-card", + sizeof("msm8909-skue-snd-card"))) { + strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUE, + sizeof(MIXER_XML_PATH_SKUE)); + 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-skul", + sizeof("msm8939-snd-card-skul"))) { + strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUL, + sizeof(MIXER_XML_PATH_SKUL)); + 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]); + + } +} + +void platform_set_echo_reference(void *platform, bool enable) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + + if (my_data->ec_ref_enabled) { + my_data->ec_ref_enabled = false; + ALOGD("%s: disabling echo-reference", __func__); + audio_route_reset_and_update_path(adev->audio_route, "echo-reference"); + } + + if (enable) { + my_data->ec_ref_enabled = true; + ALOGD("%s: enabling echo-reference", __func__); + audio_route_apply_and_update_path(adev->audio_route, "echo-reference"); + } + +} + +static struct csd_data *open_csd_client() +{ + struct csd_data *csd = calloc(1, sizeof(struct csd_data)); + if (!csd) { + ALOGE("failed to allocate csd_data mem"); + return NULL; + } + + csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW); + if (csd->csd_client == NULL) { + ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT); + goto error; + } else { + ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT); + + csd->deinit = (deinit_t)dlsym(csd->csd_client, + "csd_client_deinit"); + if (csd->deinit == NULL) { + ALOGE("%s: dlsym error %s for csd_client_deinit", __func__, + dlerror()); + goto error; + } + csd->disable_device = (disable_device_t)dlsym(csd->csd_client, + "csd_client_disable_device"); + if (csd->disable_device == NULL) { + ALOGE("%s: dlsym error %s for csd_client_disable_device", + __func__, dlerror()); + goto error; + } + csd->enable_device_config = (enable_device_config_t)dlsym(csd->csd_client, + "csd_client_enable_device_config"); + if (csd->enable_device_config == NULL) { + ALOGE("%s: dlsym error %s for csd_client_enable_device_config", + __func__, dlerror()); + goto error; + } + csd->enable_device = (enable_device_t)dlsym(csd->csd_client, + "csd_client_enable_device"); + if (csd->enable_device == NULL) { + ALOGE("%s: dlsym error %s for csd_client_enable_device", + __func__, dlerror()); + goto error; + } + csd->start_voice = (start_voice_t)dlsym(csd->csd_client, + "csd_client_start_voice"); + if (csd->start_voice == NULL) { + ALOGE("%s: dlsym error %s for csd_client_start_voice", + __func__, dlerror()); + goto error; + } + csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client, + "csd_client_stop_voice"); + if (csd->stop_voice == NULL) { + ALOGE("%s: dlsym error %s for csd_client_stop_voice", + __func__, dlerror()); + goto error; + } + csd->volume = (volume_t)dlsym(csd->csd_client, + "csd_client_volume"); + if (csd->volume == NULL) { + ALOGE("%s: dlsym error %s for csd_client_volume", + __func__, dlerror()); + goto error; + } + csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client, + "csd_client_mic_mute"); + if (csd->mic_mute == NULL) { + ALOGE("%s: dlsym error %s for csd_client_mic_mute", + __func__, dlerror()); + goto error; + } + csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client, + "csd_client_slow_talk"); + if (csd->slow_talk == NULL) { + ALOGE("%s: dlsym error %s for csd_client_slow_talk", + __func__, dlerror()); + goto error; + } + csd->start_playback = (start_playback_t)dlsym(csd->csd_client, + "csd_client_start_playback"); + if (csd->start_playback == NULL) { + ALOGE("%s: dlsym error %s for csd_client_start_playback", + __func__, dlerror()); + goto error; + } + csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client, + "csd_client_stop_playback"); + if (csd->stop_playback == NULL) { + ALOGE("%s: dlsym error %s for csd_client_stop_playback", + __func__, dlerror()); + goto error; + } + csd->set_lch = (set_lch_t)dlsym(csd->csd_client, "csd_client_set_lch"); + if (csd->set_lch == NULL) { + ALOGE("%s: dlsym error %s for csd_client_set_lch", + __func__, dlerror()); + /* Ignore the error as this is not mandatory function for + * basic voice call to work. + */ + } + csd->start_record = (start_record_t)dlsym(csd->csd_client, + "csd_client_start_record"); + if (csd->start_record == NULL) { + ALOGE("%s: dlsym error %s for csd_client_start_record", + __func__, dlerror()); + goto error; + } + csd->stop_record = (stop_record_t)dlsym(csd->csd_client, + "csd_client_stop_record"); + if (csd->stop_record == NULL) { + ALOGE("%s: dlsym error %s for csd_client_stop_record", + __func__, dlerror()); + goto error; + } + csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init"); + + if (csd->init == NULL) { + ALOGE("%s: dlsym error %s for csd_client_init", + __func__, dlerror()); + goto error; + } else { + csd->init(); + } + } + return csd; + +error: + free(csd); + csd = NULL; + return csd; +} + +void close_csd_client(struct csd_data *csd) +{ + if (csd != NULL) { + csd->deinit(); + dlclose(csd->csd_client); + free(csd); + csd = NULL; + } +} + +void get_cvd_version(char *cvd_version, struct audio_device *adev) +{ + struct mixer_ctl *ctl; + int count; + int ret = 0; + + ctl = mixer_get_ctl_by_name(adev->mixer, CVD_VERSION_MIXER_CTL); + if (!ctl) { + ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, CVD_VERSION_MIXER_CTL); + goto done; + } + mixer_ctl_update(ctl); + + count = mixer_ctl_get_num_values(ctl); + if (count > MAX_CVD_VERSION_STRING_SIZE) + count = MAX_CVD_VERSION_STRING_SIZE; + + ret = mixer_ctl_get_array(ctl, cvd_version, count); + if (ret != 0) { + ALOGE("%s: ERROR! mixer_ctl_get_array() failed to get CVD Version", __func__); + goto done; + } + +done: + return; +} + +static int hw_util_open(int card_no) +{ + int fd = -1; + char dev_name[256]; + + snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u", + card_no, WCD9XXX_CODEC_HWDEP_NODE); + ALOGD("%s Opening device %s\n", __func__, dev_name); + fd = open(dev_name, O_WRONLY); + if (fd < 0) { + ALOGE("%s: cannot open device '%s'\n", __func__, dev_name); + return fd; + } + ALOGD("%s success", __func__); + return fd; +} + +struct param_data { + int use_case; + int acdb_id; + int get_size; + int buff_size; + int data_size; + void *buff; +}; + +static int send_codec_cal(acdb_loader_get_calibration_t acdb_loader_get_calibration, int fd) +{ + int ret = 0, type; + + for (type = WCD9XXX_ANC_CAL; type < WCD9XXX_MAX_CAL; type++) { + struct wcdcal_ioctl_buffer codec_buffer; + struct param_data calib; + + if (!strcmp(cal_name_info[type], "mad_cal")) + calib.acdb_id = SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID; + calib.get_size = 1; + ret = acdb_loader_get_calibration(cal_name_info[type], sizeof(struct param_data), + &calib); + if (ret < 0) { + ALOGE("%s get_calibration failed\n", __func__); + return ret; + } + calib.get_size = 0; + calib.buff = malloc(calib.buff_size); + if(calib.buff == NULL) { + ALOGE("%s mem allocation for %d bytes for %s failed\n" + , __func__, calib.buff_size, cal_name_info[type]); + return -1; + } + ret = acdb_loader_get_calibration(cal_name_info[type], + sizeof(struct param_data), &calib); + if (ret < 0) { + ALOGE("%s get_calibration failed type=%s calib.size=%d\n" + , __func__, cal_name_info[type], codec_buffer.size); + free(calib.buff); + return ret; + } + codec_buffer.buffer = calib.buff; + codec_buffer.size = calib.data_size; + codec_buffer.cal_type = type; + if (ioctl(fd, SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE, &codec_buffer) < 0) + ALOGE("Failed to call ioctl for %s err=%d calib.size=%d", + cal_name_info[type], errno, codec_buffer.size); + ALOGD("%s cal sent for %s calib.size=%d" + , __func__, cal_name_info[type], codec_buffer.size); + free(calib.buff); + } + return ret; +} + +static void audio_hwdep_send_cal(struct platform_data *plat_data) +{ + int fd; + + fd = hw_util_open(plat_data->adev->snd_card); + if (fd == -1) { + ALOGE("%s error open\n", __func__); + return; + } + + acdb_loader_get_calibration = (acdb_loader_get_calibration_t) + dlsym(plat_data->acdb_handle, "acdb_loader_get_calibration"); + + if (acdb_loader_get_calibration == NULL) { + ALOGE("%s: ERROR. dlsym Error:%s acdb_loader_get_calibration", __func__, + dlerror()); + return; + } + if (send_codec_cal(acdb_loader_get_calibration, fd) < 0) + ALOGE("%s: Could not send anc cal", __FUNCTION__); +} + +void *platform_init(struct audio_device *adev) +{ + char platform[PROPERTY_VALUE_MAX]; + char baseband[PROPERTY_VALUE_MAX]; + char value[PROPERTY_VALUE_MAX]; + struct platform_data *my_data = NULL; + int retry_num = 0, snd_card_num = 0, key = 0; + const char *snd_card_name; + char mixer_xml_path[100],ffspEnable[PROPERTY_VALUE_MAX]; + char *cvd_version = NULL; + + my_data = calloc(1, sizeof(struct platform_data)); + if (!my_data) { + ALOGE("failed to allocate platform data"); + return NULL; + } + + while (snd_card_num < MAX_SND_CARD) { + adev->mixer = mixer_open(snd_card_num); + + while (!adev->mixer && retry_num < RETRY_NUMBER) { + usleep(RETRY_US); + adev->mixer = mixer_open(snd_card_num); + retry_num++; + } + + if (!adev->mixer) { + ALOGE("%s: Unable to open the mixer card: %d", __func__, + snd_card_num); + retry_num = 0; + snd_card_num++; + continue; + } + + snd_card_name = mixer_get_name(adev->mixer); + ALOGV("%s: snd_card_name: %s", __func__, snd_card_name); + + my_data->hw_info = hw_info_init(snd_card_name); + if (!my_data->hw_info) { + ALOGE("%s: Failed to init hardware info", __func__); + } else { + query_platform(snd_card_name, mixer_xml_path); + ALOGD("%s: mixer path file is %s", __func__, + mixer_xml_path); + if (audio_extn_read_xml(adev, snd_card_num, mixer_xml_path, + MIXER_XML_PATH_AUXPCM) == -ENOSYS) { + adev->audio_route = audio_route_init(snd_card_num, + mixer_xml_path); + } + if (!adev->audio_route) { + ALOGE("%s: Failed to init audio route controls, aborting.", + __func__); + free(my_data); + return NULL; + } + adev->snd_card = snd_card_num; + update_codec_type(snd_card_name); + ALOGD("%s: Opened sound card:%d", __func__, snd_card_num); + break; + } + retry_num = 0; + snd_card_num++; + } + + if (snd_card_num >= MAX_SND_CARD) { + ALOGE("%s: Unable to find correct sound card, aborting.", __func__); + free(my_data); + return NULL; + } + + my_data->adev = adev; + my_data->fluence_in_spkr_mode = false; + my_data->fluence_in_voice_call = false; + my_data->fluence_in_voice_rec = false; + my_data->fluence_in_audio_rec = false; + my_data->fluence_type = FLUENCE_NONE; + my_data->fluence_mode = FLUENCE_ENDFIRE; + my_data->slowtalk = false; + my_data->hd_voice = false; + + property_get("ro.qc.sdk.audio.fluencetype", my_data->fluence_cap, ""); + if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) { + my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC; + } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) { + my_data->fluence_type = FLUENCE_DUAL_MIC; + } else { + my_data->fluence_type = FLUENCE_NONE; + } + + if (my_data->fluence_type != FLUENCE_NONE) { + property_get("persist.audio.fluence.voicecall",value,""); + if (!strncmp("true", value, sizeof("true"))) { + my_data->fluence_in_voice_call = true; + } + + property_get("persist.audio.fluence.voicerec",value,""); + if (!strncmp("true", value, sizeof("true"))) { + my_data->fluence_in_voice_rec = true; + } + + property_get("persist.audio.fluence.audiorec",value,""); + if (!strncmp("true", value, sizeof("true"))) { + my_data->fluence_in_audio_rec = true; + } + + property_get("persist.audio.fluence.speaker",value,""); + if (!strncmp("true", value, sizeof("true"))) { + my_data->fluence_in_spkr_mode = true; + } + + property_get("persist.audio.fluence.mode",value,""); + if (!strncmp("broadside", value, sizeof("broadside"))) { + my_data->fluence_mode = FLUENCE_BROADSIDE; + } + } + property_get("persist.audio.FFSP.enable", ffspEnable, ""); + if (!strncmp("true", ffspEnable, sizeof("true"))) { + acdb_device_table[SND_DEVICE_OUT_SPEAKER] = 131; + acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = 131; + acdb_device_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 131; + acdb_device_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 131; + } + property_get("audio.ds1.metainfo.key",value,"0"); + key = atoi(value); + + my_data->voice_feature_set = VOICE_FEATURE_SET_DEFAULT; + my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW); + if (my_data->acdb_handle == NULL) { + ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER); + } else { + ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER); + my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle, + "acdb_loader_deallocate_ACDB"); + if (!my_data->acdb_deallocate) + ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s", + __func__, LIB_ACDB_LOADER); + + my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle, + "acdb_loader_send_audio_cal_v2"); + if (!my_data->acdb_send_audio_cal) + ALOGE("%s: Could not find the symbol acdb_send_audio_cal from %s", + __func__, LIB_ACDB_LOADER); + + my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle, + "acdb_loader_send_voice_cal"); + if (!my_data->acdb_send_voice_cal) + ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s", + __func__, LIB_ACDB_LOADER); + + my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle, + "acdb_loader_reload_vocvoltable"); + if (!my_data->acdb_reload_vocvoltable) + ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s", + __func__, LIB_ACDB_LOADER); + + my_data->acdb_get_default_app_type = (acdb_get_default_app_type_t)dlsym( + my_data->acdb_handle, + "acdb_loader_get_default_app_type"); + if (!my_data->acdb_get_default_app_type) + ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s", + __func__, LIB_ACDB_LOADER); + + my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle, + "acdb_loader_init_v2"); + if (my_data->acdb_init == NULL) { + ALOGE("%s: dlsym error %s for acdb_loader_init_v2", __func__, dlerror()); + goto acdb_init_fail; + } + + cvd_version = calloc(1, MAX_CVD_VERSION_STRING_SIZE); + if (!cvd_version) + ALOGE("Failed to allocate cvd version"); + else + get_cvd_version(cvd_version, adev); + + my_data->acdb_init(snd_card_name, cvd_version, key); + if (cvd_version) + free(cvd_version); + } + audio_extn_pm_vote(); + +acdb_init_fail: + /* Initialize ACDB ID's */ + platform_info_init(PLATFORM_INFO_XML_PATH); + + /* init usb */ + audio_extn_usb_init(adev); + /* update sound cards appropriately */ + audio_extn_usb_set_proxy_sound_card(adev->snd_card); + + /* Read one time ssr property */ + audio_extn_ssr_update_enabled(); + audio_extn_spkr_prot_init(adev); + + /* init dap hal */ + audio_extn_dap_hal_init(adev->snd_card); + + audio_extn_dolby_set_license(adev); + audio_hwdep_send_cal(my_data); + + return my_data; +} + +void platform_deinit(void *platform) +{ + struct platform_data *my_data = (struct platform_data *)platform; + + hw_info_deinit(my_data->hw_info); + close_csd_client(my_data->csd); + + free(platform); + /* deinit usb */ + audio_extn_usb_deinit(); + audio_extn_dap_hal_deinit(); +} + +const char *platform_get_snd_device_name(snd_device_t snd_device) +{ + if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) + return device_table[snd_device]; + else + return ""; +} + +int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device, + char *device_name) +{ + struct platform_data *my_data = (struct platform_data *)platform; + + if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) { + strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE); + hw_info_append_hw_type(my_data->hw_info, snd_device, device_name); + } else { + strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE); + return -EINVAL; + } + + return 0; +} + +void platform_add_backend_name(char *mixer_path, snd_device_t snd_device) +{ + if ((snd_device == SND_DEVICE_IN_BT_SCO_MIC) || + (snd_device == SND_DEVICE_IN_BT_SCO_MIC_NREC)) + strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH); + else if ((snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB) || + (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)) + 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) + strlcat(mixer_path, " speaker-and-hdmi", MIXER_PATH_MAX_LENGTH); + 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); +} + +int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type) +{ + int device_id = -1; + + if (is_external_codec && is_misc_usecase(usecase)) { + if (device_type == PCM_PLAYBACK) + device_id = pcm_device_table_of_ext_codec[usecase][0]; + else + device_id = pcm_device_table_of_ext_codec[usecase][1]; + } else { + if (device_type == PCM_PLAYBACK) + device_id = pcm_device_table[usecase][0]; + else + device_id = pcm_device_table[usecase][1]; + } + return device_id; +} + +int platform_get_snd_device_index(char *snd_device_index_name) +{ + int ret = 0; + int i; + + if (snd_device_index_name == NULL) { + ALOGE("%s: snd_device_index_name 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; + goto done; + } + } + ALOGE("%s: Could not find index for snd_device_index_name = %s", + __func__, snd_device_index_name); + ret = -ENODEV; +done: + return ret; +} + +int platform_set_fluence_type(void *platform, char *value) +{ + int ret = 0; + int fluence_type = FLUENCE_NONE; + int fluence_flag = NONE_FLAG; + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + + ALOGV("%s: fluence type:%d", __func__, my_data->fluence_type); + + /* only dual mic turn on and off is supported as of now through setparameters */ + if (!strncmp(AUDIO_PARAMETER_VALUE_DUALMIC,value, sizeof(AUDIO_PARAMETER_VALUE_DUALMIC))) { + if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro")) || + !strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) { + ALOGV("fluence dualmic feature enabled \n"); + fluence_type = FLUENCE_DUAL_MIC; + fluence_flag = DMIC_FLAG; + } else { + ALOGE("%s: Failed to set DUALMIC", __func__); + ret = -1; + goto done; + } + } else if (!strncmp(AUDIO_PARAMETER_KEY_NO_FLUENCE, value, sizeof(AUDIO_PARAMETER_KEY_NO_FLUENCE))) { + ALOGV("fluence disabled"); + fluence_type = FLUENCE_NONE; + } else { + ALOGE("Invalid fluence value : %s",value); + ret = -1; + goto done; + } + + if (fluence_type != my_data->fluence_type) { + ALOGV("%s: Updating fluence_type to :%d", __func__, fluence_type); + my_data->fluence_type = fluence_type; + adev->acdb_settings = (adev->acdb_settings & FLUENCE_MODE_CLEAR) | fluence_flag; + } +done: + return ret; +} + +int platform_get_fluence_type(void *platform, char *value, uint32_t len) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + + if (my_data->fluence_type == FLUENCE_QUAD_MIC) { + strlcpy(value, "quadmic", len); + } else if (my_data->fluence_type == FLUENCE_DUAL_MIC) { + strlcpy(value, "dualmic", len); + } else if (my_data->fluence_type == FLUENCE_NONE) { + strlcpy(value, "none", len); + } else + ret = -1; + + return ret; +} + +int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id) +{ + int ret = 0; + + if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) { + ALOGE("%s: Invalid snd_device = %d", + __func__, snd_device); + ret = -EINVAL; + goto done; + } + + acdb_device_table[snd_device] = acdb_id; +done: + return ret; +} + +int platform_get_default_app_type(void *platform) +{ + struct platform_data *my_data = (struct platform_data *)platform; + + if (my_data->acdb_get_default_app_type) + return my_data->acdb_get_default_app_type(); + else + return DEFAULT_APP_TYPE; +} + +int platform_get_snd_device_acdb_id(snd_device_t snd_device) +{ + if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) { + ALOGE("%s: Invalid snd_device = %d", __func__, snd_device); + return -EINVAL; + } + return acdb_device_table[snd_device]; +} + +int platform_send_audio_calibration(void *platform, struct audio_usecase *usecase, + int app_type, int sample_rate) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int acdb_dev_id, acdb_dev_type; + struct audio_device *adev = my_data->adev; + int snd_device = SND_DEVICE_OUT_SPEAKER; + + if (usecase->type == PCM_PLAYBACK) { + snd_device = usecase->out_snd_device; + if(usecase->id != USECASE_AUDIO_PLAYBACK_OFFLOAD) + app_type = APP_TYPE_SYSTEM_SOUNDS; + } else if ((usecase->type == PCM_HFP_CALL) || (usecase->type == PCM_CAPTURE)) { + snd_device = usecase->in_snd_device; + app_type = APP_TYPE_GENERAL_RECORDING; + } + + acdb_dev_id = acdb_device_table[snd_device]; + if (acdb_dev_id < 0) { + ALOGE("%s: Could not find acdb id for device(%d)", + __func__, snd_device); + return -EINVAL; + } + if (my_data->acdb_send_audio_cal) { + ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)", + __func__, snd_device, acdb_dev_id); + if (snd_device >= SND_DEVICE_OUT_BEGIN && + snd_device < SND_DEVICE_OUT_END) + acdb_dev_type = ACDB_DEV_TYPE_OUT; + else + acdb_dev_type = ACDB_DEV_TYPE_IN; + my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type, app_type, + sample_rate); + } + return 0; +} + +int platform_switch_voice_call_device_pre(void *platform) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int ret = 0; + + if (my_data->csd != NULL && + my_data->adev->mode == AUDIO_MODE_IN_CALL) { + /* This must be called before disabling mixer controls on APQ side */ + ret = my_data->csd->disable_device(); + if (ret < 0) { + ALOGE("%s: csd_client_disable_device, failed, error %d", + __func__, ret); + } + } + return ret; +} +int platform_switch_voice_call_enable_device_config(void *platform, + snd_device_t out_snd_device, + snd_device_t in_snd_device) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int acdb_rx_id, acdb_tx_id; + int ret = 0; + + acdb_rx_id = acdb_device_table[out_snd_device]; + acdb_tx_id = acdb_device_table[in_snd_device]; + + if (my_data->csd != NULL) { + if (acdb_rx_id > 0 && acdb_tx_id > 0) { + ret = my_data->csd->enable_device_config(acdb_rx_id, acdb_tx_id); + if (ret < 0) { + ALOGE("%s: csd_enable_device_config, failed, error %d", + __func__, ret); + } + } else { + ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, + acdb_rx_id, acdb_tx_id); + } + } + return ret; +} + + +int platform_switch_voice_call_device_post(void *platform, + snd_device_t out_snd_device, + snd_device_t in_snd_device) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int acdb_rx_id, acdb_tx_id; + + if (my_data->acdb_send_voice_cal == NULL) { + ALOGE("%s: dlsym error for acdb_send_voice_call", __func__); + } else { + acdb_rx_id = acdb_device_table[out_snd_device]; + acdb_tx_id = acdb_device_table[in_snd_device]; + + if (acdb_rx_id > 0 && acdb_tx_id > 0) + my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id); + else + ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, + acdb_rx_id, acdb_tx_id); + } + + return 0; +} + +int platform_switch_voice_call_usecase_route_post(void *platform, + snd_device_t out_snd_device, + snd_device_t in_snd_device) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int acdb_rx_id, acdb_tx_id; + int ret = 0; + + acdb_rx_id = acdb_device_table[out_snd_device]; + acdb_tx_id = acdb_device_table[in_snd_device]; + + if (my_data->csd != NULL) { + if (acdb_rx_id > 0 && acdb_tx_id > 0) { + ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id, + my_data->adev->acdb_settings); + if (ret < 0) { + ALOGE("%s: csd_enable_device, failed, error %d", + __func__, ret); + } + } else { + ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, + acdb_rx_id, acdb_tx_id); + } + } + return ret; +} + +int platform_start_voice_call(void *platform, uint32_t vsid) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int ret = 0; + + if (my_data->csd != NULL) { + ret = my_data->csd->start_voice(vsid); + if (ret < 0) { + ALOGE("%s: csd_start_voice error %d\n", __func__, ret); + } + } + return ret; +} + +int platform_stop_voice_call(void *platform, uint32_t vsid) +{ + struct platform_data *my_data = (struct platform_data *)platform; + int ret = 0; + + if (my_data->csd != NULL) { + ret = my_data->csd->stop_voice(vsid); + if (ret < 0) { + ALOGE("%s: csd_stop_voice error %d\n", __func__, ret); + } + } + return ret; +} + +int platform_get_sample_rate(void *platform __unused, uint32_t *rate __unused) +{ + return 0; +} + +int platform_set_voice_volume(void *platform, int volume) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *mixer_ctl_name = "Voice Rx Gain"; + int vol_index = 0, ret = 0; + uint32_t set_values[ ] = {0, + ALL_SESSION_VSID, + DEFAULT_VOLUME_RAMP_DURATION_MS}; + + // Voice volume levels are mapped to adsp volume levels as follows. + // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0 + // But this values don't changed in kernel. So, below change is need. + vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX); + set_values[0] = vol_index; + + 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; + } + ALOGV("Setting voice volume index: %d", set_values[0]); + mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); + + if (my_data->csd != NULL) { + ret = my_data->csd->volume(ALL_SESSION_VSID, volume); + if (ret < 0) { + ALOGE("%s: csd_volume error %d", __func__, ret); + } + } + return ret; +} + +int platform_set_mic_mute(void *platform, bool state) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *mixer_ctl_name = "Voice Tx Mute"; + int ret = 0; + uint32_t set_values[ ] = {0, + ALL_SESSION_VSID, + DEFAULT_VOLUME_RAMP_DURATION_MS}; + + set_values[0] = state; + 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; + } + ALOGV("Setting voice mute state: %d", state); + mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); + + if (my_data->csd != NULL) { + ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state); + if (ret < 0) { + ALOGE("%s: csd_mic_mute error %d", __func__, ret); + } + } + return ret; +} + +int platform_set_device_mute(void *platform, bool state, char *dir) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + char *mixer_ctl_name = NULL; + int ret = 0; + uint32_t set_values[ ] = {0, + ALL_SESSION_VSID, + 0}; + if(dir == NULL) { + ALOGE("%s: Invalid direction:%s", __func__, dir); + return -EINVAL; + } + + if (!strncmp("rx", dir, sizeof("rx"))) { + mixer_ctl_name = "Voice Rx Device Mute"; + } else if (!strncmp("tx", dir, sizeof("tx"))) { + mixer_ctl_name = "Voice Tx Device Mute"; + } else { + return -EINVAL; + } + + set_values[0] = state; + 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; + } + + ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s", + __func__,state, mixer_ctl_name); + mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); + + return ret; +} + +snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + audio_mode_t mode = adev->mode; + snd_device_t snd_device = SND_DEVICE_NONE; +#ifdef RECORD_PLAY_CONCURRENCY + bool use_voip_out_devices = false; + bool prop_rec_play_enabled = false; + char recConcPropValue[PROPERTY_VALUE_MAX]; + + if (property_get("rec.playback.conc.disabled", recConcPropValue, NULL)) { + prop_rec_play_enabled = atoi(recConcPropValue) || !strncmp("true", recConcPropValue, 4); + } + use_voip_out_devices = prop_rec_play_enabled && + (my_data->rec_play_conc_set || adev->mode == AUDIO_MODE_IN_COMMUNICATION); + ALOGV("platform_get_output_snd_device use_voip_out_devices : %d",use_voip_out_devices); +#endif + + audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? + AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; + int channel_count = popcount(channel_mask); + + ALOGV("%s: enter: output devices(%#x)", __func__, devices); + if (devices == AUDIO_DEVICE_NONE || + devices & AUDIO_DEVICE_BIT_IN) { + ALOGV("%s: Invalid output devices (%#x)", __func__, devices); + goto exit; + } + + if (popcount(devices) == 2) { + if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE | + AUDIO_DEVICE_OUT_SPEAKER)) { + snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; + } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET | + AUDIO_DEVICE_OUT_SPEAKER)) { + if (audio_extn_get_anc_enabled()) + snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET; + else + snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; + } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL | + AUDIO_DEVICE_OUT_SPEAKER)) { + snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI; + } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET | + AUDIO_DEVICE_OUT_SPEAKER)) { + snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET; + } else { + ALOGE("%s: Invalid combo device(%#x)", __func__, devices); + goto exit; + } + if (snd_device != SND_DEVICE_NONE) { + goto exit; + } + } + + if (popcount(devices) != 1) { + ALOGE("%s: Invalid output devices(%#x)", __func__, devices); + goto exit; + } + + if ((mode == AUDIO_MODE_IN_CALL) || + voice_extn_compress_voip_is_active(adev)) { + if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || + devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { + if ((adev->voice.tty_mode != TTY_MODE_OFF) && + !voice_extn_compress_voip_is_active(adev)) { + switch (adev->voice.tty_mode) { + case TTY_MODE_FULL: + snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES; + break; + case TTY_MODE_VCO: + snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES; + break; + case TTY_MODE_HCO: + snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET; + break; + default: + ALOGE("%s: Invalid TTY mode (%#x)", + __func__, adev->voice.tty_mode); + } + } else if (audio_extn_get_anc_enabled()) { + if (audio_extn_should_use_fb_anc()) + snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET; + else + snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET; + } else { + snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES; + } + } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { + if (adev->bt_wb_speech_enabled) + snd_device = SND_DEVICE_OUT_BT_SCO_WB; + else + snd_device = SND_DEVICE_OUT_BT_SCO; + } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { + snd_device = SND_DEVICE_OUT_VOICE_SPEAKER; + } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || + devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { + snd_device = SND_DEVICE_OUT_USB_HEADSET; + } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { + snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; + } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { + if (audio_extn_should_use_handset_anc(channel_count)) + snd_device = SND_DEVICE_OUT_ANC_HANDSET; + else + snd_device = SND_DEVICE_OUT_VOICE_HANDSET; + } + if (snd_device != SND_DEVICE_NONE) { + goto exit; + } + } + + if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || + devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { + if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET + && audio_extn_get_anc_enabled()) { +#ifdef RECORD_PLAY_CONCURRENCY + if (use_voip_out_devices) { + // ANC should be disabled for voip concurrency + snd_device = SND_DEVICE_OUT_VOIP_HEADPHONES; + } else +#endif + { + if (audio_extn_should_use_fb_anc()) + snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET; + else + snd_device = SND_DEVICE_OUT_ANC_HEADSET; + } + } else { +#ifdef RECORD_PLAY_CONCURRENCY + if (use_voip_out_devices) + snd_device = SND_DEVICE_OUT_VOIP_HEADPHONES; + else +#endif + snd_device = SND_DEVICE_OUT_HEADPHONES; + } + } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { +#ifdef RECORD_PLAY_CONCURRENCY + if (use_voip_out_devices) { + snd_device = SND_DEVICE_OUT_VOIP_SPEAKER; + } else +#endif + { + if (adev->speaker_lr_swap) + snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE; + else + snd_device = SND_DEVICE_OUT_SPEAKER; + } + } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { + if (adev->bt_wb_speech_enabled) + snd_device = SND_DEVICE_OUT_BT_SCO_WB; + else + snd_device = SND_DEVICE_OUT_BT_SCO; + } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { + snd_device = SND_DEVICE_OUT_HDMI ; + } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || + devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { + ALOGD("%s: setting USB hadset channel capability(2) for Proxy", __func__); + audio_extn_set_afe_proxy_channel_mixer(adev, 2); + snd_device = SND_DEVICE_OUT_USB_HEADSET; + } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { + snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; + } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { +#ifdef RECORD_PLAY_CONCURRENCY + if (use_voip_out_devices) + snd_device = SND_DEVICE_OUT_VOIP_HANDSET; + else +#endif + snd_device = SND_DEVICE_OUT_HANDSET; + } else if (devices & AUDIO_DEVICE_OUT_PROXY) { + channel_count = audio_extn_get_afe_proxy_channel_count(); + ALOGD("%s: setting sink capability(%d) for Proxy", __func__, channel_count); + audio_extn_set_afe_proxy_channel_mixer(adev, channel_count); + snd_device = SND_DEVICE_OUT_AFE_PROXY; + } else { + ALOGE("%s: Unknown device(s) %#x", __func__, devices); + } +exit: + ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]); + return snd_device; +} + +snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + audio_source_t source = (adev->active_input == NULL) ? + AUDIO_SOURCE_DEFAULT : adev->active_input->source; + + audio_mode_t mode = adev->mode; + audio_devices_t in_device = ((adev->active_input == NULL) ? + AUDIO_DEVICE_NONE : adev->active_input->device) + & ~AUDIO_DEVICE_BIT_IN; + audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? + AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; + snd_device_t snd_device = SND_DEVICE_NONE; + int channel_count = popcount(channel_mask); + + ALOGV("%s: enter: out_device(%#x) in_device(%#x)", + __func__, out_device, in_device); + if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) || + voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) { + if ((adev->voice.tty_mode != TTY_MODE_OFF) && + !voice_extn_compress_voip_is_active(adev)) { + if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || + out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { + switch (adev->voice.tty_mode) { + case TTY_MODE_FULL: + snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC; + break; + case TTY_MODE_VCO: + snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC; + break; + case TTY_MODE_HCO: + snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC; + break; + default: + ALOGE("%s: Invalid TTY mode (%#x)", + __func__, adev->voice.tty_mode); + } + goto exit; + } + } + if (out_device & AUDIO_DEVICE_OUT_EARPIECE || + out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { + if (out_device & AUDIO_DEVICE_OUT_EARPIECE && + audio_extn_should_use_handset_anc(channel_count) && + my_data->fluence_type != FLUENCE_NONE) { + snd_device = SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC; + adev->acdb_settings |= DMIC_FLAG; + ALOGD("Selecting AANC, Fluence combo device"); + } else if (out_device & AUDIO_DEVICE_OUT_EARPIECE && + audio_extn_should_use_handset_anc(channel_count)) { + snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC; + } else if (my_data->fluence_type == FLUENCE_NONE || + my_data->fluence_in_voice_call == false) { + snd_device = SND_DEVICE_IN_HANDSET_MIC; + if (audio_extn_hfp_is_active(adev)) + platform_set_echo_reference(adev->platform, true); + } else { + snd_device = SND_DEVICE_IN_VOICE_DMIC; + adev->acdb_settings |= DMIC_FLAG; + } + } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC; + if (audio_extn_hfp_is_active(adev)) + platform_set_echo_reference(adev->platform, true); + } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) { + if (adev->bt_wb_speech_enabled) { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; + } else { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC; + } + } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { + if (my_data->fluence_type != FLUENCE_NONE && + my_data->fluence_in_voice_call && + my_data->fluence_in_spkr_mode) { + if(my_data->fluence_type & FLUENCE_QUAD_MIC) { + adev->acdb_settings |= QMIC_FLAG; + snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC; + } else { + adev->acdb_settings |= DMIC_FLAG; + if (my_data->fluence_mode == FLUENCE_BROADSIDE) + snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE; + else + snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC; + } + } else { + snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC; + if (audio_extn_hfp_is_active(adev)) + platform_set_echo_reference(adev->platform, true); + } + } + } else if (source == AUDIO_SOURCE_CAMCORDER) { + if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC || + in_device & AUDIO_DEVICE_IN_BACK_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC && + channel_count == 2) + snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC; + else + snd_device = SND_DEVICE_IN_CAMCORDER_MIC; + } + } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) { + if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { + if (channel_count == 2) { + snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO; + adev->acdb_settings |= DMIC_FLAG; + } else if (adev->active_input->enable_ns) + snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS; + else if (my_data->fluence_type != FLUENCE_NONE && + my_data->fluence_in_voice_rec) { + snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE; + adev->acdb_settings |= DMIC_FLAG; + } else { + snd_device = SND_DEVICE_IN_VOICE_REC_MIC; + } + } + } else if ((source == AUDIO_SOURCE_VOICE_COMMUNICATION) || + (mode == AUDIO_MODE_IN_COMMUNICATION)) { + if (out_device & AUDIO_DEVICE_OUT_SPEAKER) + in_device = AUDIO_DEVICE_IN_BACK_MIC; + if (adev->active_input) { + if (adev->active_input->enable_aec && + adev->active_input->enable_ns) { + if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC && + my_data->fluence_in_spkr_mode) { + if (my_data->fluence_mode == FLUENCE_BROADSIDE) + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE; + else + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS; + } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC) { + snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS; + } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; + } + platform_set_echo_reference(adev->platform, true); + } else if (adev->active_input->enable_aec) { + if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC && + my_data->fluence_in_spkr_mode) { + if (my_data->fluence_mode == FLUENCE_BROADSIDE) + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE; + else + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC; + } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC) { + snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC; + } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; + } + platform_set_echo_reference(adev->platform, true); + } else if (adev->active_input->enable_ns) { + if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC && + my_data->fluence_in_spkr_mode) { + if (my_data->fluence_mode == FLUENCE_BROADSIDE) + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE; + else + snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS; + } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { + if (my_data->fluence_type & FLUENCE_DUAL_MIC) { + snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS; + adev->acdb_settings |= DMIC_FLAG; + } else + snd_device = SND_DEVICE_IN_HANDSET_MIC_NS; + } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; + } + platform_set_echo_reference(adev->platform,false); + } else + platform_set_echo_reference(adev->platform, false); + } + } else if (source == AUDIO_SOURCE_MIC) { + if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC && + channel_count == 1 ) { + if(my_data->fluence_type & FLUENCE_DUAL_MIC && + my_data->fluence_in_audio_rec) + snd_device = SND_DEVICE_IN_HANDSET_DMIC; + } + } else if (source == AUDIO_SOURCE_FM_RX || + source == AUDIO_SOURCE_FM_RX_A2DP) { + snd_device = SND_DEVICE_IN_CAPTURE_FM; + } else if (source == AUDIO_SOURCE_DEFAULT) { + goto exit; + } + + + if (snd_device != SND_DEVICE_NONE) { + goto exit; + } + + if (in_device != AUDIO_DEVICE_NONE && + !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) && + !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) { + if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { + if (audio_extn_ssr_get_enabled() && channel_count == 6) + snd_device = SND_DEVICE_IN_QUAD_MIC; + else if (channel_count == 2) + snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC; + else + snd_device = SND_DEVICE_IN_HANDSET_MIC; + } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { + snd_device = SND_DEVICE_IN_SPEAKER_MIC; + } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_HEADSET_MIC; + } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) { + if (adev->bt_wb_speech_enabled) { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; + } else { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC; + } + } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) { + snd_device = SND_DEVICE_IN_HDMI_MIC; + } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET || + in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) { + snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; + } else if (in_device & AUDIO_DEVICE_IN_FM_RX) { + snd_device = SND_DEVICE_IN_CAPTURE_FM; + } else { + ALOGE("%s: Unknown input device(s) %#x", __func__, in_device); + ALOGW("%s: Using default handset-mic", __func__); + snd_device = SND_DEVICE_IN_HANDSET_MIC; + } + } else { + if (out_device & AUDIO_DEVICE_OUT_EARPIECE) { + snd_device = SND_DEVICE_IN_HANDSET_MIC; + } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { + snd_device = SND_DEVICE_IN_HEADSET_MIC; + } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { + if (channel_count > 1) + snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC; + else + snd_device = SND_DEVICE_IN_SPEAKER_MIC; + } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { + snd_device = SND_DEVICE_IN_HANDSET_MIC; + } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) { + if (adev->bt_wb_speech_enabled) { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; + } else { + if (adev->bluetooth_nrec) + snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC; + else + snd_device = SND_DEVICE_IN_BT_SCO_MIC; + } + } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) { + snd_device = SND_DEVICE_IN_HDMI_MIC; + } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || + out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { + snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; + } else { + ALOGE("%s: Unknown output device(s) %#x", __func__, out_device); + ALOGW("%s: Using default handset-mic", __func__); + snd_device = SND_DEVICE_IN_HANDSET_MIC; + } + } +exit: + ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]); + return snd_device; +} + +int platform_set_hdmi_channels(void *platform, int channel_count) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *channel_cnt_str = NULL; + const char *mixer_ctl_name = "HDMI_RX Channels"; + switch (channel_count) { + case 8: + channel_cnt_str = "Eight"; break; + case 7: + channel_cnt_str = "Seven"; break; + case 6: + channel_cnt_str = "Six"; break; + case 5: + channel_cnt_str = "Five"; break; + case 4: + channel_cnt_str = "Four"; break; + case 3: + channel_cnt_str = "Three"; break; + default: + channel_cnt_str = "Two"; break; + } + 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; + } + ALOGV("HDMI channel count: %s", channel_cnt_str); + mixer_ctl_set_enum_by_string(ctl, channel_cnt_str); + return 0; +} + +int platform_edid_get_max_channels(void *platform) +{ + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE]; + char *sad = block; + int num_audio_blocks; + int channel_count; + int max_channels = 0; + int i, ret, count; + + struct mixer_ctl *ctl; + + ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL); + if (!ctl) { + ALOGE("%s: Could not get ctl for mixer cmd - %s", + __func__, AUDIO_DATA_BLOCK_MIXER_CTL); + return 0; + } + + mixer_ctl_update(ctl); + + count = mixer_ctl_get_num_values(ctl); + + /* Read SAD blocks, clamping the maximum size for safety */ + if (count > (int)sizeof(block)) + count = (int)sizeof(block); + + ret = mixer_ctl_get_array(ctl, block, count); + if (ret != 0) { + ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__); + return 0; + } + + /* Calculate the number of SAD blocks */ + num_audio_blocks = count / SAD_BLOCK_SIZE; + + for (i = 0; i < num_audio_blocks; i++) { + /* Only consider LPCM blocks */ + if ((sad[0] >> 3) != EDID_FORMAT_LPCM) { + sad += 3; + continue; + } + + channel_count = (sad[0] & 0x7) + 1; + if (channel_count > max_channels) + max_channels = channel_count; + + /* Advance to next block */ + sad += 3; + } + + return max_channels; +} + +static int platform_set_slowtalk(struct platform_data *my_data, bool state) +{ + int ret = 0; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *mixer_ctl_name = "Slowtalk Enable"; + uint32_t set_values[ ] = {0, + ALL_SESSION_VSID}; + + set_values[0] = state; + 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); + ret = -EINVAL; + } else { + ALOGV("Setting slowtalk state: %d", state); + ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); + my_data->slowtalk = state; + } + + if (my_data->csd != NULL) { + ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state); + if (ret < 0) { + ALOGE("%s: csd_client_disable_device, failed, error %d", + __func__, ret); + } + } + return ret; +} + +static int set_hd_voice(struct platform_data *my_data, bool state) +{ + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *mixer_ctl_name = "HD Voice Enable"; + int ret = 0; + uint32_t set_values[ ] = {0, + ALL_SESSION_VSID}; + + set_values[0] = state; + 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); + ret = -EINVAL; + } else { + ALOGV("Setting HD Voice state: %d", state); + ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); + my_data->hd_voice = state; + } + + return ret; +} + +int platform_set_parameters(void *platform, struct str_parms *parms) +{ + struct platform_data *my_data = (struct platform_data *)platform; + char *str; + char value[256] = {0}; + int val; + int ret = 0, err; + char *kv_pairs = NULL; + + kv_pairs = str_parms_to_str(parms); + ALOGV("%s: enter: - %s", __func__, kv_pairs); + free(kv_pairs); + + err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SLOWTALK, value, sizeof(value)); + if (err >= 0) { + bool state = false; + if (!strncmp("true", value, sizeof("true"))) { + state = true; + } + + str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK); + ret = platform_set_slowtalk(my_data, state); + if (ret) + ALOGE("%s: Failed to set slow talk err: %d", __func__, ret); + } + + err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HD_VOICE, value, sizeof(value)); + if (err >= 0) { + bool state = false; + if (!strncmp("true", value, sizeof("true"))) { + state = true; + } + + str_parms_del(parms, AUDIO_PARAMETER_KEY_HD_VOICE); + if (my_data->hd_voice != state) { + ret = set_hd_voice(my_data, state); + if (ret) + ALOGE("%s: Failed to set HD voice err: %d", __func__, ret); + } else { + ALOGV("%s: HD Voice already set to %d", __func__, state); + } + } + + err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST, + value, sizeof(value)); + if (err >= 0) { + str_parms_del(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST); + + if (my_data->acdb_reload_vocvoltable == NULL) { + ALOGE("%s: acdb_reload_vocvoltable is NULL", __func__); + } else if (!strcmp(value, "on")) { + if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_VOLUME_BOOST)) { + my_data->voice_feature_set = 1; + } + } else { + if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_DEFAULT)) { + my_data->voice_feature_set = 0; + } + } + } + +#ifdef RECORD_PLAY_CONCURRENCY + err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_REC_PLAY_CONC, value, sizeof(value)); + if (err >= 0) { + if (!strncmp("true", value, sizeof("true"))) { + ALOGD("setting record playback concurrency to true"); + my_data->rec_play_conc_set = true; + } else { + ALOGD("setting record playback concurrency to false"); + my_data->rec_play_conc_set = false; + } + } +#endif + ALOGV("%s: exit with code(%d)", __func__, ret); + return ret; +} + +int platform_set_incall_recording_session_id(void *platform, + uint32_t session_id, int rec_mode) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + struct audio_device *adev = my_data->adev; + struct mixer_ctl *ctl; + const char *mixer_ctl_name = "Voc VSID"; + int num_ctl_values; + int i; + + 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); + ret = -EINVAL; + } else { + num_ctl_values = mixer_ctl_get_num_values(ctl); + for (i = 0; i < num_ctl_values; i++) { + if (mixer_ctl_set_value(ctl, i, session_id)) { + ALOGV("Error: invalid session_id: %x", session_id); + ret = -EINVAL; + break; + } + } + } + + if (my_data->csd != NULL) { + ret = my_data->csd->start_record(ALL_SESSION_VSID, rec_mode); + if (ret < 0) { + ALOGE("%s: csd_client_start_record failed, error %d", + __func__, ret); + } + } + + return ret; +} + +int platform_stop_incall_recording_usecase(void *platform) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + + if (my_data->csd != NULL) { + ret = my_data->csd->stop_record(ALL_SESSION_VSID); + if (ret < 0) { + ALOGE("%s: csd_client_stop_record failed, error %d", + __func__, ret); + } + } + + return ret; +} + +int platform_start_incall_music_usecase(void *platform) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + + if (my_data->csd != NULL) { + ret = my_data->csd->start_playback(ALL_SESSION_VSID); + if (ret < 0) { + ALOGE("%s: csd_client_start_playback failed, error %d", + __func__, ret); + } + } + + return ret; +} + +int platform_stop_incall_music_usecase(void *platform) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + + if (my_data->csd != NULL) { + ret = my_data->csd->stop_playback(ALL_SESSION_VSID); + if (ret < 0) { + ALOGE("%s: csd_client_stop_playback failed, error %d", + __func__, ret); + } + } + + return ret; +} + +int platform_update_lch(void *platform, struct voice_session *session, + enum voice_lch_mode lch_mode) +{ + int ret = 0; + struct platform_data *my_data = (struct platform_data *)platform; + + if ((my_data->csd != NULL) && (my_data->csd->set_lch != NULL)) + ret = my_data->csd->set_lch(session->vsid, lch_mode); + else + ret = pcm_ioctl(session->pcm_tx, SNDRV_VOICE_IOCTL_LCH, &lch_mode); + + return ret; +} + +void platform_get_parameters(void *platform, + struct str_parms *query, + struct str_parms *reply) +{ + struct platform_data *my_data = (struct platform_data *)platform; + char *str = NULL; + char value[256] = {0}; + int ret; + char *kv_pairs = NULL; + + ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK, + value, sizeof(value)); + if (ret >= 0) { + str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SLOWTALK, + my_data->slowtalk?"true":"false"); + } + + ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_HD_VOICE, + value, sizeof(value)); + if (ret >= 0) { + str_parms_add_str(reply, AUDIO_PARAMETER_KEY_HD_VOICE, + my_data->hd_voice?"true":"false"); + } + + ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOLUME_BOOST, + value, sizeof(value)); + if (ret >= 0) { + if (my_data->voice_feature_set == VOICE_FEATURE_SET_VOLUME_BOOST) { + strlcpy(value, "on", sizeof(value)); + } else { + strlcpy(value, "off", sizeof(value)); + } + + str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value); + } + + kv_pairs = str_parms_to_str(reply); + ALOGV("%s: exit: returns - %s", __func__, kv_pairs); + free(kv_pairs); +} + +/* Delay in Us */ +int64_t platform_render_latency(audio_usecase_t usecase) +{ + switch (usecase) { + case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER: + return DEEP_BUFFER_PLATFORM_DELAY; + case USECASE_AUDIO_PLAYBACK_LOW_LATENCY: + return LOW_LATENCY_PLATFORM_DELAY; + default: + return 0; + } +} + +int platform_update_usecase_from_source(int source, int usecase) +{ + ALOGV("%s: input source :%d", __func__, source); + if(source == AUDIO_SOURCE_FM_RX_A2DP) + usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL; + return usecase; +} + +bool platform_listen_device_needs_event(snd_device_t snd_device) +{ + bool needs_event = false; + + if ((snd_device >= SND_DEVICE_IN_BEGIN) && + (snd_device < SND_DEVICE_IN_END) && + (snd_device != SND_DEVICE_IN_CAPTURE_FM) && + (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)) + needs_event = true; + + return needs_event; +} + +bool platform_listen_usecase_needs_event(audio_usecase_t uc_id) +{ + bool needs_event = false; + + switch(uc_id){ + /* concurrent playback usecases needs event */ + case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER: + case USECASE_AUDIO_PLAYBACK_MULTI_CH: + case USECASE_AUDIO_PLAYBACK_OFFLOAD: + needs_event = true; + break; + /* concurrent playback in low latency allowed */ + case USECASE_AUDIO_PLAYBACK_LOW_LATENCY: + break; + /* concurrent playback FM needs event */ + case USECASE_AUDIO_PLAYBACK_FM: + needs_event = true; + break; + + /* concurrent capture usecases, no event, capture handled by device + * USECASE_AUDIO_RECORD: + * USECASE_AUDIO_RECORD_COMPRESS: + * USECASE_AUDIO_RECORD_LOW_LATENCY: + + * USECASE_VOICE_CALL: + * USECASE_VOICE2_CALL: + * USECASE_VOLTE_CALL: + * USECASE_QCHAT_CALL: + * USECASE_VOWLAN_CALL: + * USECASE_COMPRESS_VOIP_CALL: + * USECASE_AUDIO_RECORD_FM_VIRTUAL: + * USECASE_INCALL_REC_UPLINK: + * USECASE_INCALL_REC_DOWNLINK: + * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK: + * USECASE_INCALL_REC_UPLINK_COMPRESS: + * USECASE_INCALL_REC_DOWNLINK_COMPRESS: + * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS: + * USECASE_INCALL_MUSIC_UPLINK: + * USECASE_INCALL_MUSIC_UPLINK2: + * USECASE_AUDIO_SPKR_CALIB_RX: + * USECASE_AUDIO_SPKR_CALIB_TX: + */ + default: + ALOGV("%s:usecase_id[%d} no need to raise event.", __func__, uc_id); + } + return needs_event; +} + +bool platform_sound_trigger_device_needs_event(snd_device_t snd_device) +{ + bool needs_event = false; + + if ((snd_device >= SND_DEVICE_IN_BEGIN) && + (snd_device < SND_DEVICE_IN_END) && + (snd_device != SND_DEVICE_IN_CAPTURE_FM) && + (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)) + needs_event = true; + + return needs_event; +} + +bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id) +{ + bool needs_event = false; + + switch(uc_id){ + /* concurrent playback usecases needs event */ + case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER: + case USECASE_AUDIO_PLAYBACK_MULTI_CH: + case USECASE_AUDIO_PLAYBACK_OFFLOAD: + needs_event = true; + break; + /* concurrent playback in low latency allowed */ + case USECASE_AUDIO_PLAYBACK_LOW_LATENCY: + break; + /* concurrent playback FM needs event */ + case USECASE_AUDIO_PLAYBACK_FM: + needs_event = true; + break; + + /* concurrent capture usecases, no event, capture handled by device + * USECASE_AUDIO_RECORD: + * USECASE_AUDIO_RECORD_COMPRESS: + * USECASE_AUDIO_RECORD_LOW_LATENCY: + + * USECASE_VOICE_CALL: + * USECASE_VOICE2_CALL: + * USECASE_VOLTE_CALL: + * USECASE_QCHAT_CALL: + * USECASE_VOWLAN_CALL: + * USECASE_COMPRESS_VOIP_CALL: + * USECASE_AUDIO_RECORD_FM_VIRTUAL: + * USECASE_INCALL_REC_UPLINK: + * USECASE_INCALL_REC_DOWNLINK: + * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK: + * USECASE_INCALL_REC_UPLINK_COMPRESS: + * USECASE_INCALL_REC_DOWNLINK_COMPRESS: + * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS: + * USECASE_INCALL_MUSIC_UPLINK: + * USECASE_INCALL_MUSIC_UPLINK2: + * USECASE_AUDIO_SPKR_CALIB_RX: + * USECASE_AUDIO_SPKR_CALIB_TX: + */ + default: + ALOGV("%s:usecase_id[%d] no need to raise event.", __func__, uc_id); + } + return needs_event; +} + +/* Read offload buffer size from a property. + * If value is not power of 2 round it to + * power of 2. + */ +uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info) +{ + char value[PROPERTY_VALUE_MAX] = {0}; + uint32_t fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE; + if((property_get("audio.offload.buffer.size.kb", value, "")) && + atoi(value)) { + fragment_size = atoi(value) * 1024; + } + + if (info != NULL && info->has_video && 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); + } + + fragment_size = ALIGN( fragment_size, 1024); + + if(fragment_size < MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE) + fragment_size = MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE; + else if(fragment_size > MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE) + fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE; + ALOGV("%s: fragment_size %d", __func__, fragment_size); + return fragment_size; +} + +uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info) +{ + uint32_t fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE; + uint32_t bits_per_sample = 16; + + if (info->format == AUDIO_FORMAT_PCM_24_BIT_OFFLOAD) { + bits_per_sample = 32; + } + + if (!info->has_video) { + fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE; + + } else if (info->has_video && info->is_streaming) { + fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING + * info->sample_rate + * bits_per_sample + * popcount(info->channel_mask))/1000; + + } else if (info->has_video) { + fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV + * info->sample_rate + * bits_per_sample + * popcount(info->channel_mask))/1000; + } + + fragment_size = ALIGN( fragment_size, 1024); + + if(fragment_size < MIN_PCM_OFFLOAD_FRAGMENT_SIZE) + fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE; + else if(fragment_size > MAX_PCM_OFFLOAD_FRAGMENT_SIZE) + fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE; + + ALOGV("%s: fragment_size %d", __func__, fragment_size); + 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) +{ + 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; +} + +int platform_get_subsys_image_name(char *buf) +{ + strlcpy(buf, PLATFORM_IMAGE_NAME, sizeof(PLATFORM_IMAGE_NAME)); + return 0; +} |