Gitiles
Code Review Sign In
review.blissroms.org / platform_hardware_qcom_audio / 70e5761630b6bbe339227f2f3baffa059da2109e / . / hal / msm8974 / platform.c
blob: 17269fd920f34bb2426f1aca7964230146fe1027 [file] [log] [blame]
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1/*
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2 * Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]3 * Not a Contribution.
4 *
Shiv Maliyappanahalli8911f282014-01-10 15:56:19 -0800[diff] [blame]5 * Copyright (C) 2013 The Android Open Source Project
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20#define LOG_TAG "msm8974_platform"
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]21//#define LOG_NDEBUG 0
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]22#define LOG_NDDEBUG 0
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]23/*#define VERY_VERY_VERBOSE_LOGGING*/
24#ifdef VERY_VERY_VERBOSE_LOGGING
25#define ALOGVV ALOGV
26#else
27#define ALOGVV(a...) do { } while(0)
28#endif
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]29
30#include <stdlib.h>
31#include <dlfcn.h>
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]32#include <fcntl.h>
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]33#include <sys/ioctl.h>
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]34#include <log/log.h>
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]35#include <cutils/properties.h>
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]36#include <cutils/str_parms.h>
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]37#include <audio_hw.h>
38#include <platform_api.h>
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]39#include <pthread.h>
Vinay Vermaaddfa4a2018-04-29 14:03:38 +0530[diff] [blame]40#include <unistd.h>
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]41#include "platform.h"
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]42#include "audio_extn.h"
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]43#include "acdb.h"
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]44#include "voice_extn.h"
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]45#include "edid.h"
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]46#include "sound/compress_params.h"
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]47#include "sound/msmcal-hwdep.h"
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]48
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]49#ifdef DYNAMIC_LOG_ENABLED
50#include <log_xml_parser.h>
51#define LOG_MASK HAL_MOD_FILE_PLATFORM
52#include <log_utils.h>
53#endif
54
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]55#define SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID (100)
Apoorv Raghuvanshia433fb52015-03-16 15:22:30 -0700[diff] [blame]56#define MIXER_FILE_DELIMITER "_"
57#define MIXER_FILE_EXT ".xml"
58
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]59#define MIXER_XML_BASE_STRING "mixer_paths"
60#define MIXER_XML_DEFAULT_PATH "mixer_paths.xml"
61
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]62#ifdef LINUX_ENABLED
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]63#define PLATFORM_INFO_XML_PATH_INTCODEC "/etc/audio_platform_info_intcodec.xml"
64#define PLATFORM_INFO_XML_PATH_SKUSH "/etc/audio_platform_info_skush.xml"
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]65#define PLATFORM_INFO_XML_PATH_SKUW "/etc/audio_platform_info_skuw.xml"
kunleiz291f3412018-09-04 16:04:44 +0800[diff] [blame]66#define PLATFORM_INFO_XML_PATH_QRD "/etc/audio_platform_info_qrd.xml"
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]67#define PLATFORM_INFO_XML_PATH "/etc/audio_platform_info.xml"
68#define MIXER_XML_PATH_AUXPCM "/etc/mixer_paths_auxpcm.xml"
69#define MIXER_XML_PATH_I2S "/etc/mixer_paths_i2s.xml"
Josh Kirschf6932f72017-12-12 11:31:01 -0800[diff] [blame]70#define PLATFORM_INFO_XML_PATH_I2S "/etc/audio_platform_info_extcodec.xml"
Ramu Gottipati54ed9482018-08-21 16:00:22 +0530[diff] [blame]71#define PLATFORM_INFO_XML_PATH_WSA "/etc/audio_platform_info_wsa.xml"
Dhananjay Kumarb34c5c12018-09-25 16:04:26 +0530[diff] [blame]72#define PLATFORM_INFO_XML_PATH_TDM "/etc/audio_platform_info_tdm.xml"
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]73#else
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]74#define PLATFORM_INFO_XML_PATH_INTCODEC "/vendor/etc/audio_platform_info_intcodec.xml"
75#define PLATFORM_INFO_XML_PATH_SKUSH "/vendor/etc/audio_platform_info_skush.xml"
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]76#define PLATFORM_INFO_XML_PATH_SKUW "/vendor/etc/audio_platform_info_skuw.xml"
kunleiz291f3412018-09-04 16:04:44 +0800[diff] [blame]77#define PLATFORM_INFO_XML_PATH_QRD "/vendor/etc/audio_platform_info_qrd.xml"
Naresh Tanniru10758b62017-06-05 21:05:53 +0530[diff] [blame]78#define PLATFORM_INFO_XML_PATH "/vendor/etc/audio_platform_info.xml"
79#define MIXER_XML_PATH_AUXPCM "/vendor/etc/mixer_paths_auxpcm.xml"
80#define MIXER_XML_PATH_I2S "/vendor/etc/mixer_paths_i2s.xml"
81#define PLATFORM_INFO_XML_PATH_I2S "/vendor/etc/audio_platform_info_i2s.xml"
Ramu Gottipati54ed9482018-08-21 16:00:22 +0530[diff] [blame]82#define PLATFORM_INFO_XML_PATH_WSA "/vendor/etc/audio_platform_info_wsa.xml"
Dhananjay Kumarb34c5c12018-09-25 16:04:26 +0530[diff] [blame]83#define PLATFORM_INFO_XML_PATH_TDM "/vendor/etc/audio_platform_info_tdm.xml"
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]84#endif
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]85
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]86#include <linux/msm_audio.h>
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]87#if defined (PLATFORM_MSM8998) || (PLATFORM_SDM845) || (PLATFORM_SDM710) || \
88 defined (PLATFORM_QCS605) || defined (PLATFORM_MSMNILE) || \
89 defined (PLATFORM_KONA) || defined (PLATFORM_MSMSTEPPE) || \
90 defined (PLATFORM_QCS405)
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]91#include <sound/devdep_params.h>
92#endif
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]93
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]94#include <resolv.h>
95
96#define min(a, b) ((a) < (b) ? (a) : (b))
97
98#define TOSTRING_(x) #x
99#define TOSTRING(x) TOSTRING_(x)
100
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]101#define LIB_ACDB_LOADER "libacdbloader.so"
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]102#define CVD_VERSION_MIXER_CTL "CVD Version"
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]103
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]104#define FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)
105#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024 * 1024)
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]106#define MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024)
107#define COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING (2 * 1024)
108#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
109
Vikram Panduranga7e784962016-10-27 12:32:30 -0700[diff] [blame]110
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]111/*
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]112 * This file will have a maximum of 38 bytes:
113 *
114 * 4 bytes: number of audio blocks
115 * 4 bytes: total length of Short Audio Descriptor (SAD) blocks
116 * Maximum 10 * 3 bytes: SAD blocks
117 */
118#define MAX_SAD_BLOCKS 10
119#define SAD_BLOCK_SIZE 3
120
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]121#define MAX_CVD_VERSION_STRING_SIZE 100
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]122#define MAX_SND_CARD_STRING_SIZE 100
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]123
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]124/* EDID format ID for LPCM audio */
125#define EDID_FORMAT_LPCM 1
126
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]127/* fallback app type if the default app type from acdb loader fails */
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]128#define DEFAULT_APP_TYPE_RX_PATH 69936
129#define DEFAULT_APP_TYPE_TX_PATH 69938
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]130
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]131#define SAMPLE_RATE_8KHZ 8000
132#define SAMPLE_RATE_16KHZ 16000
133
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]134#define MAX_SET_CAL_BYTE_SIZE 65536
135
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]136/* Mixer path names */
137#define AFE_SIDETONE_MIXER_PATH "afe-sidetone"
138
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]139#define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable"
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]140#define AUDIO_PARAMETER_KEY_HD_VOICE "hd_voice"
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]141#define AUDIO_PARAMETER_KEY_VOLUME_BOOST "volume_boost"
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]142#define AUDIO_PARAMETER_KEY_AUD_CALDATA "cal_data"
143#define AUDIO_PARAMETER_KEY_AUD_CALRESULT "cal_result"
144
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]145#define AUDIO_PARAMETER_KEY_MONO_SPEAKER "mono_speaker"
146
Jhansi Konathala170875c2018-10-11 18:34:10 +0530[diff] [blame]147#define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence_type"
148#define AUDIO_PARAMETER_KEY_FLUENCE_VOICE_CALL "fluence_voice"
149#define AUDIO_PARAMETER_KEY_FLUENCE_VOICE_REC "fluence_voice_rec"
150#define AUDIO_PARAMETER_KEY_FLUENCE_AUDIO_REC "fluence_audio_rec"
151#define AUDIO_PARAMETER_KEY_FLUENCE_SPEAKER "fluence_speaker"
152#define AUDIO_PARAMETER_KEY_FLUENCE_MODE "fluence_mode"
153#define AUDIO_PARAMETER_KEY_FLUENCE_HFPCALL "fluence_hfp"
154#define AUDIO_PARAMETER_KEY_FLUENCE_TRI_MIC "fluence_tri_mic"
155
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]156#define AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS "perf_lock_opts"
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]157
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]158/* Reload ACDB files from specified path */
159#define AUDIO_PARAMETER_KEY_RELOAD_ACDB "reload_acdb"
160
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]161/* Query external audio device connection status */
162#define AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE "ext_audio_device"
163
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]164/* Query whether it is ok to select display-port as output
165 * device for voice usecase
166 */
167#define AUDIO_PARAMETER_KEY_DP_FOR_VOICE_USECASE "dp_for_voice"
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]168#define AUDIO_PARAMETER_KEY_DP_CHANNEL_MASK "dp_channel_mask"
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]169#define AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP "spkr_device_chmap"
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]170
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]171#define EVENT_EXTERNAL_SPK_1 "qc_ext_spk_1"
172#define EVENT_EXTERNAL_SPK_2 "qc_ext_spk_2"
173#define EVENT_EXTERNAL_MIC "qc_ext_mic"
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]174#define MAX_CAL_NAME 20
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]175#define MAX_MIME_TYPE_LENGTH 30
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]176
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]177#define GET_IN_DEVICE_INDEX(SND_DEVICE) ((SND_DEVICE) - (SND_DEVICE_IN_BEGIN))
178
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]179#ifdef DYNAMIC_LOG_ENABLED
180extern void log_utils_init(void);
181extern void log_utils_deinit(void);
182#endif
183
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]184char cal_name_info[WCD9XXX_MAX_CAL][MAX_CAL_NAME] = {
185 [WCD9XXX_ANC_CAL] = "anc_cal",
186 [WCD9XXX_MBHC_CAL] = "mbhc_cal",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]187 [WCD9XXX_VBAT_CAL] = "vbat_cal",
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]188};
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]189static char *default_rx_backend = NULL;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]190
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]191#define AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED "is_hw_dec_session_allowed"
192
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]193char dsp_only_decoders_mime[][MAX_MIME_TYPE_LENGTH] = {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]194 "audio/x-ms-wma" /* wma*/ ,
195 "audio/x-ms-wma-lossless" /* wma lossless */ ,
196 "audio/x-ms-wma-pro" /* wma prop */ ,
197 "audio/amr-wb-plus" /* amr wb plus */ ,
198 "audio/alac" /*alac */ ,
199 "audio/x-ape" /*ape */,
200};
201
202
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]203enum {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]204 VOICE_FEATURE_SET_DEFAULT,
205 VOICE_FEATURE_SET_VOLUME_BOOST
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]206};
sangwoo53b2cf02013-07-25 19:18:44 -0700[diff] [blame]207
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]208struct audio_block_header
209{
210 int reserved;
211 int length;
212};
213
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]214enum {
215 CAL_MODE_SEND = 0x1,
216 CAL_MODE_PERSIST = 0x2,
217 CAL_MODE_RTAC = 0x4
218};
219
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]220#define PLATFORM_CONFIG_KEY_OPERATOR_INFO "operator_info"
221
222struct operator_info {
223 struct listnode list;
224 char *name;
225 char *mccmnc;
226};
227
228struct operator_specific_device {
229 struct listnode list;
230 char *operator;
231 char *mixer_path;
232 int acdb_id;
233};
234
235static struct listnode operator_info_list;
236static struct listnode *operator_specific_device_table[SND_DEVICE_MAX];
237
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]238acdb_loader_get_calibration_t acdb_loader_get_calibration;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]239
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]240typedef struct codec_backend_cfg {
241 uint32_t sample_rate;
242 uint32_t bit_width;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]243 uint32_t channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]244 uint32_t format;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]245 char *bitwidth_mixer_ctl;
246 char *samplerate_mixer_ctl;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]247 char *channels_mixer_ctl;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]248} codec_backend_cfg_t;
249
Ashish Jain4826f6c2017-02-06 13:33:20 +0530[diff] [blame]250static native_audio_prop na_props = {0, 0, NATIVE_AUDIO_MODE_INVALID};
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]251static bool supports_true_32_bit = false;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]252
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]253static int max_be_dai_names = 0;
254static const struct be_dai_name_struct *be_dai_name_table;
255
Naresh Tannirudcb47c52018-06-25 16:23:32 +0530[diff] [blame]256struct snd_device_to_mic_map {
257 struct mic_info microphones[AUDIO_MICROPHONE_MAX_COUNT];
258 size_t mic_count;
259};
260
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]261struct platform_data {
262 struct audio_device *adev;
263 bool fluence_in_spkr_mode;
264 bool fluence_in_voice_call;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]265 bool fluence_in_voice_comm;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]266 bool fluence_in_voice_rec;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]267 bool fluence_in_audio_rec;
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]268 bool fluence_in_hfp_call;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]269 bool external_spk_1;
270 bool external_spk_2;
271 bool external_mic;
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]272 bool speaker_lr_swap;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]273 int fluence_type;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]274 int fluence_mode;
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]275 char fluence_cap[PROPERTY_VALUE_MAX];
Sachin Mohan Gadagbe2054d2018-01-29 16:05:05 +0530[diff] [blame]276 bool ambisonic_capture;
277 bool ambisonic_profile;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]278 bool slowtalk;
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]279 bool hd_voice;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]280 bool ec_ref_enabled;
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]281 bool is_i2s_ext_modem;
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]282 bool is_acdb_initialized;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]283 /* Vbat monitor related flags */
284 bool is_vbat_speaker;
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]285 bool is_bcl_speaker;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]286 bool gsm_mode_enabled;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]287 bool is_slimbus_interface;
288 bool is_internal_codec;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]289 int mono_speaker;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]290 bool voice_speaker_stereo;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]291 /* Audio calibration related functions */
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]292 void *acdb_handle;
293 int voice_feature_set;
294 acdb_init_t acdb_init;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]295 acdb_init_v3_t acdb_init_v3;
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]296 acdb_init_v4_t acdb_init_v4;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]297 acdb_deallocate_t acdb_deallocate;
298 acdb_send_audio_cal_t acdb_send_audio_cal;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]299 acdb_send_audio_cal_v3_t acdb_send_audio_cal_v3;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]300 acdb_set_audio_cal_t acdb_set_audio_cal;
301 acdb_get_audio_cal_t acdb_get_audio_cal;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]302 acdb_send_voice_cal_t acdb_send_voice_cal;
303 acdb_reload_vocvoltable_t acdb_reload_vocvoltable;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]304 acdb_get_default_app_type_t acdb_get_default_app_type;
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]305 acdb_send_common_top_t acdb_send_common_top;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]306 acdb_set_codec_data_t acdb_set_codec_data;
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]307 acdb_reload_t acdb_reload;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]308 acdb_reload_v2_t acdb_reload_v2;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]309 void *hw_info;
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]310 acdb_send_gain_dep_cal_t acdb_send_gain_dep_cal;
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]311 struct csd_data *csd;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]312 void *edid_info;
313 bool edid_valid;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]314 int ext_disp_type;
kunleize96916e2018-07-16 16:25:59 +0800[diff] [blame]315 char ec_ref_mixer_path[MIXER_PATH_MAX_LENGTH];
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]316 codec_backend_cfg_t current_backend_cfg[MAX_CODEC_BACKENDS];
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]317 char codec_version[CODEC_VERSION_MAX_LENGTH];
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]318 int hw_dep_fd;
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]319 char cvd_version[MAX_CVD_VERSION_STRING_SIZE];
320 char snd_card_name[MAX_SND_CARD_STRING_SIZE];
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]321 int max_vol_index;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]322 int source_mic_type;
323 int max_mic_count;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]324 bool is_dsd_supported;
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530[diff] [blame]325 bool is_asrc_supported;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]326 struct listnode acdb_meta_key_list;
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]327 bool use_generic_handset;
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]328 struct acdb_init_data_v4 acdb_init_data;
Naresh Tannirudcb47c52018-06-25 16:23:32 +0530[diff] [blame]329 uint32_t declared_mic_count;
330 struct audio_microphone_characteristic_t microphones[AUDIO_MICROPHONE_MAX_COUNT];
331 struct snd_device_to_mic_map mic_map[SND_DEVICE_MAX];
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]332 struct spkr_device_chmap *spkr_ch_map;
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]333 bool use_sprk_default_sample_rate;
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]334};
Naresh Tannirudcb47c52018-06-25 16:23:32 +0530[diff] [blame]335
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]336struct spkr_device_chmap {
337 int num_ch;
338 char chmap[AUDIO_CHANNEL_COUNT_MAX];
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]339};
340
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]341static int pcm_device_table[AUDIO_USECASE_MAX][2] = {
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]342 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE,
343 DEEP_BUFFER_PCM_DEVICE},
344 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]345 LOWLATENCY_PCM_DEVICE},
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]346 [USECASE_AUDIO_PLAYBACK_ULL] = {MULTIMEDIA3_PCM_DEVICE,
347 MULTIMEDIA3_PCM_DEVICE},
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]348 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE,
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]349 MULTIMEDIA2_PCM_DEVICE},
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700[diff] [blame]350 [USECASE_AUDIO_PLAYBACK_HIFI] = {MULTIMEDIA2_PCM_DEVICE,
351 MULTIMEDIA2_PCM_DEVICE},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]352 [USECASE_AUDIO_PLAYBACK_TTS] = {MULTIMEDIA2_PCM_DEVICE,
353 MULTIMEDIA2_PCM_DEVICE},
Krishnankutty Kolathappillya43f96e2013-11-01 12:17:53 -0700[diff] [blame]354 [USECASE_AUDIO_PLAYBACK_OFFLOAD] =
355 {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE},
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700[diff] [blame]356 [USECASE_AUDIO_PLAYBACK_OFFLOAD2] =
357 {PLAYBACK_OFFLOAD_DEVICE2, PLAYBACK_OFFLOAD_DEVICE2},
358 [USECASE_AUDIO_PLAYBACK_OFFLOAD3] =
359 {PLAYBACK_OFFLOAD_DEVICE3, PLAYBACK_OFFLOAD_DEVICE3},
360 [USECASE_AUDIO_PLAYBACK_OFFLOAD4] =
361 {PLAYBACK_OFFLOAD_DEVICE4, PLAYBACK_OFFLOAD_DEVICE4},
362 [USECASE_AUDIO_PLAYBACK_OFFLOAD5] =
363 {PLAYBACK_OFFLOAD_DEVICE5, PLAYBACK_OFFLOAD_DEVICE5},
364 [USECASE_AUDIO_PLAYBACK_OFFLOAD6] =
365 {PLAYBACK_OFFLOAD_DEVICE6, PLAYBACK_OFFLOAD_DEVICE6},
366 [USECASE_AUDIO_PLAYBACK_OFFLOAD7] =
367 {PLAYBACK_OFFLOAD_DEVICE7, PLAYBACK_OFFLOAD_DEVICE7},
368 [USECASE_AUDIO_PLAYBACK_OFFLOAD8] =
369 {PLAYBACK_OFFLOAD_DEVICE8, PLAYBACK_OFFLOAD_DEVICE8},
370 [USECASE_AUDIO_PLAYBACK_OFFLOAD9] =
371 {PLAYBACK_OFFLOAD_DEVICE9, PLAYBACK_OFFLOAD_DEVICE9},
vivek mehta0ea887a2015-08-26 14:01:20 -0700[diff] [blame]372
vivek mehta0ea887a2015-08-26 14:01:20 -0700[diff] [blame]373
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]374 [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE},
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]375 [USECASE_AUDIO_RECORD_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, COMPRESS_CAPTURE_DEVICE},
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530[diff] [blame]376 [USECASE_AUDIO_RECORD_COMPRESS2] = {-1, -1},
377 [USECASE_AUDIO_RECORD_COMPRESS3] = {-1, -1},
378 [USECASE_AUDIO_RECORD_COMPRESS4] = {-1, -1},
Dhananjay Kumar376e38b2017-09-28 22:26:23 +0530[diff] [blame]379 [USECASE_AUDIO_RECORD_COMPRESS5] = {-1, -1},
380 [USECASE_AUDIO_RECORD_COMPRESS6] = {-1, -1},
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]381 [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
382 LOWLATENCY_PCM_DEVICE},
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]383 [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE,
384 MULTIMEDIA2_PCM_DEVICE},
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700[diff] [blame]385 [USECASE_AUDIO_RECORD_HIFI] = {MULTIMEDIA2_PCM_DEVICE,
386 MULTIMEDIA2_PCM_DEVICE},
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]387 [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE},
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -0800[diff] [blame]388 [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX},
Vimal Puthanveed47e64852013-12-20 13:23:39 -0800[diff] [blame]389 [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX},
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]390 [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]391 [USECASE_AUDIO_PLAYBACK_MMAP] = {MMAP_PLAYBACK_PCM_DEVICE,
392 MMAP_PLAYBACK_PCM_DEVICE},
393 [USECASE_AUDIO_RECORD_MMAP] = {MMAP_RECORD_PCM_DEVICE,
394 MMAP_RECORD_PCM_DEVICE},
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]395 [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE},
396 [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE},
397 [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE},
Vicky Sehrawat7e4fc152014-02-12 17:58:59 -0800[diff] [blame]398 [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE},
Vidyakumar Athota0e109352015-02-12 17:38:22 -0800[diff] [blame]399 [USECASE_VOICEMMODE1_CALL] = {VOICEMMODE1_CALL_PCM_DEVICE,
400 VOICEMMODE1_CALL_PCM_DEVICE},
401 [USECASE_VOICEMMODE2_CALL] = {VOICEMMODE2_CALL_PCM_DEVICE,
402 VOICEMMODE2_CALL_PCM_DEVICE},
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]403 [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE},
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]404 [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE,
405 AUDIO_RECORD_PCM_DEVICE},
406 [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
407 AUDIO_RECORD_PCM_DEVICE},
408 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
409 AUDIO_RECORD_PCM_DEVICE},
Helen Zenge56b4852013-12-03 16:54:40 -0800[diff] [blame]410 [USECASE_INCALL_REC_UPLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
411 COMPRESS_CAPTURE_DEVICE},
412 [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
413 COMPRESS_CAPTURE_DEVICE},
414 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
415 COMPRESS_CAPTURE_DEVICE},
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -0700[diff] [blame]416 [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE,
417 INCALL_MUSIC_UPLINK_PCM_DEVICE},
418 [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE,
419 INCALL_MUSIC_UPLINK2_PCM_DEVICE},
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]420 [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1},
421 [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE},
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]422
423 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
424 AFE_PROXY_RECORD_PCM_DEVICE},
425 [USECASE_AUDIO_RECORD_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
426 AFE_PROXY_RECORD_PCM_DEVICE},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]427 [USECASE_AUDIO_DSM_FEEDBACK] = {QUAT_MI2S_PCM_DEVICE, QUAT_MI2S_PCM_DEVICE},
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +0530[diff] [blame]428 [USECASE_AUDIO_PLAYBACK_SILENCE] = {MULTIMEDIA9_PCM_DEVICE, -1},
Surendar Karka93cd25a2018-08-28 14:21:37 +0530[diff] [blame]429 [USECASE_AUDIO_TRANSCODE_LOOPBACK_RX] = {TRANSCODE_LOOPBACK_RX_DEV_ID, -1},
430 [USECASE_AUDIO_TRANSCODE_LOOPBACK_TX] = {-1, TRANSCODE_LOOPBACK_TX_DEV_ID},
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]431
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]432 [USECASE_AUDIO_PLAYBACK_VOIP] = {AUDIO_PLAYBACK_VOIP_PCM_DEVICE, AUDIO_PLAYBACK_VOIP_PCM_DEVICE},
433 [USECASE_AUDIO_RECORD_VOIP] = {AUDIO_RECORD_VOIP_PCM_DEVICE, AUDIO_RECORD_VOIP_PCM_DEVICE},
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]434 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1] =
435 {PLAYBACK_INTERACTIVE_STRM_DEVICE1, PLAYBACK_INTERACTIVE_STRM_DEVICE1},
436 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2] =
437 {PLAYBACK_INTERACTIVE_STRM_DEVICE2, PLAYBACK_INTERACTIVE_STRM_DEVICE2},
438 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3] =
439 {PLAYBACK_INTERACTIVE_STRM_DEVICE3, PLAYBACK_INTERACTIVE_STRM_DEVICE3},
440 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4] =
441 {PLAYBACK_INTERACTIVE_STRM_DEVICE4, PLAYBACK_INTERACTIVE_STRM_DEVICE4},
442 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5] =
443 {PLAYBACK_INTERACTIVE_STRM_DEVICE5, PLAYBACK_INTERACTIVE_STRM_DEVICE5},
444 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6] =
445 {PLAYBACK_INTERACTIVE_STRM_DEVICE6, PLAYBACK_INTERACTIVE_STRM_DEVICE6},
446 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7] =
447 {PLAYBACK_INTERACTIVE_STRM_DEVICE7, PLAYBACK_INTERACTIVE_STRM_DEVICE7},
448 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8] =
449 {PLAYBACK_INTERACTIVE_STRM_DEVICE8, PLAYBACK_INTERACTIVE_STRM_DEVICE8},
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]450
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]451};
452
453/* Array to store sound devices */
454static const char * const device_table[SND_DEVICE_MAX] = {
455 [SND_DEVICE_NONE] = "none",
456 /* Playback sound devices */
457 [SND_DEVICE_OUT_HANDSET] = "handset",
458 [SND_DEVICE_OUT_SPEAKER] = "speaker",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]459 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = "speaker-ext-1",
460 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = "speaker-ext-2",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]461 [SND_DEVICE_OUT_SPEAKER_VBAT] = "speaker-vbat",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]462 [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]463 [SND_DEVICE_OUT_SPEAKER_SAFE] = "speaker-safe",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]464 [SND_DEVICE_OUT_HEADPHONES] = "headphones",
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]465 [SND_DEVICE_OUT_HEADPHONES_DSD] = "headphones-dsd",
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]466 [SND_DEVICE_OUT_HEADPHONES_44_1] = "headphones-44.1",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]467 [SND_DEVICE_OUT_LINE] = "line",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]468 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]469 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES] = "speaker-safe-and-headphones",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]470 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = "speaker-and-line",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]471 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE] = "speaker-safe-and-line",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]472 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = "speaker-and-headphones-ext-1",
473 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = "speaker-and-headphones-ext-2",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]474 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]475 [SND_DEVICE_OUT_VOICE_HAC_HANDSET] = "voice-hac-handset",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]476 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]477 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO] = "voice-speaker-stereo",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]478 [SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = "voice-speaker-vbat",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]479 [SND_DEVICE_OUT_VOICE_SPEAKER_2] = "voice-speaker-2",
480 [SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = "voice-speaker-2-vbat",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]481 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]482 [SND_DEVICE_OUT_VOICE_LINE] = "voice-line",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]483 [SND_DEVICE_OUT_HDMI] = "hdmi",
484 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]485 [SND_DEVICE_OUT_DISPLAY_PORT] = "display-port",
486 [SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = "speaker-and-display-port",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]487 [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]488 [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]489 [SND_DEVICE_OUT_BT_A2DP] = "bt-a2dp",
490 [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = "speaker-and-bt-a2dp",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]491 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP] = "speaker-safe-and-bt-a2dp",
492 [SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = "voice-handset-tmus",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]493 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
494 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
495 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]496 [SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = "voice-tty-full-usb",
497 [SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = "voice-tty-vco-usb",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]498 [SND_DEVICE_OUT_VOICE_TX] = "voice-tx",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]499 [SND_DEVICE_OUT_VOICE_MUSIC_TX] = "voice-music-tx",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]500 [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy",
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]501 [SND_DEVICE_OUT_USB_HEADSET] = "usb-headset",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]502 [SND_DEVICE_OUT_VOICE_USB_HEADSET] = "usb-headset",
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]503 [SND_DEVICE_OUT_USB_HEADPHONES] = "usb-headphones",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]504 [SND_DEVICE_OUT_USB_HEADSET_SPEC] = "usb-headset",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]505 [SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = "usb-headphones",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]506 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]507 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET] = "speaker-safe-and-usb-headphones",
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]508 [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]509 [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones",
510 [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones",
511 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones",
512 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones",
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]513 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = "voice-speaker-and-voice-headphones",
514 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = "voice-speaker-and-voice-anc-headphones",
515 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = "voice-speaker-and-voice-anc-fb-headphones",
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]516 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_HEADPHONES] = "voice-speaker-stereo-and-voice-headphones",
517 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_HEADSET] = "voice-speaker-stereo-and-voice-anc-headphones",
518 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_FB_HEADSET] = "voice-speaker-stereo-and-voice-anc-fb-headphones",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]519 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones",
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]520 [SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = "speaker-and-anc-fb-headphones",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]521 [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]522 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]523 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = "voice-speaker-protected",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]524 [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = "voice-speaker-hfp",
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]525 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED] = "voice-speaker-stereo-protected",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]526 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = "voice-speaker-2-protected",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]527 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = "speaker-protected-vbat",
528 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = "voice-speaker-protected-vbat",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]529 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT] = "voice-speaker-2-protected-vbat",
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]530 [SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS] = "speaker-protected",
531 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS] = "speaker-protected-vbat",
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]532 [SND_DEVICE_OUT_SPEAKER_AND_BT_SCO] = "speaker-and-bt-sco",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]533 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO] = "speaker-safe-and-bt-sco",
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]534 [SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB] = "speaker-and-bt-sco-wb",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]535 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB] = "speaker-safe-and-bt-sco-wb",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]536
537 /* Capture sound devices */
538 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]539 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = "handset-mic-ext",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]540 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]541 [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic",
542 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic",
543 [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]544 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]545 [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire",
546 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire",
547 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]548 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]549 [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic",
550 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic",
551 [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]552 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]553 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire",
554 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire",
555 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]556 [SND_DEVICE_IN_HEADSET_MIC_AEC] = "headset-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]557 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]558 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
559 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]560 [SND_DEVICE_IN_SPDIF] = "spdif-in",
561 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-in",
562 [SND_DEVICE_IN_HDMI_ARC] = "hdmi-arc-in",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]563 [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]564 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = "bt-sco-mic",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]565 [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]566 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = "bt-sco-mic-wb",
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]567 [SND_DEVICE_IN_BT_A2DP] = "bt-a2dp-cap",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]568 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]569 [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]570 [SND_DEVICE_IN_VOICE_DMIC_TMUS] = "voice-dmic-ef-tmus",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]571 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]572 [SND_DEVICE_IN_VOICE_SPEAKER_TMIC] = "voice-speaker-tmic",
Vidyakumar Athotaadfe4e32013-12-13 14:51:26 -0800[diff] [blame]573 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]574 [SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = "voice-speaker-mic-hfp",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]575 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
576 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
577 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]578 [SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = "voice-tty-full-usb-mic",
579 [SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = "voice-tty-hco-usb-mic",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]580 [SND_DEVICE_IN_VOICE_RX] = "voice-rx",
581
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]582 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]583 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]584 [SND_DEVICE_IN_VOICE_REC_MIC_AEC] = "voice-rec-mic",
585 [SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS] = "voice-rec-mic",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]586 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]587 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]588 [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]589 [SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] ="usb-headset-mic",
590 [SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = "usb-headset-mic",
591 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = "usb-headset-mic",
592 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = "usb-headset-mic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]593 [SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = "headset-mic",
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]594 [SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC] = "usb-headset-mic",
595 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MULTI_CHANNEL_MIC] = "usb-headset-mic",
596 [SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC_AEC] = "usb-headset-mic",
597 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MULTI_CHANNEL_MIC] = "usb-headset-mic",
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]598 [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]599 [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]600 [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = "aanc-handset-mic",
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]601 [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]602 [SND_DEVICE_IN_HANDSET_DMIC_STEREO] = "handset-stereo-dmic-ef",
603 [SND_DEVICE_IN_SPEAKER_DMIC_STEREO] = "speaker-stereo-dmic-ef",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]604 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]605 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = "vi-feedback-mono-1",
606 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = "vi-feedback-mono-2",
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]607 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = "voice-speaker-dmic-broadside",
608 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = "speaker-dmic-broadside",
609 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = "speaker-dmic-broadside",
610 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = "speaker-dmic-broadside",
611 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = "speaker-dmic-broadside",
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]612 [SND_DEVICE_IN_HANDSET_QMIC] = "quad-mic",
613 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = "quad-mic",
614 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = "quad-mic",
615 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = "quad-mic",
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]616 [SND_DEVICE_IN_HANDSET_QMIC_AEC] = "quad-mic",
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]617 [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = "quad-mic",
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -0700[diff] [blame]618 [SND_DEVICE_IN_THREE_MIC] = "three-mic",
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]619 [SND_DEVICE_IN_HANDSET_TMIC_FLUENCE_PRO] = "three-mic",
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]620 [SND_DEVICE_IN_HANDSET_TMIC] = "three-mic",
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]621 [SND_DEVICE_IN_HANDSET_TMIC_AEC] = "three-mic",
622 [SND_DEVICE_IN_HANDSET_TMIC_NS] = "three-mic",
623 [SND_DEVICE_IN_HANDSET_TMIC_AEC_NS] = "three-mic",
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]624 [SND_DEVICE_IN_SPEAKER_TMIC_AEC] = "speaker-tmic",
625 [SND_DEVICE_IN_SPEAKER_TMIC_NS] = "speaker-tmic",
626 [SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS] = "speaker-tmic",
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]627 [SND_DEVICE_IN_VOICE_REC_TMIC] = "three-mic",
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]628 [SND_DEVICE_IN_UNPROCESSED_MIC] = "unprocessed-mic",
Aalique Grahame97748be2017-10-10 14:32:29 -0700[diff] [blame]629 [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = "unprocessed-stereo-mic",
630 [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = "unprocessed-three-mic",
631 [SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = "unprocessed-quad-mic",
632 [SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = "unprocessed-headset-mic",
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]633 [SND_DEVICE_IN_HANDSET_GENERIC_QMIC] = "quad-mic",
Divya Narayanan Poojary85d0a592018-02-06 14:25:16 +0530[diff] [blame]634 [SND_DEVICE_IN_INCALL_REC_RX] = "incall-rec-rx",
635 [SND_DEVICE_IN_INCALL_REC_TX] = "incall-rec-tx",
636 [SND_DEVICE_IN_INCALL_REC_RX_TX] = "incall-rec-rx-tx",
Ramu Gottipati813ae982018-07-25 14:14:48 +0530[diff] [blame]637 [SND_DEVICE_IN_LINE] = "line-in",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]638};
639
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]640// Platform specific backend bit width table
641static int backend_bit_width_table[SND_DEVICE_MAX] = {0};
642
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]643static struct audio_effect_config effect_config_table[GET_IN_DEVICE_INDEX(SND_DEVICE_MAX)][EFFECT_MAX] = {
644 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FLUENCE_PROV2, 0x0, 0x10EAF, 0x01},
645 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FLUENCE_PROV2, 0x0, 0x10EAF, 0x02},
Vignesh Kulothungan80d87ee2018-07-17 11:59:25 -0700[diff] [blame]646 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_TM_FLUENCE_PRO_VC, 0x0, 0x10EAF, 0x01},
647 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_TM_FLUENCE_PRO_VC, 0x0, 0x10EAF, 0x02},
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]648 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)][EFFECT_AEC] = {TX_VOICE_DM_FV5_BROADSIDE, 0x0,
649 0x10EAF, 0x01},
650 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)][EFFECT_NS] = {TX_VOICE_DM_FV5_BROADSIDE, 0x0,
651 0x10EAF, 0x02},
652 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x01},
653 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x02},
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]654 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_MIC)][EFFECT_AEC] = {TX_VOICE_SMECNS_V2, 0x0, 0x10EAF, 0x01},
655 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_MIC)][EFFECT_NS] = {TX_VOICE_SMECNS_V2, 0x0, 0x10EAF, 0x02},
Vignesh Kulothungan80d87ee2018-07-17 11:59:25 -0700[diff] [blame]656 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_TMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_TM_FLUENCE_EF, 0x8000, 0x10EAF, 0x01},
657 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_TMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_TM_FLUENCE_EF, 0x8000, 0x10EAF, 0x02},
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]658 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x01},
659 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x02},
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]660 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_MIC)][EFFECT_AEC] = {TX_VOICE_SMECNS_V2, 0x0, 0x10EAF, 0x01},
661 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_MIC)][EFFECT_NS] = {TX_VOICE_SMECNS_V2, 0x0, 0x10EAF, 0x02},
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]662};
663
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]664/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]665static int acdb_device_table[SND_DEVICE_MAX] = {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]666 [SND_DEVICE_NONE] = -1,
667 [SND_DEVICE_OUT_HANDSET] = 7,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]668 [SND_DEVICE_OUT_SPEAKER] = 14,
Tanya Finkel87af1a52015-03-27 14:54:23 -0700[diff] [blame]669 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = 130,
670 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = 130,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]671 [SND_DEVICE_OUT_SPEAKER_VBAT] = 14,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]672 [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]673 [SND_DEVICE_OUT_SPEAKER_SAFE] = 14,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]674 [SND_DEVICE_OUT_LINE] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]675 [SND_DEVICE_OUT_HEADPHONES] = 10,
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]676 [SND_DEVICE_OUT_HEADPHONES_DSD] = 10,
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]677 [SND_DEVICE_OUT_HEADPHONES_44_1] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]678 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]679 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES] = 10,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]680 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = 10,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]681 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE] = 10,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]682 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = 130,
683 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = 130,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]684 [SND_DEVICE_OUT_VOICE_HANDSET] = 7,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]685 [SND_DEVICE_OUT_VOICE_SPEAKER] = 14,
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]686 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO] = 15,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]687 [SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = 14,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]688 [SND_DEVICE_OUT_VOICE_SPEAKER_2] = 14,
689 [SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = 14,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]690 [SND_DEVICE_OUT_VOICE_HAC_HANDSET] = 53,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]691 [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]692 [SND_DEVICE_OUT_VOICE_LINE] = 10,
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]693 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = 10,
694 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = 10,
695 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = 10,
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]696 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_HEADPHONES] = 10,
697 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_HEADSET] = 10,
698 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_FB_HEADSET] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]699 [SND_DEVICE_OUT_HDMI] = 18,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]700 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]701 [SND_DEVICE_OUT_DISPLAY_PORT] = 18,
702 [SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = 14,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]703 [SND_DEVICE_OUT_BT_SCO] = 22,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]704 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO] = 14,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]705 [SND_DEVICE_OUT_BT_SCO_WB] = 39,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]706 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB] = 14,
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]707 [SND_DEVICE_OUT_BT_A2DP] = 20,
708 [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = 14,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]709 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP] = 14,
710 [SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = 88,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]711 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
712 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
713 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]714 [SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = 17,
715 [SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = 17,
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]716 [SND_DEVICE_OUT_VOICE_TX] = 45,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]717 [SND_DEVICE_OUT_VOICE_MUSIC_TX] = 3,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]718 [SND_DEVICE_OUT_AFE_PROXY] = 0,
Vidyakumar Athotab9522202014-01-14 20:08:27 -0800[diff] [blame]719 [SND_DEVICE_OUT_USB_HEADSET] = 45,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]720 [SND_DEVICE_OUT_VOICE_USB_HEADSET] = 45,
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]721 [SND_DEVICE_OUT_USB_HEADPHONES] = 45,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]722 [SND_DEVICE_OUT_USB_HEADSET_SPEC] = 45,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]723 [SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = 45,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]724 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]725 [SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET] = 14,
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]726 [SND_DEVICE_OUT_TRANSMISSION_FM] = 0,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]727 [SND_DEVICE_OUT_ANC_HEADSET] = 26,
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]728 [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]729 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26,
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]730 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]731 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26,
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]732 [SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]733 [SND_DEVICE_OUT_ANC_HANDSET] = 103,
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]734 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 124,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]735 [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = 14,
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]736 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = 101,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]737 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = 101,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]738 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = 124,
739 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = 101,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]740 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT] = 101,
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]741 [SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED] = 124,
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]742 [SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS] = 134,
743 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS] = 134,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]744 [SND_DEVICE_IN_HANDSET_MIC] = 4,
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]745 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = 4,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]746 [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106,
747 [SND_DEVICE_IN_HANDSET_MIC_NS] = 107,
748 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]749 [SND_DEVICE_IN_HANDSET_DMIC] = 41,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]750 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109,
751 [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110,
752 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]753 [SND_DEVICE_IN_SPEAKER_MIC] = 11,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]754 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112,
755 [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113,
756 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]757 [SND_DEVICE_IN_SPEAKER_DMIC] = 43,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]758 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115,
759 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116,
760 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]761 [SND_DEVICE_IN_HEADSET_MIC] = 8,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]762 [SND_DEVICE_IN_HEADSET_MIC_AEC] = 8,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]763 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]764 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]765 [SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = 11,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]766 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
Ralf Herz76b455c2018-09-10 13:58:04 +0200[diff] [blame]767 [SND_DEVICE_IN_SPDIF] = 143,
768 [SND_DEVICE_IN_HDMI_MIC] = 143,
769 [SND_DEVICE_IN_HDMI_ARC] = 143,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]770 [SND_DEVICE_IN_BT_SCO_MIC] = 21,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]771 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = 122,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]772 [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]773 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = 123,
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]774 [SND_DEVICE_IN_BT_A2DP] = 21,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]775 [SND_DEVICE_IN_CAMCORDER_MIC] = 4,
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]776 [SND_DEVICE_IN_VOICE_DMIC] = 41,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]777 [SND_DEVICE_IN_VOICE_DMIC_TMUS] = 89,
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]778 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43,
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]779 [SND_DEVICE_IN_VOICE_SPEAKER_TMIC] = 161,
Vidyakumar Athotaadfe4e32013-12-13 14:51:26 -0800[diff] [blame]780 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]781 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16,
782 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
783 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]784 [SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = 16,
785 [SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = 16,
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]786 [SND_DEVICE_IN_VOICE_RX] = 44,
787
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]788 [SND_DEVICE_IN_VOICE_REC_MIC] = 4,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]789 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]790 [SND_DEVICE_IN_VOICE_REC_MIC_AEC] = 112,
791 [SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS] = 114,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]792 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34,
793 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]794 [SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = 8,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]795 [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]796 [SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = 44,
797 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = 44,
798 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = 44,
799 [SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = 44,
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]800 [SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC] = 162,
801 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MULTI_CHANNEL_MIC] = 162,
802 [SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC_AEC] = 162,
803 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MULTI_CHANNEL_MIC] = 162,
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]804 [SND_DEVICE_IN_CAPTURE_FM] = 0,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]805 [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]806 [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = 105,
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]807 [SND_DEVICE_IN_QUAD_MIC] = 46,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]808 [SND_DEVICE_IN_HANDSET_DMIC_STEREO] = 34,
809 [SND_DEVICE_IN_SPEAKER_DMIC_STEREO] = 35,
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]810 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]811 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = 102,
812 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = 102,
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]813 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = 12,
814 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = 12,
815 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = 119,
816 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = 121,
817 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120,
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]818 [SND_DEVICE_IN_HANDSET_QMIC] = 125,
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]819 [SND_DEVICE_IN_HANDSET_QMIC_AEC] = 125,
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]820 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = 126,
821 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = 127,
822 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = 129,
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]823 [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = 125,
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]824 [SND_DEVICE_IN_THREE_MIC] = 46, /* for APSS Surround Sound Recording */
Vikram Pandurangab1e26aa2018-06-21 17:28:20 -0700[diff] [blame]825 [SND_DEVICE_IN_HANDSET_TMIC_FLUENCE_PRO] = 138,
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]826 [SND_DEVICE_IN_HANDSET_TMIC] = 153,
827 [SND_DEVICE_IN_HANDSET_TMIC_AEC] = 154,
828 [SND_DEVICE_IN_HANDSET_TMIC_NS] = 155,
829 [SND_DEVICE_IN_HANDSET_TMIC_AEC_NS] = 156,
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]830 [SND_DEVICE_IN_SPEAKER_TMIC_AEC] = 158,
831 [SND_DEVICE_IN_SPEAKER_TMIC_NS] = 159,
832 [SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS] = 160,
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]833 [SND_DEVICE_IN_VOICE_REC_TMIC] = 125,
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]834 [SND_DEVICE_IN_UNPROCESSED_MIC] = 143,
835 [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = 144,
836 [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = 145,
837 [SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = 146,
838 [SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = 147,
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]839 [SND_DEVICE_IN_HANDSET_GENERIC_QMIC] = 150,
Ramu Gottipati813ae982018-07-25 14:14:48 +0530[diff] [blame]840 [SND_DEVICE_IN_LINE] = 4,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]841};
842
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]843struct name_to_index {
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]844 char name[100];
845 unsigned int index;
846};
847
848#define TO_NAME_INDEX(X) #X, X
849
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]850/* Used to get index from parsed string */
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]851static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = {
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]852 {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)},
853 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]854 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_EXTERNAL_1)},
855 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_EXTERNAL_2)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]856 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_VBAT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]857 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]858 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]859 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]860 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_DSD)},
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]861 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_44_1)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]862 {TO_NAME_INDEX(SND_DEVICE_OUT_LINE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]863 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]864 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]865 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_LINE)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]866 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]867 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1)},
868 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]869 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET)},
870 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]871 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_HFP)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]872 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_VBAT)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]873 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2)},
874 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]875 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HEADPHONES)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]876 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_LINE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]877 {TO_NAME_INDEX(SND_DEVICE_OUT_HDMI)},
878 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]879 {TO_NAME_INDEX(SND_DEVICE_OUT_DISPLAY_PORT)},
880 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]881 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]882 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]883 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]884 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB)},
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]885 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_A2DP)},
886 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]887 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP)},
888 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET_TMUS)},
889 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HAC_HANDSET)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]890 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
891 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
892 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]893 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_SCO)},
894 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB)},
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]895 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_USB)},
896 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_USB)},
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]897 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TX)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]898 {TO_NAME_INDEX(SND_DEVICE_OUT_AFE_PROXY)},
899 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]900 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_USB_HEADSET)},
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]901 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADPHONES)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]902 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_USB_HEADPHONES)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]903 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]904 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET)},
905 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET_SPEC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]906 {TO_NAME_INDEX(SND_DEVICE_OUT_TRANSMISSION_FM)},
907 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HEADSET)},
908 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_FB_HEADSET)},
909 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_HEADSET)},
910 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)},
911 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET)},
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]912 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]913 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HANDSET)},
914 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)},
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]915 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]916 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED)},
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]917 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]918 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT)},
919 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]920 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT)},
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]921 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS)},
922 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]923 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]924 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_EXTERNAL)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]925 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC)},
926 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_NS)},
927 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)},
928 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC)},
929 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC)},
930 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_NS)},
931 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)},
932 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC)},
933 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC)},
934 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_NS)},
935 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)},
936 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC)},
937 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC)},
938 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS)},
939 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]940 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_STEREO)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]941 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]942 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_AEC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]943 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_FLUENCE)},
944 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]945 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]946 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_HEADSET_MIC)},
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]947 {TO_NAME_INDEX(SND_DEVICE_IN_SPDIF)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]948 {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_MIC)},
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]949 {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_ARC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]950 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]951 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_NREC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]952 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]953 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)},
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]954 {TO_NAME_INDEX(SND_DEVICE_IN_BT_A2DP)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]955 {TO_NAME_INDEX(SND_DEVICE_IN_CAMCORDER_MIC)},
956 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]957 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC_TMUS)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]958 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC)},
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]959 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_TMIC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]960 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_QMIC)},
961 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC)},
962 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC)},
963 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC)},
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]964 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC)},
965 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]966 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC)},
967 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_NS)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]968 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_AEC)},
969 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]970 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)},
971 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]972 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_HEADSET_MIC)},
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]973 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RX)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]974 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]975 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_USB_HEADSET_MIC)},
976 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC)},
977 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC)},
978 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC_AEC)},
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]979 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC)},
980 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MULTI_CHANNEL_MIC)},
981 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MULTI_CHANNEL_MIC)},
982 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC_AEC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]983 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_FM)},
984 {TO_NAME_INDEX(SND_DEVICE_IN_AANC_HANDSET_MIC)},
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]985 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]986 {TO_NAME_INDEX(SND_DEVICE_IN_QUAD_MIC)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]987 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_STEREO)},
988 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_STEREO)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]989 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]990 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1)},
991 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2)},
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]992 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE)},
993 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE)},
994 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE)},
995 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE)},
996 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)},
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]997 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_QMIC)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]998 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_QMIC_AEC)},
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]999 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC)},
1000 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_NS)},
1001 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)},
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]1002 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE)},
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1003 {TO_NAME_INDEX(SND_DEVICE_IN_THREE_MIC)},
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]1004 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC_FLUENCE_PRO)},
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1005 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC)},
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]1006 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC_AEC)},
1007 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC_NS)},
1008 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC_AEC_NS)},
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]1009 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_TMIC_AEC)},
1010 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_TMIC_NS)},
1011 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS)},
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]1012 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_TMIC)},
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]1013 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_MIC)},
1014 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_STEREO_MIC)},
1015 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_THREE_MIC)},
1016 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_QUAD_MIC)},
1017 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC)},
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]1018 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_GENERIC_QMIC)},
Divya Narayanan Poojary85d0a592018-02-06 14:25:16 +0530[diff] [blame]1019 {TO_NAME_INDEX(SND_DEVICE_IN_INCALL_REC_RX)},
1020 {TO_NAME_INDEX(SND_DEVICE_IN_INCALL_REC_TX)},
1021 {TO_NAME_INDEX(SND_DEVICE_IN_INCALL_REC_RX_TX)},
Ramu Gottipati813ae982018-07-25 14:14:48 +0530[diff] [blame]1022 {TO_NAME_INDEX(SND_DEVICE_IN_LINE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]1023};
1024
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1025static char * backend_tag_table[SND_DEVICE_MAX] = {0};
1026static char * hw_interface_table[SND_DEVICE_MAX] = {0};
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1027
1028static struct name_to_index usecase_name_index[AUDIO_USECASE_MAX] = {
1029 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_DEEP_BUFFER)},
1030 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_LOW_LATENCY)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1031 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_HIFI)},
1032 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_TTS)},
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]1033 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_ULL)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1034 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MULTI_CH)},
1035 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD)},
Alexy Joseph2f89cfa2014-10-06 12:15:01 -0700[diff] [blame]1036 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD2)},
1037 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD3)},
1038 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD4)},
1039 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD5)},
1040 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD6)},
1041 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD7)},
1042 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD8)},
1043 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD9)},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]1044 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MMAP)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1045 {TO_NAME_INDEX(USECASE_AUDIO_RECORD)},
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530[diff] [blame]1046 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS)},
1047 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS2)},
1048 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS3)},
1049 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS4)},
Dhananjay Kumar376e38b2017-09-28 22:26:23 +0530[diff] [blame]1050 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS5)},
1051 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS6)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1052 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_LOW_LATENCY)},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]1053 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_MMAP)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1054 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_HIFI)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1055 {TO_NAME_INDEX(USECASE_VOICE_CALL)},
1056 {TO_NAME_INDEX(USECASE_VOICE2_CALL)},
1057 {TO_NAME_INDEX(USECASE_VOLTE_CALL)},
1058 {TO_NAME_INDEX(USECASE_QCHAT_CALL)},
1059 {TO_NAME_INDEX(USECASE_VOWLAN_CALL)},
Shiv Maliyappanahallif2d2a492016-05-11 22:03:47 -0700[diff] [blame]1060 {TO_NAME_INDEX(USECASE_VOICEMMODE1_CALL)},
1061 {TO_NAME_INDEX(USECASE_VOICEMMODE2_CALL)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1062 {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK)},
1063 {TO_NAME_INDEX(USECASE_INCALL_REC_DOWNLINK)},
1064 {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK_AND_DOWNLINK)},
1065 {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO)},
Satya Krishna Pindiprolic6b0a742017-02-03 14:37:18 +0530[diff] [blame]1066 {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO_WB)},
Shiv Maliyappanahallie236ff02016-05-26 11:47:48 -0700[diff] [blame]1067 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_FM)},
1068 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_FM_VIRTUAL)},
Stephen Oglesbyf8a7bf92016-05-11 14:23:16 -0700[diff] [blame]1069 {TO_NAME_INDEX(USECASE_AUDIO_SPKR_CALIB_RX)},
1070 {TO_NAME_INDEX(USECASE_AUDIO_SPKR_CALIB_TX)},
Garmond Leunge1e8c762016-06-27 16:35:15 -0700[diff] [blame]1071 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_AFE_PROXY)},
1072 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_AFE_PROXY)},
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1073 {TO_NAME_INDEX(USECASE_AUDIO_DSM_FEEDBACK)},
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +0530[diff] [blame]1074 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_SILENCE)},
Arun Mirpurie5c697c2018-07-17 17:58:17 -0700[diff] [blame]1075 {TO_NAME_INDEX(USECASE_INCALL_MUSIC_UPLINK)},
Aniket Kumar Lata7fd86e12018-02-20 19:26:10 -0800[diff] [blame]1076 {TO_NAME_INDEX(USECASE_AUDIO_A2DP_ABR_FEEDBACK)},
kunleiz6f796ac2018-07-16 17:03:59 +0800[diff] [blame]1077 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_VOIP)},
1078 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_VOIP)},
Surendar Karka93cd25a2018-08-28 14:21:37 +0530[diff] [blame]1079 {TO_NAME_INDEX(USECASE_AUDIO_TRANSCODE_LOOPBACK_RX)},
1080 {TO_NAME_INDEX(USECASE_AUDIO_TRANSCODE_LOOPBACK_TX)},
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]1081
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1082};
1083
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1084static const struct name_to_index usecase_type_index[USECASE_TYPE_MAX] = {
1085 {TO_NAME_INDEX(PCM_PLAYBACK)},
1086 {TO_NAME_INDEX(PCM_CAPTURE)},
1087 {TO_NAME_INDEX(VOICE_CALL)},
1088 {TO_NAME_INDEX(PCM_HFP_CALL)},
1089};
1090
1091struct app_type_entry {
1092 int uc_type;
1093 int bit_width;
1094 int app_type;
1095 int max_rate;
1096 char *mode;
1097 struct listnode node; // membership in app_type_entry_list;
1098};
1099
1100static struct listnode app_type_entry_list;
1101
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]1102#define NO_COLS 2
1103#ifdef PLATFORM_APQ8084
1104static int msm_device_to_be_id [][NO_COLS] = {
1105 {AUDIO_DEVICE_OUT_EARPIECE , 2},
1106 {AUDIO_DEVICE_OUT_SPEAKER , 2},
1107 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 2},
1108 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 2},
1109 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
1110 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
1111 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
1112 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
1113 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
1114 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
1115 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
1116 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
1117 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
1118 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
1119 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]1120 {AUDIO_DEVICE_OUT_USB_HEADSET , -1},
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]1121 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
1122 {AUDIO_DEVICE_OUT_PROXY , 9},
1123 {AUDIO_DEVICE_OUT_FM , 7},
1124 {AUDIO_DEVICE_OUT_FM_TX , 8},
1125 {AUDIO_DEVICE_OUT_ALL , -1},
1126 {AUDIO_DEVICE_NONE , -1},
1127 {AUDIO_DEVICE_OUT_DEFAULT , -1},
1128};
1129#elif PLATFORM_MSM8994
1130static int msm_device_to_be_id [][NO_COLS] = {
1131 {AUDIO_DEVICE_OUT_EARPIECE , 2},
1132 {AUDIO_DEVICE_OUT_SPEAKER , 2},
1133 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 2},
1134 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 2},
1135 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 38},
1136 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 38},
1137 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 38},
1138 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
1139 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
1140 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
1141 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
1142 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
1143 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
1144 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
1145 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]1146 {AUDIO_DEVICE_OUT_USB_HEADSET , -1},
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]1147 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
1148 {AUDIO_DEVICE_OUT_PROXY , 9},
1149/* Add the correct be ids */
1150 {AUDIO_DEVICE_OUT_FM , 7},
1151 {AUDIO_DEVICE_OUT_FM_TX , 8},
1152 {AUDIO_DEVICE_OUT_ALL , -1},
1153 {AUDIO_DEVICE_NONE , -1},
1154 {AUDIO_DEVICE_OUT_DEFAULT , -1},
1155};
Pradnya Chaphekarf0b1cfe2015-04-15 16:52:49 -0700[diff] [blame]1156#elif PLATFORM_MSM8996
1157static int msm_device_to_be_id [][NO_COLS] = {
1158 {AUDIO_DEVICE_OUT_EARPIECE , 2},
1159 {AUDIO_DEVICE_OUT_SPEAKER , 2},
Sharad Sangle1f705a72016-10-05 20:01:39 +0530[diff] [blame]1160 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 41},
1161 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 41},
Pradnya Chaphekarf0b1cfe2015-04-15 16:52:49 -0700[diff] [blame]1162 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
1163 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
1164 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
1165 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
1166 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
1167 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
1168 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
1169 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
1170 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
1171 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
1172 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]1173 {AUDIO_DEVICE_OUT_USB_HEADSET , -1},
Pradnya Chaphekarf0b1cfe2015-04-15 16:52:49 -0700[diff] [blame]1174 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
1175 {AUDIO_DEVICE_OUT_PROXY , 9},
1176/* Add the correct be ids */
1177 {AUDIO_DEVICE_OUT_FM , 7},
1178 {AUDIO_DEVICE_OUT_FM_TX , 8},
1179 {AUDIO_DEVICE_OUT_ALL , -1},
1180 {AUDIO_DEVICE_NONE , -1},
1181 {AUDIO_DEVICE_OUT_DEFAULT , -1},
1182};
Weiyin Jiang6f4c8062016-11-23 15:30:29 +0800[diff] [blame]1183#elif PLATFORM_MSM8998
1184static int msm_device_to_be_id [][NO_COLS] = {
1185 {AUDIO_DEVICE_OUT_EARPIECE , 2},
1186 {AUDIO_DEVICE_OUT_SPEAKER , 2},
1187 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 41},
1188 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 41},
1189 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
1190 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
1191 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
1192 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
1193 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
1194 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
1195 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
1196 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
1197 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
1198 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
1199 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]1200 {AUDIO_DEVICE_OUT_USB_HEADSET , -1},
Weiyin Jiang6f4c8062016-11-23 15:30:29 +0800[diff] [blame]1201 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
1202 {AUDIO_DEVICE_OUT_PROXY , 9},
1203/* Add the correct be ids */
1204 {AUDIO_DEVICE_OUT_FM , 7},
1205 {AUDIO_DEVICE_OUT_FM_TX , 8},
1206 {AUDIO_DEVICE_OUT_ALL , -1},
1207 {AUDIO_DEVICE_NONE , -1},
1208 {AUDIO_DEVICE_OUT_DEFAULT , -1},
1209};
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]1210#else
1211static int msm_device_to_be_id [][NO_COLS] = {
1212 {AUDIO_DEVICE_NONE, -1},
1213};
1214#endif
1215static int msm_be_id_array_len =
1216 sizeof(msm_device_to_be_id) / sizeof(msm_device_to_be_id[0]);
1217
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]1218#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]1219#define PCM_OFFLOAD_PLATFORM_DELAY (30*1000LL)
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]1220#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1221#define ULL_PLATFORM_DELAY (3*1000LL)
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]1222#define MMAP_PLATFORM_DELAY (3*1000LL)
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]1223
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1224static pthread_once_t check_op_once_ctl = PTHREAD_ONCE_INIT;
1225static bool is_tmus = false;
1226
1227static void check_operator()
1228{
1229 char value[PROPERTY_VALUE_MAX];
1230 int mccmnc;
1231 property_get("gsm.sim.operator.numeric",value,"0");
1232 mccmnc = atoi(value);
1233 ALOGD("%s: tmus mccmnc %d", __func__, mccmnc);
1234 switch(mccmnc) {
1235 /* TMUS MCC(310), MNC(490, 260, 026) */
1236 case 310490:
1237 case 310260:
1238 case 310026:
1239 /* Add new TMUS MNC(800, 660, 580, 310, 270, 250, 240, 230, 220, 210, 200, 160) */
1240 case 310800:
1241 case 310660:
1242 case 310580:
1243 case 310310:
1244 case 310270:
1245 case 310250:
1246 case 310240:
1247 case 310230:
1248 case 310220:
1249 case 310210:
1250 case 310200:
1251 case 310160:
1252 is_tmus = true;
1253 break;
1254 }
1255}
1256
1257bool is_operator_tmus()
1258{
1259 pthread_once(&check_op_once_ctl, check_operator);
1260 return is_tmus;
1261}
1262
1263static char *get_current_operator()
1264{
1265 struct listnode *node;
1266 struct operator_info *info_item;
1267 char mccmnc[PROPERTY_VALUE_MAX];
1268 char *ret = NULL;
1269
1270 property_get("gsm.sim.operator.numeric",mccmnc,"00000");
1271
1272 list_for_each(node, &operator_info_list) {
1273 info_item = node_to_item(node, struct operator_info, list);
1274 if (strstr(info_item->mccmnc, mccmnc) != NULL) {
1275 ret = info_item->name;
1276 }
1277 }
1278
1279 return ret;
1280}
1281
1282static struct operator_specific_device *get_operator_specific_device(snd_device_t snd_device)
1283{
1284 struct listnode *node;
1285 struct operator_specific_device *ret = NULL;
1286 struct operator_specific_device *device_item;
1287 char *operator_name;
1288
1289 operator_name = get_current_operator();
1290 if (operator_name == NULL)
1291 return ret;
1292
1293 list_for_each(node, operator_specific_device_table[snd_device]) {
1294 device_item = node_to_item(node, struct operator_specific_device, list);
1295 if (strcmp(operator_name, device_item->operator) == 0) {
1296 ret = device_item;
1297 }
1298 }
1299
1300 return ret;
1301}
1302
1303static int get_operator_specific_device_acdb_id(snd_device_t snd_device)
1304{
1305 struct operator_specific_device *device;
1306 int ret = acdb_device_table[snd_device];
1307
1308 device = get_operator_specific_device(snd_device);
1309 if (device != NULL)
1310 ret = device->acdb_id;
1311
1312 return ret;
1313}
1314
1315static const char *get_operator_specific_device_mixer_path(snd_device_t snd_device)
1316{
1317 struct operator_specific_device *device;
1318 const char *ret = device_table[snd_device];
1319
1320 device = get_operator_specific_device(snd_device);
1321 if (device != NULL)
1322 ret = device->mixer_path;
1323
1324 return ret;
1325}
1326
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]1327static void update_codec_type_and_interface(struct platform_data * my_data,
1328 const char *snd_card_name)
1329{
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]1330 if (!strncmp(snd_card_name, "sdm670-skuw-snd-card",
1331 sizeof("sdm670-skuw-snd-card")) ||
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1332 !strncmp(snd_card_name, "sdm660-snd-card-skush",
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]1333 sizeof("sdm660-snd-card-skush")) ||
Walter Yang725a57f2017-11-03 14:32:49 +0800[diff] [blame]1334 !strncmp(snd_card_name, "sdm670-360cam-snd-card",
1335 sizeof("sdm670-360cam-snd-card")) ||
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]1336 !strncmp(snd_card_name, "sdm660-snd-card-mtp",
1337 sizeof("sdm660-snd-card-mtp")) ||
Sharad Sangle999cf722017-10-18 18:25:47 +0530[diff] [blame]1338 !strncmp(snd_card_name, "sdm670-mtp-snd-card",
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]1339 sizeof("sdm670-mtp-snd-card")) ||
Xiaojun Sangfcddd672018-08-15 17:53:48 +0800[diff] [blame]1340 !strncmp(snd_card_name, "sm6150-qrd-snd-card",
1341 sizeof("sm6150-qrd-snd-card")) ||
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]1342 !strncmp(snd_card_name, "sm6150-idp-snd-card",
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]1343 sizeof("sm6150-idp-snd-card")) ||
Sachin Mohan Gadageffd7562018-02-13 17:10:09 +0530[diff] [blame]1344 !strncmp(snd_card_name, "qcs605-lc-snd-card",
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]1345 sizeof("qcs605-lc-snd-card")) ||
1346 !strncmp(snd_card_name, "kona-mtp-snd-card",
1347 sizeof("kona-mtp-snd-card")) ||
1348 !strncmp(snd_card_name, "kona-qrd-snd-card",
1349 sizeof("kona-qrd-snd-card"))) {
1350 ALOGI("%s: snd_card_name: %s", __func__, snd_card_name);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1351 my_data->is_internal_codec = true;
1352 my_data->is_slimbus_interface = false;
1353 }
1354}
1355
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1356static bool can_enable_mbdrc_on_device(snd_device_t snd_device)
1357{
1358 bool ret = false;
1359
1360 if (snd_device == SND_DEVICE_OUT_SPEAKER ||
1361 snd_device == SND_DEVICE_OUT_SPEAKER_WSA ||
1362 snd_device == SND_DEVICE_OUT_SPEAKER_VBAT ||
1363 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
1364 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT ||
1365 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
1366 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
1367 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_WSA ||
1368 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_WSA) {
1369 ret = true;
1370 }
1371 return ret;
1372}
1373
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]1374static snd_device_t fixup_usb_headset_mic_snd_device(void *platform,
1375 snd_device_t base,
1376 snd_device_t other)
1377{
1378 struct platform_data *my_data = (struct platform_data *)platform;
1379 struct audio_device *adev = my_data->adev;
1380 if (adev->active_input == NULL) {
1381 return base;
1382 }
1383 unsigned int sr = adev->active_input->sample_rate;
1384 unsigned int ch = popcount(adev->active_input->channel_mask);
1385 unsigned int bit_width = adev->active_input->bit_width;
1386 if (audio_extn_usb_is_config_supported(&bit_width, &sr, &ch, false)
1387 && ((ch == 6) || (ch == 8))) {
1388 return other;
1389 } else {
1390 return base;
1391 }
1392}
1393
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]1394static const char *platform_get_mixer_control(struct mixer_ctl *);
1395
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1396bool platform_send_gain_dep_cal(void *platform, int level) {
1397 bool ret_val = false;
1398 struct platform_data *my_data = (struct platform_data *)platform;
1399 struct audio_device *adev = my_data->adev;
1400 int acdb_dev_id, app_type;
1401 int acdb_dev_type = MSM_SNDDEV_CAP_RX;
1402 int mode = CAL_MODE_RTAC;
1403 struct listnode *node;
1404 struct audio_usecase *usecase;
1405
1406 if (my_data->acdb_send_gain_dep_cal == NULL) {
1407 ALOGE("%s: dlsym error for acdb_send_gain_dep_cal", __func__);
1408 return ret_val;
1409 }
1410
1411 if (!voice_is_in_call(adev)) {
1412 ALOGV("%s: Not Voice call usecase, apply new cal for level %d",
1413 __func__, level);
1414
1415 // find the current active sound device
1416 list_for_each(node, &adev->usecase_list) {
1417 usecase = node_to_item(node, struct audio_usecase, list);
1418
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]1419 if (usecase != NULL && usecase->type == PCM_PLAYBACK) {
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1420 int new_snd_device[2] = {0};
1421 int i, num_devices = 1;
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1422
1423 ALOGV("%s: out device is %d", __func__, usecase->out_snd_device);
1424 app_type = usecase->stream.out->app_type_cfg.app_type;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1425 acdb_dev_id = platform_get_snd_device_acdb_id(usecase->out_snd_device);
vivek mehta0b8ea6f2015-07-23 17:27:26 -0700[diff] [blame]1426
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1427 if (platform_split_snd_device(my_data, usecase->out_snd_device,
1428 &num_devices, new_snd_device) < 0)
1429 new_snd_device[0] = usecase->out_snd_device;
1430
1431 for (i = 0; i < num_devices; i++)
1432 if (can_enable_mbdrc_on_device(new_snd_device[i])) {
1433 if (audio_extn_spkr_prot_is_enabled())
1434 acdb_dev_id = platform_get_spkr_prot_acdb_id(new_snd_device[i]);
1435 else
1436 acdb_dev_id = acdb_device_table[new_snd_device[i]];
1437 }
vivek mehta0b8ea6f2015-07-23 17:27:26 -0700[diff] [blame]1438
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1439 if (!my_data->acdb_send_gain_dep_cal(acdb_dev_id, app_type,
1440 acdb_dev_type, mode, level)) {
1441 // set ret_val true if at least one calibration is set successfully
1442 ret_val = true;
1443 } else {
1444 ALOGE("%s: my_data->acdb_send_gain_dep_cal failed ", __func__);
1445 }
1446 } else {
1447 ALOGW("%s: Usecase list is empty", __func__);
1448 }
1449 }
1450 } else {
1451 ALOGW("%s: Voice call in progress .. ignore setting new cal",
1452 __func__);
1453 }
1454 return ret_val;
1455}
1456
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1457void platform_set_gsm_mode(void *platform, bool enable)
1458{
1459 struct platform_data *my_data = (struct platform_data *)platform;
1460 struct audio_device *adev = my_data->adev;
1461
1462 if (my_data->gsm_mode_enabled) {
1463 my_data->gsm_mode_enabled = false;
1464 ALOGV("%s: disabling gsm mode", __func__);
1465 audio_route_reset_and_update_path(adev->audio_route, "gsm-mode");
1466 }
1467
1468 if (enable) {
1469 my_data->gsm_mode_enabled = true;
1470 ALOGD("%s: enabling gsm mode", __func__);
1471 audio_route_apply_and_update_path(adev->audio_route, "gsm-mode");
1472 }
1473}
1474
1475void platform_set_echo_reference(struct audio_device *adev, bool enable,
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]1476 audio_devices_t out_device __unused)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1477{
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1478 struct platform_data *my_data = (struct platform_data *)adev->platform;
kunleize96916e2018-07-16 16:25:59 +0800[diff] [blame]1479 char ec_ref_mixer_path[MIXER_PATH_MAX_LENGTH] = "echo-reference";
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1480
kunleiz70e57612018-12-28 17:50:23 +0800[diff] [blame^]1481 audio_extn_sound_trigger_update_ec_ref_status(enable);
1482
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1483 if (strcmp(my_data->ec_ref_mixer_path, "")) {
1484 ALOGV("%s: disabling %s", __func__, my_data->ec_ref_mixer_path);
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1485 audio_route_reset_and_update_path(adev->audio_route,
1486 my_data->ec_ref_mixer_path);
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]1487 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1488
Ravi Kumar Alamandad1c85bb2014-11-17 18:36:24 -0800[diff] [blame]1489 if (enable) {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]1490 if (!voice_extn_is_compress_voip_supported()) {
1491 if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
1492 strlcat(ec_ref_mixer_path, "-voip", MIXER_PATH_MAX_LENGTH);
1493 }
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1494 /*
1495 * If native audio device reference count > 0, then apply codec EC otherwise
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1496 * fallback to Speakers with VBat if enabled or default
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1497 */
1498 if (adev->snd_dev_ref_cnt[SND_DEVICE_OUT_HEADPHONES_44_1] > 0)
kunleize96916e2018-07-16 16:25:59 +0800[diff] [blame]1499 strlcat(ec_ref_mixer_path, " headphones-44.1",
1500 MIXER_PATH_MAX_LENGTH);
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]1501 else if (adev->snd_dev_ref_cnt[SND_DEVICE_OUT_SPEAKER_VBAT] > 0)
kunleize96916e2018-07-16 16:25:59 +0800[diff] [blame]1502 strlcat(ec_ref_mixer_path, " speaker-vbat",
1503 MIXER_PATH_MAX_LENGTH);
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]1504 else if (adev->snd_dev_ref_cnt[SND_DEVICE_OUT_DISPLAY_PORT] > 0)
kunleize96916e2018-07-16 16:25:59 +0800[diff] [blame]1505 strlcat(ec_ref_mixer_path, " display-port",
1506 MIXER_PATH_MAX_LENGTH);
1507
1508 strlcpy(my_data->ec_ref_mixer_path, ec_ref_mixer_path,
1509 MIXER_PATH_MAX_LENGTH);
Ravi Kumar Alamandad1c85bb2014-11-17 18:36:24 -0800[diff] [blame]1510
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1511 ALOGD("%s: enabling %s", __func__, my_data->ec_ref_mixer_path);
1512 audio_route_apply_and_update_path(adev->audio_route, my_data->ec_ref_mixer_path);
1513 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1514}
1515
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1516static struct csd_data *open_csd_client(bool i2s_ext_modem)
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1517{
1518 struct csd_data *csd = calloc(1, sizeof(struct csd_data));
1519
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -0700[diff] [blame]1520 if (!csd) {
1521 ALOGE("failed to allocate csd_data mem");
1522 return NULL;
1523 }
1524
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1525 csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW);
1526 if (csd->csd_client == NULL) {
1527 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT);
1528 goto error;
1529 } else {
1530 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT);
1531
1532 csd->deinit = (deinit_t)dlsym(csd->csd_client,
1533 "csd_client_deinit");
1534 if (csd->deinit == NULL) {
1535 ALOGE("%s: dlsym error %s for csd_client_deinit", __func__,
1536 dlerror());
1537 goto error;
1538 }
1539 csd->disable_device = (disable_device_t)dlsym(csd->csd_client,
1540 "csd_client_disable_device");
1541 if (csd->disable_device == NULL) {
1542 ALOGE("%s: dlsym error %s for csd_client_disable_device",
1543 __func__, dlerror());
1544 goto error;
1545 }
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]1546 csd->enable_device_config = (enable_device_config_t)dlsym(csd->csd_client,
1547 "csd_client_enable_device_config");
1548 if (csd->enable_device_config == NULL) {
1549 ALOGE("%s: dlsym error %s for csd_client_enable_device_config",
1550 __func__, dlerror());
1551 goto error;
1552 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1553 csd->enable_device = (enable_device_t)dlsym(csd->csd_client,
1554 "csd_client_enable_device");
1555 if (csd->enable_device == NULL) {
1556 ALOGE("%s: dlsym error %s for csd_client_enable_device",
1557 __func__, dlerror());
1558 goto error;
1559 }
1560 csd->start_voice = (start_voice_t)dlsym(csd->csd_client,
1561 "csd_client_start_voice");
1562 if (csd->start_voice == NULL) {
1563 ALOGE("%s: dlsym error %s for csd_client_start_voice",
1564 __func__, dlerror());
1565 goto error;
1566 }
1567 csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client,
1568 "csd_client_stop_voice");
1569 if (csd->stop_voice == NULL) {
1570 ALOGE("%s: dlsym error %s for csd_client_stop_voice",
1571 __func__, dlerror());
1572 goto error;
1573 }
1574 csd->volume = (volume_t)dlsym(csd->csd_client,
1575 "csd_client_volume");
1576 if (csd->volume == NULL) {
1577 ALOGE("%s: dlsym error %s for csd_client_volume",
1578 __func__, dlerror());
1579 goto error;
1580 }
1581 csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client,
1582 "csd_client_mic_mute");
1583 if (csd->mic_mute == NULL) {
1584 ALOGE("%s: dlsym error %s for csd_client_mic_mute",
1585 __func__, dlerror());
1586 goto error;
1587 }
1588 csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client,
1589 "csd_client_slow_talk");
1590 if (csd->slow_talk == NULL) {
1591 ALOGE("%s: dlsym error %s for csd_client_slow_talk",
1592 __func__, dlerror());
1593 goto error;
1594 }
1595 csd->start_playback = (start_playback_t)dlsym(csd->csd_client,
1596 "csd_client_start_playback");
1597 if (csd->start_playback == NULL) {
1598 ALOGE("%s: dlsym error %s for csd_client_start_playback",
1599 __func__, dlerror());
1600 goto error;
1601 }
1602 csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client,
1603 "csd_client_stop_playback");
1604 if (csd->stop_playback == NULL) {
1605 ALOGE("%s: dlsym error %s for csd_client_stop_playback",
1606 __func__, dlerror());
1607 goto error;
1608 }
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]1609 csd->set_lch = (set_lch_t)dlsym(csd->csd_client, "csd_client_set_lch");
1610 if (csd->set_lch == NULL) {
1611 ALOGE("%s: dlsym error %s for csd_client_set_lch",
1612 __func__, dlerror());
1613 /* Ignore the error as this is not mandatory function for
1614 * basic voice call to work.
1615 */
1616 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1617 csd->start_record = (start_record_t)dlsym(csd->csd_client,
1618 "csd_client_start_record");
1619 if (csd->start_record == NULL) {
1620 ALOGE("%s: dlsym error %s for csd_client_start_record",
1621 __func__, dlerror());
1622 goto error;
1623 }
1624 csd->stop_record = (stop_record_t)dlsym(csd->csd_client,
1625 "csd_client_stop_record");
1626 if (csd->stop_record == NULL) {
1627 ALOGE("%s: dlsym error %s for csd_client_stop_record",
1628 __func__, dlerror());
1629 goto error;
1630 }
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1631
1632 csd->get_sample_rate = (get_sample_rate_t)dlsym(csd->csd_client,
1633 "csd_client_get_sample_rate");
1634 if (csd->get_sample_rate == NULL) {
1635 ALOGE("%s: dlsym error %s for csd_client_get_sample_rate",
1636 __func__, dlerror());
1637
1638 goto error;
1639 }
1640
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1641 csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init");
1642
1643 if (csd->init == NULL) {
1644 ALOGE("%s: dlsym error %s for csd_client_init",
1645 __func__, dlerror());
1646 goto error;
1647 } else {
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1648 csd->init(i2s_ext_modem);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1649 }
1650 }
1651 return csd;
1652
1653error:
1654 free(csd);
1655 csd = NULL;
1656 return csd;
1657}
1658
1659void close_csd_client(struct csd_data *csd)
1660{
1661 if (csd != NULL) {
1662 csd->deinit();
1663 dlclose(csd->csd_client);
1664 free(csd);
1665 csd = NULL;
1666 }
1667}
1668
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1669static bool platform_is_i2s_ext_modem(const char *snd_card_name,
1670 struct platform_data *plat_data)
1671{
1672 plat_data->is_i2s_ext_modem = false;
1673
1674 if (!strncmp(snd_card_name, "apq8084-taiko-i2s-mtp-snd-card",
1675 sizeof("apq8084-taiko-i2s-mtp-snd-card")) ||
1676 !strncmp(snd_card_name, "apq8084-taiko-i2s-cdp-snd-card",
Josh Kirschc3894372016-03-28 15:59:48 -0700[diff] [blame]1677 sizeof("apq8084-taiko-i2s-cdp-snd-card")) ||
1678 !strncmp(snd_card_name, "apq8096-tasha-i2c-snd-card",
Xiaoyu Yec494c752017-11-02 18:52:48 -0700[diff] [blame]1679 sizeof("apq8096-tasha-i2c-snd-card")) ||
1680 !strncmp(snd_card_name, "sdx-tavil-i2s-snd-card",
Josh Kirschf20adbf2018-03-06 16:26:22 -0800[diff] [blame]1681 sizeof("sdx-tavil-i2s-snd-card")) ||
1682 !strncmp(snd_card_name, "sda845-tavil-i2s-snd-card",
1683 sizeof("sda845-tavil-i2s-snd-card"))) {
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1684 plat_data->is_i2s_ext_modem = true;
1685 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]1686 ALOGV("%s, is_i2s_ext_modem:%d soundcard name is %s",__func__,
1687 plat_data->is_i2s_ext_modem, snd_card_name);
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1688
1689 return plat_data->is_i2s_ext_modem;
Helen Zeng008aebd2014-02-23 19:13:12 -0800[diff] [blame]1690}
1691
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1692static void set_platform_defaults(struct platform_data * my_data)
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1693{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]1694 int32_t dev;
1695 unsigned int count = 0;
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1696 const char *MEDIA_MIMETYPE_AUDIO_ALAC = "audio/alac";
1697 const char *MEDIA_MIMETYPE_AUDIO_APE = "audio/x-ape";
1698
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1699 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1700 backend_tag_table[dev] = NULL;
1701 hw_interface_table[dev] = NULL;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1702 operator_specific_device_table[dev] = NULL;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1703 }
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]1704 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]1705 backend_bit_width_table[dev] = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]1706 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1707
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1708 // To overwrite these go to the audio_platform_info.xml file.
1709 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("bt-sco");
1710 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("bt-sco-wb");
1711 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("bt-sco");
1712 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("bt-sco-wb");
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]1713 backend_tag_table[SND_DEVICE_IN_SPDIF] = strdup("spdif-in");
1714 backend_tag_table[SND_DEVICE_IN_HDMI_MIC] = strdup("hdmi-in");
1715 backend_tag_table[SND_DEVICE_IN_HDMI_ARC] = strdup("hdmi-arc-in");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1716 backend_tag_table[SND_DEVICE_OUT_BT_SCO] = strdup("bt-sco");
1717 backend_tag_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("bt-sco-wb");
1718 backend_tag_table[SND_DEVICE_OUT_HDMI] = strdup("hdmi");
1719 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("speaker-and-hdmi");
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]1720 backend_tag_table[SND_DEVICE_OUT_DISPLAY_PORT] = strdup("display-port");
1721 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = strdup("speaker-and-display-port");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1722 backend_tag_table[SND_DEVICE_OUT_VOICE_TX] = strdup("afe-proxy");
1723 backend_tag_table[SND_DEVICE_IN_VOICE_RX] = strdup("afe-proxy");
1724 backend_tag_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("afe-proxy");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1725 backend_tag_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("usb-headset");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1726 backend_tag_table[SND_DEVICE_OUT_VOICE_USB_HEADSET] = strdup("usb-headset");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1727 backend_tag_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("usb-headphones");
Aniket Kumar Latab26135f2017-06-16 12:20:04 -0700[diff] [blame]1728 backend_tag_table[SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = strdup("usb-headset");
1729 backend_tag_table[SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = strdup("usb-headphones");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1730 backend_tag_table[SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = strdup("usb-headphones");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1731 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] =
Sidipotu Ashokeaec6392016-04-19 09:37:57 +0530[diff] [blame]1732 strdup("speaker-and-usb-headphones");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1733 backend_tag_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET] =
1734 strdup("speaker-safe-and-usb-headphones");
1735 backend_tag_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO] =
1736 strdup("speaker-safe-and-bt-sco");
1737 backend_tag_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB] =
1738 strdup("speaker-safe-and-bt-sco-wb");
Aniket Kumar Lata6bbd3bb2017-07-21 11:09:21 -0700[diff] [blame]1739 backend_tag_table[SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = strdup("usb-headset-mic");
1740 backend_tag_table[SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = strdup("usb-headset-mic");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1741 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1742 backend_tag_table[SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1743 backend_tag_table[SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1744 backend_tag_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1745 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = strdup("usb-headset-mic");
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]1746 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC] = strdup("usb-headset-mic");
1747 backend_tag_table[SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MULTI_CHANNEL_MIC] = strdup("usb-headset-mic");
1748 backend_tag_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MULTI_CHANNEL_MIC] = strdup("usb-headset-mic");
1749 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC_AEC] = strdup("usb-headset-mic");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1750 backend_tag_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("capture-fm");
1751 backend_tag_table[SND_DEVICE_OUT_TRANSMISSION_FM] = strdup("transmission-fm");
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]1752 backend_tag_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("headphones-dsd");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1753 backend_tag_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("headphones-44.1");
1754 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = strdup("voice-speaker-vbat");
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]1755 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = strdup("voice-speaker-2-vbat");
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]1756 backend_tag_table[SND_DEVICE_OUT_BT_A2DP] = strdup("bt-a2dp");
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]1757 backend_tag_table[SND_DEVICE_IN_BT_A2DP] = strdup("bt-a2dp-cap");
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]1758 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("speaker-and-bt-a2dp");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1759 backend_tag_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP] = strdup("speaker-safe-and-bt-a2dp");
1760 backend_tag_table[SND_DEVICE_OUT_USB_HEADSET_SPEC] = strdup("usb-headset");
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]1761 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = strdup("speaker-and-headphones");
1762 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = strdup("speaker-and-headphones");
1763 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = strdup("speaker-and-headphones");
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]1764 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_HEADPHONES] = strdup("speaker-and-headphones");
1765 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_HEADSET] = strdup("speaker-and-headphones");
1766 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_FB_HEADSET] = strdup("speaker-and-headphones");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1767
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1768 hw_interface_table[SND_DEVICE_OUT_HANDSET] = strdup("SLIMBUS_0_RX");
1769 hw_interface_table[SND_DEVICE_OUT_SPEAKER] = strdup("SLIMBUS_0_RX");
1770 hw_interface_table[SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = strdup("SLIMBUS_0_RX");
1771 hw_interface_table[SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = strdup("SLIMBUS_0_RX");
1772 hw_interface_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = strdup("SLIMBUS_0_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1773 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE] = strdup("SLIMBUS_0_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1774 hw_interface_table[SND_DEVICE_OUT_SPEAKER_VBAT] = strdup("SLIMBUS_0_RX");
1775 hw_interface_table[SND_DEVICE_OUT_LINE] = strdup("SLIMBUS_6_RX");
1776 hw_interface_table[SND_DEVICE_OUT_HEADPHONES] = strdup("SLIMBUS_6_RX");
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]1777 hw_interface_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("SLIMBUS_2_RX");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1778 hw_interface_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("SLIMBUS_5_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1779 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1780 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]1781 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1782 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1783 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]1784 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1785 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1786 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_FB_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1787 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_LINE] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1788 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1789 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1790 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1791 hw_interface_table[SND_DEVICE_OUT_VOICE_HANDSET] = strdup("SLIMBUS_0_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1792 hw_interface_table[SND_DEVICE_OUT_VOICE_HAC_HANDSET] = strdup("SLIMBUS_0_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1793 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER] = strdup("SLIMBUS_0_RX");
1794 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = strdup("SLIMBUS_0_RX");
1795 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2] = strdup("SLIMBUS_0_RX");
1796 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = strdup("SLIMBUS_0_RX");
1797 hw_interface_table[SND_DEVICE_OUT_VOICE_HEADPHONES] = strdup("SLIMBUS_6_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1798 hw_interface_table[SND_DEVICE_OUT_VOICE_MUSIC_TX] = strdup("VOICE_PLAYBACK_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1799 hw_interface_table[SND_DEVICE_OUT_VOICE_LINE] = strdup("SLIMBUS_6_RX");
1800 hw_interface_table[SND_DEVICE_OUT_HDMI] = strdup("HDMI");
1801 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("SLIMBUS_0_RX-and-HDMI");
1802 hw_interface_table[SND_DEVICE_OUT_DISPLAY_PORT] = strdup("DISPLAY_PORT");
1803 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = strdup("SLIMBUS_0_RX-and-DISPLAY_PORT");
1804 hw_interface_table[SND_DEVICE_OUT_BT_SCO] = strdup("SLIMBUS_7_RX");
1805 hw_interface_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("SLIMBUS_7_RX");
1806 hw_interface_table[SND_DEVICE_OUT_BT_A2DP] = strdup("SLIMBUS_7_RX");
1807 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("SLIMBUS_0_RX-and-SLIMBUS_7_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1808 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP] =
1809 strdup("SLIMBUS_0_RX-and-SLIMBUS_7_RX");
1810 hw_interface_table[SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = strdup("SLIMBUS_0_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1811 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = strdup("SLIMBUS_6_RX");
1812 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = strdup("SLIMBUS_6_RX");
1813 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = strdup("SLIMBUS_0_RX");
Aniket Kumar Latab26135f2017-06-16 12:20:04 -0700[diff] [blame]1814 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = strdup("USB_AUDIO_RX");
1815 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = strdup("USB_AUDIO_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1816 hw_interface_table[SND_DEVICE_OUT_VOICE_TX] = strdup("RT_PROXY_DAI_001_RX");
1817 hw_interface_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("RT_PROXY_DAI_001_RX");
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]1818 hw_interface_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("USB_AUDIO_RX");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1819 hw_interface_table[SND_DEVICE_OUT_VOICE_USB_HEADSET] = strdup("USB_AUDIO_RX");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1820 hw_interface_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("USB_AUDIO_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1821 hw_interface_table[SND_DEVICE_OUT_USB_HEADSET_SPEC] = strdup("USB_AUDIO_RX");
1822 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET] =
1823 strdup("SLIMBUS_0_RX-and-USB_AUDIO_RX");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1824 hw_interface_table[SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = strdup("USB_AUDIO_RX");
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]1825 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = strdup("SLIMBUS_0_RX-and-USB_AUDIO_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1826 hw_interface_table[SND_DEVICE_OUT_TRANSMISSION_FM] = strdup("SLIMBUS_8_TX");
1827 hw_interface_table[SND_DEVICE_OUT_ANC_HEADSET] = strdup("SLIMBUS_6_RX");
1828 hw_interface_table[SND_DEVICE_OUT_ANC_FB_HEADSET] = strdup("SLIMBUS_6_RX");
1829 hw_interface_table[SND_DEVICE_OUT_VOICE_ANC_HEADSET] = strdup("SLIMBUS_6_RX");
1830 hw_interface_table[SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = strdup("SLIMBUS_6_RX");
1831 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1832 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1833 hw_interface_table[SND_DEVICE_OUT_ANC_HANDSET] = strdup("SLIMBUS_0_RX");
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]1834 hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
1835 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1836 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = strdup("SLIMBUS_0_RX");
1837 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_SCO] = strdup("SLIMBUS_0_RX-and-SEC_AUX_PCM_RX");
1838 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB] = strdup("SLIMBUS_0_RX-and-SEC_AUX_PCM_RX");
1839 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO] = strdup("QUAT_TDM_RX_0-and-SLIMBUS_7_RX");
1840 hw_interface_table[SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB] = strdup("QUAT_TDM_RX_0-and-SLIMBUS_7_RX");
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]1841 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = strdup("SLIMBUS_0_RX");
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]1842 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED] = strdup("SLIMBUS_0_RX");
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]1843 hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = strdup("SLIMBUS_0_RX");
1844 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = strdup("SLIMBUS_0_RX");
1845 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT] = strdup("SLIMBUS_0_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1846 hw_interface_table[SND_DEVICE_OUT_SPEAKER_WSA] = strdup("SLIMBUS_0_RX");
1847 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_WSA] = strdup("SLIMBUS_0_RX");
1848 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_WSA] = strdup("SLIMBUS_0_RX");
1849 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1850 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = strdup("SLIMBUS_0_TX");
1851 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC] = strdup("SLIMBUS_0_TX");
1852 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_NS] = strdup("SLIMBUS_0_TX");
1853 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1854 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC] = strdup("SLIMBUS_0_TX");
1855 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC] = strdup("SLIMBUS_0_TX");
1856 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_NS] = strdup("SLIMBUS_0_TX");
1857 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1858 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
1859 hw_interface_table[SND_DEVICE_IN_HEADSET_MIC_AEC] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1860 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
1861 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_AEC] = strdup("SLIMBUS_0_TX");
1862 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_NS] = strdup("SLIMBUS_0_TX");
1863 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1864 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC] = strdup("SLIMBUS_0_TX");
1865 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC] = strdup("SLIMBUS_0_TX");
1866 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_NS] = strdup("SLIMBUS_0_TX");
1867 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1868 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1869 hw_interface_table[SND_DEVICE_IN_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
1870 hw_interface_table[SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1871 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
1872 hw_interface_table[SND_DEVICE_IN_VOICE_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]1873 hw_interface_table[SND_DEVICE_IN_SPDIF] = strdup("PRI_SPDIF_TX");
1874 hw_interface_table[SND_DEVICE_IN_HDMI_MIC] = strdup("SEC_MI2S_TX");
1875 hw_interface_table[SND_DEVICE_IN_HDMI_ARC] = strdup("SEC_SPDIF_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1876 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("SLIMBUS_7_TX");
1877 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("SLIMBUS_7_TX");
1878 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("SLIMBUS_7_TX");
1879 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("SLIMBUS_7_TX");
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]1880 hw_interface_table[SND_DEVICE_IN_BT_A2DP] = strdup("SLIMBUS_7_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1881 hw_interface_table[SND_DEVICE_IN_CAMCORDER_MIC] = strdup("SLIMBUS_0_TX");
1882 hw_interface_table[SND_DEVICE_IN_VOICE_DMIC] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1883 hw_interface_table[SND_DEVICE_IN_VOICE_DMIC_TMUS] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1884 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1885 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = strdup("SLIMBUS_0_TX");
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]1886 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_TMIC] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1887 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = strdup("SLIMBUS_0_TX");
1888 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
1889 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1890 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1891 hw_interface_table[SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Aniket Kumar Latab26135f2017-06-16 12:20:04 -0700[diff] [blame]1892 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = strdup("USB_AUDIO_TX");
1893 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = strdup("USB_AUDIO_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1894 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC] = strdup("SLIMBUS_0_TX");
1895 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_NS] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1896 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_AEC] = strdup("SLIMBUS_0_TX");
1897 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1898 hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
1899 hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1900 hw_interface_table[SND_DEVICE_IN_VOICE_RX] = strdup("RT_PROXY_DAI_002_TX");
1901 hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1902 hw_interface_table[SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
1903 hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = strdup("USB_AUDIO_TX");
1904 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
1905 hw_interface_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]1906 hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC] = strdup("USB_AUDIO_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1907 hw_interface_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("SLIMBUS_8_TX");
1908 hw_interface_table[SND_DEVICE_IN_AANC_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1909 hw_interface_table[SND_DEVICE_IN_QUAD_MIC] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1910 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
1911 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1912 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = strdup("SLIMBUS_4_TX");
1913 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = strdup("SLIMBUS_4_TX");
1914 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = strdup("SLIMBUS_4_TX");
1915 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1916 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1917 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1918 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = strdup("SLIMBUS_0_TX");
1919 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = strdup("SLIMBUS_0_TX");
1920 hw_interface_table[SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = strdup("SLIMBUS_0_TX");
1921 hw_interface_table[SND_DEVICE_IN_HANDSET_QMIC] = strdup("SLIMBUS_0_TX");
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1922 hw_interface_table[SND_DEVICE_IN_HANDSET_QMIC_AEC] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1923 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_AEC] = strdup("SLIMBUS_0_TX");
1924 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_NS] = strdup("SLIMBUS_0_TX");
1925 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1926 hw_interface_table[SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1927 hw_interface_table[SND_DEVICE_IN_THREE_MIC] = strdup("SLIMBUS_0_TX");
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]1928 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC_FLUENCE_PRO] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1929 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC] = strdup("SLIMBUS_0_TX");
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]1930 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC_AEC] = strdup("SLIMBUS_0_TX");
1931 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC_NS] = strdup("SLIMBUS_0_TX");
1932 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]1933 hw_interface_table[SND_DEVICE_IN_SPEAKER_TMIC_AEC] = strdup("SLIMBUS_0_TX");
1934 hw_interface_table[SND_DEVICE_IN_SPEAKER_TMIC_NS] = strdup("SLIMBUS_0_TX");
1935 hw_interface_table[SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1936 hw_interface_table[SND_DEVICE_IN_VOICE_REC_TMIC] = strdup("SLIMBUS_0_TX");
1937 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_MIC] = strdup("SLIMBUS_0_TX");
1938 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = strdup("SLIMBUS_0_TX");
1939 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = strdup("SLIMBUS_0_TX");
1940 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = strdup("SLIMBUS_0_TX");
1941 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]1942 hw_interface_table[SND_DEVICE_IN_HANDSET_GENERIC_QMIC] = strdup("SLIMBUS_0_TX");
Divya Narayanan Poojary85d0a592018-02-06 14:25:16 +0530[diff] [blame]1943 hw_interface_table[SND_DEVICE_IN_INCALL_REC_RX] = strdup("INCALL_RECORD_RX");
1944 hw_interface_table[SND_DEVICE_IN_INCALL_REC_TX] = strdup("INCALL_RECORD_TX");
Ramu Gottipati813ae982018-07-25 14:14:48 +0530[diff] [blame]1945 hw_interface_table[SND_DEVICE_IN_LINE] = strdup("SLIMBUS_0_TX");
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1946
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1947 my_data->max_mic_count = PLATFORM_DEFAULT_MIC_COUNT;
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1948
1949 /*remove ALAC & APE from DSP decoder list based on software decoder availability*/
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]1950 for (count = 0; count < (int32_t)(sizeof(dsp_only_decoders_mime)/sizeof(dsp_only_decoders_mime[0]));
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1951 count++) {
1952
1953 if (!strncmp(MEDIA_MIMETYPE_AUDIO_ALAC, dsp_only_decoders_mime[count],
1954 strlen(dsp_only_decoders_mime[count]))) {
1955
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]1956 if(property_get_bool("vendor.audio.use.sw.alac.decoder", false)) {
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1957 ALOGD("Alac software decoder is available...removing alac from DSP decoder list");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1958 strlcpy(dsp_only_decoders_mime[count],"none",5);
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1959 }
1960 } else if (!strncmp(MEDIA_MIMETYPE_AUDIO_APE, dsp_only_decoders_mime[count],
1961 strlen(dsp_only_decoders_mime[count]))) {
1962
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]1963 if(property_get_bool("vendor.audio.use.sw.ape.decoder", false)) {
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1964 ALOGD("APE software decoder is available...removing ape from DSP decoder list");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1965 strlcpy(dsp_only_decoders_mime[count],"none",5);
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1966 }
1967 }
1968 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1969}
1970
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]1971void get_cvd_version(char *cvd_version, struct audio_device *adev)
1972{
1973 struct mixer_ctl *ctl;
1974 int count;
1975 int ret = 0;
1976
1977 ctl = mixer_get_ctl_by_name(adev->mixer, CVD_VERSION_MIXER_CTL);
1978 if (!ctl) {
1979 ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, CVD_VERSION_MIXER_CTL);
1980 goto done;
1981 }
1982 mixer_ctl_update(ctl);
1983
1984 count = mixer_ctl_get_num_values(ctl);
1985 if (count > MAX_CVD_VERSION_STRING_SIZE)
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]1986 count = MAX_CVD_VERSION_STRING_SIZE - 1;
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]1987
1988 ret = mixer_ctl_get_array(ctl, cvd_version, count);
1989 if (ret != 0) {
1990 ALOGE("%s: ERROR! mixer_ctl_get_array() failed to get CVD Version", __func__);
1991 goto done;
1992 }
1993
1994done:
1995 return;
1996}
1997
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1998static int hw_util_open(int card_no)
1999{
2000 int fd = -1;
2001 char dev_name[256];
2002
2003 snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
2004 card_no, WCD9XXX_CODEC_HWDEP_NODE);
2005 ALOGD("%s Opening device %s\n", __func__, dev_name);
2006 fd = open(dev_name, O_WRONLY);
2007 if (fd < 0) {
2008 ALOGE("%s: cannot open device '%s'\n", __func__, dev_name);
2009 return fd;
2010 }
2011 ALOGD("%s success", __func__);
2012 return fd;
2013}
2014
2015struct param_data {
2016 int use_case;
2017 int acdb_id;
2018 int get_size;
2019 int buff_size;
2020 int data_size;
2021 void *buff;
2022};
2023
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2024static int send_vbat_adc_data_to_acdb(struct platform_data *plat_data, char *cal_type)
2025{
2026 int ret = 0;
2027 struct mixer_ctl *ctl;
2028 uint16_t vbat_adc_data[2];
2029 struct platform_data *my_data = plat_data;
2030 struct audio_device *adev = my_data->adev;
2031
2032 const char *mixer_ctl_name = "Vbat ADC data";
2033
2034 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
2035 if (!ctl) {
2036 ALOGE("%s: Could not get ctl for mixer ctl name - %s",
2037 __func__, mixer_ctl_name);
2038 ret = -EINVAL;
2039 goto done;
2040 }
2041
2042 vbat_adc_data[0] = mixer_ctl_get_value(ctl, 0);
2043 vbat_adc_data[1] = mixer_ctl_get_value(ctl, 1);
2044
2045 ALOGD("%s: Vbat ADC output values: Dcp1: %d , Dcp2: %d",
2046 __func__, vbat_adc_data[0], vbat_adc_data[1]);
2047
2048 ret = my_data->acdb_set_codec_data(&vbat_adc_data[0], cal_type);
2049
2050done:
2051 return ret;
2052}
2053
2054static void send_codec_cal(acdb_loader_get_calibration_t acdb_loader_get_calibration,
2055 struct platform_data *plat_data, int fd)
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2056{
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2057 int type;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2058
2059 for (type = WCD9XXX_ANC_CAL; type < WCD9XXX_MAX_CAL; type++) {
2060 struct wcdcal_ioctl_buffer codec_buffer;
2061 struct param_data calib;
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2062 int ret;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2063
Bharath Ramachandramurthy63a47ef2015-08-31 17:41:46 -0700[diff] [blame]2064 /* MAD calibration is handled by sound trigger HAL, skip here */
2065 if (type == WCD9XXX_MAD_CAL)
2066 continue;
2067
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2068 ret = 0;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2069
Banajit Goswami4dc87fb2015-10-11 21:46:07 -0700[diff] [blame]2070 if ((plat_data->is_vbat_speaker) && (WCD9XXX_VBAT_CAL == type)) {
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]2071 /* VBAT BCL speaker does not need tuning data */
2072 if (!plat_data->is_bcl_speaker)
2073 return;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2074 ret = send_vbat_adc_data_to_acdb(plat_data, cal_name_info[type]);
2075 if (ret < 0)
2076 ALOGE("%s error in sending vbat adc data to acdb", __func__);
2077 }
2078
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2079 calib.get_size = 1;
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2080 ret = acdb_loader_get_calibration(cal_name_info[type],
2081 sizeof(struct param_data),
2082 &calib);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2083 if (ret < 0) {
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2084 ALOGE("%s: %s get_calibration size failed, err = %d\n",
2085 __func__, cal_name_info[type], ret);
2086 continue;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2087 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2088
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2089 calib.get_size = 0;
2090 calib.buff = malloc(calib.buff_size);
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2091 if (!calib.buff) {
2092 ALOGE("%s: %s: No Memory for size = %d\n",
2093 __func__, cal_name_info[type], calib.buff_size);
2094 continue;
2095 }
2096
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2097 ret = acdb_loader_get_calibration(cal_name_info[type],
2098 sizeof(struct param_data), &calib);
2099 if (ret < 0) {
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2100 ALOGE("%s: %s get_calibration failed, err = %d\n",
2101 __func__, cal_name_info[type], ret);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2102 free(calib.buff);
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2103 continue;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2104 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2105
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2106 codec_buffer.buffer = calib.buff;
2107 codec_buffer.size = calib.data_size;
2108 codec_buffer.cal_type = type;
2109 if (ioctl(fd, SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE, &codec_buffer) < 0)
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2110 ALOGE("%s: %s Failed to call ioctl, err=%d",
2111 __func__, cal_name_info[type], errno);
2112 else
2113 ALOGD("%s: %s cal sent successfully\n",
2114 __func__, cal_name_info[type]);
2115
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2116 free(calib.buff);
2117 }
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2118}
2119
2120static void audio_hwdep_send_cal(struct platform_data *plat_data)
2121{
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2122 int fd = plat_data->hw_dep_fd;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2123
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2124 if (fd < 0)
2125 fd = hw_util_open(plat_data->adev->snd_card);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2126 if (fd == -1) {
2127 ALOGE("%s error open\n", __func__);
2128 return;
2129 }
2130
2131 acdb_loader_get_calibration = (acdb_loader_get_calibration_t)
2132 dlsym(plat_data->acdb_handle, "acdb_loader_get_calibration");
2133
2134 if (acdb_loader_get_calibration == NULL) {
2135 ALOGE("%s: ERROR. dlsym Error:%s acdb_loader_get_calibration", __func__,
2136 dlerror());
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2137 if (fd >= 0) {
2138 close(fd);
2139 plat_data->hw_dep_fd = -1;
2140 }
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2141 return;
2142 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]2143
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2144 send_codec_cal(acdb_loader_get_calibration, plat_data, fd);
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2145 plat_data->hw_dep_fd = fd;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]2146}
2147
Aditya Bavanari71b6d532018-01-16 17:48:08 +0530[diff] [blame]2148const char * platform_get_snd_card_name_for_acdb_loader(const char *snd_card_name) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2149
2150 if(snd_card_name == NULL)
2151 return NULL;
2152
2153 if(!strncmp(snd_card_name, "sdm660-tashalite-snd-card",
2154 sizeof("sdm660-tashalite-snd-card"))) {
2155 ALOGD("using tasha ACDB files for tasha-lite");
2156 return "sdm660-tasha-snd-card";
2157 }
Sharad Sangled39232d2017-08-08 20:27:18 +0530[diff] [blame]2158 if(!strncmp(snd_card_name, "sdm670-tashalite-snd-card",
2159 sizeof("sdm670-tashalite-snd-card"))) {
2160 ALOGD("using tasha ACDB files for tasha-lite");
2161 return "sdm670-tasha-snd-card";
2162 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2163 return snd_card_name;
2164}
2165
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2166static int platform_acdb_init(void *platform)
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2167{
2168 struct platform_data *my_data = (struct platform_data *)platform;
2169 char *cvd_version = NULL;
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2170 const char *snd_card_name;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2171 int result = -1;
2172 struct listnode *node;
2173 struct meta_key_list *key_info;
2174 int key = 0;
2175
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2176 cvd_version = calloc(1, MAX_CVD_VERSION_STRING_SIZE);
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]2177 if (!cvd_version) {
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2178 ALOGE("Failed to allocate cvd version");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]2179 return -1;
2180 } else {
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2181 get_cvd_version(cvd_version, my_data->adev);
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]2182 }
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2183
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2184 snd_card_name = mixer_get_name(my_data->adev->mixer);
Aditya Bavanari71b6d532018-01-16 17:48:08 +0530[diff] [blame]2185 snd_card_name = platform_get_snd_card_name_for_acdb_loader(snd_card_name);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2186
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]2187 my_data->acdb_init_data.cvd_version = cvd_version;
2188 my_data->acdb_init_data.snd_card_name = strdup(snd_card_name);
2189 my_data->acdb_init_data.meta_key_list = &my_data->acdb_meta_key_list;
2190 if (my_data->acdb_init_v4) {
2191 result = my_data->acdb_init_v4(&my_data->acdb_init_data, ACDB_LOADER_INIT_V4);
2192 } else if (my_data->acdb_init_v3) {
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2193 result = my_data->acdb_init_v3(snd_card_name, cvd_version,
2194 &my_data->acdb_meta_key_list);
2195 } else if (my_data->acdb_init) {
2196 node = list_head(&my_data->acdb_meta_key_list);
2197 key_info = node_to_item(node, struct meta_key_list, list);
2198 key = key_info->cal_info.nKey;
2199 result = my_data->acdb_init(snd_card_name, cvd_version, key);
2200 }
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]2201
2202 /* Save these variables in platform_data. These will be used
2203 while reloading ACDB files during run time. */
2204 strlcpy(my_data->cvd_version, cvd_version, MAX_CVD_VERSION_STRING_SIZE);
2205 strlcpy(my_data->snd_card_name, snd_card_name,
2206 MAX_SND_CARD_STRING_SIZE);
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]2207
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2208 if (cvd_version)
2209 free(cvd_version);
2210 if (!result) {
2211 my_data->is_acdb_initialized = true;
2212 ALOGD("ACDB initialized");
2213 audio_hwdep_send_cal(my_data);
2214 } else {
2215 my_data->is_acdb_initialized = false;
2216 ALOGD("ACDB initialization failed");
2217 }
2218 return result;
2219}
2220
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2221static void get_source_mic_type(struct platform_data * my_data)
2222{
2223 // support max to mono, example if max count is 3, usecase supports Three, dual and mono mic
2224 switch (my_data->max_mic_count) {
2225 case 4:
2226 my_data->source_mic_type |= SOURCE_QUAD_MIC;
2227 case 3:
2228 my_data->source_mic_type |= SOURCE_THREE_MIC;
2229 case 2:
2230 my_data->source_mic_type |= SOURCE_DUAL_MIC;
2231 case 1:
2232 my_data->source_mic_type |= SOURCE_MONO_MIC;
2233 break;
2234 default:
2235 ALOGE("%s: max_mic_count (%d), is not supported, setting to default",
2236 __func__, my_data->max_mic_count);
2237 my_data->source_mic_type = SOURCE_MONO_MIC | SOURCE_DUAL_MIC;
2238 break;
2239 }
2240}
2241
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2242/*
2243 * Retrieves the be_dai_name_table from kernel to enable a mapping
2244 * between sound device hw interfaces and backend IDs. This allows HAL to
2245 * specify the backend a specific calibration is needed for.
2246 */
2247static int init_be_dai_name_table(struct audio_device *adev)
2248{
2249 const char *mixer_ctl_name = "Backend DAI Name Table";
2250 struct mixer_ctl *ctl;
2251 int i, j, ret, size;
2252 bool valid_hw_interface;
2253
2254 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
2255 if (!ctl) {
2256 ALOGE("%s: Could not get ctl for mixer name %s\n",
2257 __func__, mixer_ctl_name);
2258 ret = -EINVAL;
2259 goto done;
2260 }
2261
2262 mixer_ctl_update(ctl);
2263
2264 size = mixer_ctl_get_num_values(ctl);
2265 if (size <= 0){
2266 ALOGE("%s: Failed to get %s size %d\n",
2267 __func__, mixer_ctl_name, size);
2268 ret = -EFAULT;
2269 goto done;
2270 }
2271
2272 be_dai_name_table =
2273 (const struct be_dai_name_struct *)calloc(1, size);
2274 if (be_dai_name_table == NULL) {
2275 ALOGE("%s: Failed to allocate memory for %s\n",
2276 __func__, mixer_ctl_name);
2277 ret = -ENOMEM;
2278 goto freeMem;
2279 }
2280
2281 ret = mixer_ctl_get_array(ctl, (void *)be_dai_name_table, size);
2282 if (ret) {
2283 ALOGE("%s: Failed to get %s, ret %d\n",
2284 __func__, mixer_ctl_name, ret);
2285 ret = -EFAULT;
2286 goto freeMem;
2287 }
2288
2289 if (be_dai_name_table != NULL) {
2290 max_be_dai_names = size / sizeof(struct be_dai_name_struct);
2291 ALOGV("%s: Successfully got %s, number of be dais is %d\n",
2292 __func__, mixer_ctl_name, max_be_dai_names);
2293 ret = 0;
2294 } else {
2295 ALOGE("%s: Failed to get %s\n", __func__, mixer_ctl_name);
2296 ret = -EFAULT;
2297 goto freeMem;
2298 }
2299
2300 /*
2301 * Validate all sound devices have a valid backend set to catch
2302 * errors for uncommon sound devices
2303 */
2304 for (i = 0; i < SND_DEVICE_MAX; i++) {
2305 valid_hw_interface = false;
2306
2307 if (hw_interface_table[i] == NULL) {
2308 ALOGW("%s: sound device %s has no hw interface set\n",
2309 __func__, platform_get_snd_device_name(i));
2310 continue;
2311 }
2312
2313 for (j = 0; j < max_be_dai_names; j++) {
2314 if (strcmp(hw_interface_table[i], be_dai_name_table[j].be_name)
2315 == 0) {
2316 valid_hw_interface = true;
2317 break;
2318 }
2319 }
2320 if (!valid_hw_interface)
2321 ALOGD("%s: sound device %s does not have a valid hw interface set (disregard for combo devices) %s\n",
2322 __func__, platform_get_snd_device_name(i), hw_interface_table[i]);
2323 }
2324
2325 goto done;
2326
2327freeMem:
2328 if (be_dai_name_table) {
2329 free((void *)be_dai_name_table);
2330 be_dai_name_table = NULL;
2331 }
2332
2333done:
2334 return ret;
2335}
2336
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2337#ifdef FLICKER_SENSOR_INPUT
2338static void configure_flicker_sensor_input(struct mixer *mixer)
2339{
2340 struct mixer_ctl *ctl;
2341 const char* ctl1 = "AIF3_CAP Mixer SLIM TX2";
2342 int setting1 = 1;
2343 const char* ctl2 = "CDC_IF TX2 MUX";
2344 const char* setting2 = "DEC2";
2345 const char* ctl3 = "SLIM_1_TX Channels";
2346 const char* setting3 = "One";
2347 const char* ctl4 = "ADC MUX2";
2348 const char* setting4 = "AMIC";
2349 const char* ctl5 = "AMIC MUX2";
2350 const char* setting5 = "ADC1";
2351 const char* ctl6 = "DEC2 Volume";
2352 int setting6 = 84;
2353 const char* ctl7 = "MultiMedia9 Mixer SLIM_1_TX";
2354 int setting7 = 1;
2355 const char* ctl8 = "SLIM_1_TX SampleRate";
2356 const char* setting8 = "KHZ_8";
2357
2358 ctl = mixer_get_ctl_by_name(mixer, ctl1);
2359 mixer_ctl_set_value(ctl, 0, setting1);
2360 ctl = mixer_get_ctl_by_name(mixer, ctl2);
2361 mixer_ctl_set_enum_by_string(ctl, setting2);
2362 ctl = mixer_get_ctl_by_name(mixer, ctl3);
2363 mixer_ctl_set_enum_by_string(ctl, setting3);
2364 ctl = mixer_get_ctl_by_name(mixer, ctl4);
2365 mixer_ctl_set_enum_by_string(ctl, setting4);
2366 ctl = mixer_get_ctl_by_name(mixer, ctl5);
2367 mixer_ctl_set_enum_by_string(ctl, setting5);
2368 ctl = mixer_get_ctl_by_name(mixer, ctl6);
2369 mixer_ctl_set_value(ctl, 0, setting6);
2370 ctl = mixer_get_ctl_by_name(mixer, ctl7);
2371 mixer_ctl_set_value(ctl, 0, setting7);
2372 ctl = mixer_get_ctl_by_name(mixer, ctl8);
2373 mixer_ctl_set_enum_by_string(ctl, setting8);
2374}
2375#endif
2376
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2377void *platform_init(struct audio_device *adev)
2378{
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]2379 char platform[PROPERTY_VALUE_MAX];
2380 char baseband[PROPERTY_VALUE_MAX];
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2381 char value[PROPERTY_VALUE_MAX];
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]2382 struct platform_data *my_data = NULL;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2383 char *snd_card_name = NULL;
Apoorv Raghuvanshia433fb52015-03-16 15:22:30 -0700[diff] [blame]2384 char mixer_xml_file[MIXER_PATH_MAX_LENGTH]= {0};
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2385 char platform_info_file[MIXER_PATH_MAX_LENGTH]= {0};
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]2386 int idx;
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]2387 struct mixer_ctl *ctl = NULL;
2388 const char *id_string = NULL;
2389 int cfg_value = -1;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2390 bool dual_mic_config = false;
2391 struct snd_card_split *snd_split_handle = NULL;
2392
2393 list_init(&operator_info_list);
2394 list_init(&app_type_entry_list);
sangwoo1b9f4b32013-06-21 18:22:55 -0700[diff] [blame]2395
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2396 adev->snd_card = audio_extn_utils_open_snd_mixer(&adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2397 if (adev->snd_card < 0) {
2398 ALOGE("%s: Unable to find correct sound card", __func__);
2399 return NULL;
2400 }
2401 ALOGD("%s: Opened sound card:%d", __func__, adev->snd_card);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2402
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2403 snd_card_name = strdup(mixer_get_name(adev->mixer));
2404 if (!snd_card_name) {
2405 ALOGE("failed to allocate memory for snd_card_name\n");
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2406 audio_extn_utils_close_snd_mixer(adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2407 return NULL;
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]2408 }
2409
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2410 audio_extn_set_snd_card_split(snd_card_name);
2411 snd_split_handle = audio_extn_get_snd_card_split();
2412
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2413 my_data = calloc(1, sizeof(struct platform_data));
2414 if (!my_data) {
2415 ALOGE("failed to allocate platform data");
2416 if (snd_card_name)
2417 free(snd_card_name);
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2418 audio_extn_utils_close_snd_mixer(adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2419 return NULL;
2420 }
2421
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2422 my_data->is_slimbus_interface = true;
2423 my_data->is_internal_codec = false;
2424
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2425 my_data->hw_info = hw_info_init(snd_card_name);
2426 if (!my_data->hw_info) {
2427 ALOGE("failed to init hw_info");
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2428 audio_extn_utils_close_snd_mixer(adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2429 if (my_data)
2430 free(my_data);
2431
2432 if (snd_card_name)
2433 free(snd_card_name);
2434 return NULL;
2435 }
2436
2437 if (platform_is_i2s_ext_modem(snd_card_name, my_data)) {
2438 ALOGD("%s: Call MIXER_XML_PATH_I2S", __func__);
2439
2440 adev->audio_route = audio_route_init(adev->snd_card,
2441 MIXER_XML_PATH_I2S);
2442 } else {
2443 /* Get the codec internal name from the sound card name
2444 * and form the mixer paths file name dynamically. This
2445 * is generic way of picking any codec name based mixer
2446 * files in future with no code change. This code
2447 * assumes mixer files are formed with format as
2448 * mixer_paths_internalcodecname.xml
2449
2450 * If this dynamically read mixer files fails to open then it
2451 * falls back to default mixer file i.e mixer_paths.xml. This is
2452 * done to preserve backward compatibility but not mandatory as
2453 * long as the mixer files are named as per above assumption.
2454 */
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2455 snprintf(mixer_xml_file, sizeof(mixer_xml_file), "%s_%s_%s.xml",
2456 MIXER_XML_BASE_STRING, snd_split_handle->snd_card,
2457 snd_split_handle->form_factor);
2458 if (!audio_extn_utils_resolve_config_file(mixer_xml_file)) {
2459 memset(mixer_xml_file, 0, sizeof(mixer_xml_file));
2460 snprintf(mixer_xml_file, sizeof(mixer_xml_file), "%s_%s.xml",
2461 MIXER_XML_BASE_STRING, snd_split_handle->snd_card);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2462
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2463 if (!audio_extn_utils_resolve_config_file(mixer_xml_file)) {
2464 memset(mixer_xml_file, 0, sizeof(mixer_xml_file));
2465 strlcpy(mixer_xml_file, MIXER_XML_DEFAULT_PATH, MIXER_PATH_MAX_LENGTH);
2466 audio_extn_utils_resolve_config_file(mixer_xml_file);
2467 }
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2468 }
2469
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2470 ALOGD("%s: Loading mixer file: %s", __func__, mixer_xml_file);
2471 if (audio_extn_read_xml(adev, adev->snd_card, mixer_xml_file,
2472 MIXER_XML_PATH_AUXPCM) == -ENOSYS) {
2473 adev->audio_route = audio_route_init(adev->snd_card, mixer_xml_file);
2474 update_codec_type_and_interface(my_data, snd_card_name);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2475 }
2476 }
2477 if (!adev->audio_route) {
2478 ALOGE("%s: Failed to init audio route controls, aborting.",
2479 __func__);
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]2480 if (my_data)
2481 free(my_data);
Ravi Kumar Alamanda31c90df2015-10-16 10:06:59 -0700[diff] [blame]2482 if (snd_card_name)
2483 free(snd_card_name);
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2484 audio_extn_utils_close_snd_mixer(adev->mixer);
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]2485 return NULL;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]2486 }
2487
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]2488 adev->dp_allowed_for_voice =
2489 property_get_bool("vendor.audio.enable.dp.for.voice", false);
2490
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2491 my_data->adev = adev;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2492 my_data->fluence_in_spkr_mode = false;
2493 my_data->fluence_in_voice_call = false;
2494 my_data->fluence_in_voice_rec = false;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]2495 my_data->fluence_in_audio_rec = false;
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2496 my_data->fluence_in_hfp_call = false;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]2497 my_data->external_spk_1 = false;
2498 my_data->external_spk_2 = false;
2499 my_data->external_mic = false;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2500 my_data->fluence_type = FLUENCE_NONE;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2501 my_data->fluence_mode = FLUENCE_ENDFIRE;
Sachin Mohan Gadagbe2054d2018-01-29 16:05:05 +0530[diff] [blame]2502 my_data->ambisonic_capture = false;
2503 my_data->ambisonic_profile = false;
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]2504 my_data->slowtalk = false;
2505 my_data->hd_voice = false;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]2506 my_data->edid_info = NULL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]2507 my_data->ext_disp_type = EXT_DISPLAY_TYPE_NONE;
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2508 my_data->hw_dep_fd = -1;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]2509 my_data->mono_speaker = SPKR_1;
Aalique Grahame5f596f32018-01-09 12:56:35 -0800[diff] [blame]2510 my_data->speaker_lr_swap = false;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]2511 my_data->voice_speaker_stereo = false;
Naresh Tannirudcb47c52018-06-25 16:23:32 +0530[diff] [blame]2512 my_data->declared_mic_count = 0;
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]2513 my_data->spkr_ch_map = NULL;
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]2514 my_data->use_sprk_default_sample_rate = true;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2515 my_data->fluence_in_voice_comm = false;
2516
2517 //set max volume step for voice call
2518 property_get("ro.config.vc_call_vol_steps", value, TOSTRING(MAX_VOL_INDEX));
2519 my_data->max_vol_index = atoi(value);
2520
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2521 be_dai_name_table = NULL;
2522
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2523 property_get("persist.audio.dualmic.config",value,"");
2524 if (!strcmp("endfire", value)) {
2525 dual_mic_config = true;
2526 }
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]2527
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2528 my_data->fluence_type = FLUENCE_NONE;
2529 if ((property_get("ro.vendor.audio.sdk.fluencetype",
2530 my_data->fluence_cap, NULL) > 0) ||
2531 (property_get("ro.qc.sdk.audio.fluencetype",
2532 my_data->fluence_cap, NULL) > 0)) {
2533 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) {
2534 my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]2535
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2536 if (property_get_bool("persist.vendor.audio.fluence.tmic.enabled",false)) {
2537 my_data->fluence_type |= FLUENCE_TRI_MIC;
2538 }
2539 } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence")) ||
2540 dual_mic_config) {
2541 my_data->fluence_type = FLUENCE_DUAL_MIC;
2542
2543 if (property_get_bool("persist.vendor.audio.fluence.tmic.enabled",false)) {
2544 my_data->fluence_type |= FLUENCE_TRI_MIC;
2545 }
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]2546 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2547 }
2548
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2549 if (my_data->fluence_type != FLUENCE_NONE) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2550 if ((property_get("persist.vendor.audio.fluence.voicecall",
2551 value,NULL) > 0) ||
2552 (property_get("persist.audio.fluence.voicecall",value,NULL) > 0)) {
2553 if (!strncmp("true", value, sizeof("true")))
2554 my_data->fluence_in_voice_call = true;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2555 }
2556
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2557 if ((property_get("persist.vendor.audio.fluence.voicerec",
2558 value,NULL) > 0) ||
2559 (property_get("persist.audio.fluence.voicerec",value,NULL) > 0)) {
2560 if (!strncmp("true", value, sizeof("true")))
2561 my_data->fluence_in_voice_rec = true;
2562 }
2563
2564 property_get("persist.audio.fluence.voicecomm",value,"");
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2565 if (!strncmp("true", value, sizeof("true"))) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2566 my_data->fluence_in_voice_comm = true;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2567 }
2568
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2569 property_get("persist.vendor.audio.fluence.audiorec",value,"");
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]2570 if (!strncmp("true", value, sizeof("true"))) {
2571 my_data->fluence_in_audio_rec = true;
2572 }
2573
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2574 if ((property_get("persist.vendor.audio.fluence.speaker",
2575 value,NULL) > 0) ||
2576 (property_get("persist.audio.fluence.speaker",value,NULL) > 0)) {
2577 if (!strncmp("true", value, sizeof("true"))) {
2578 my_data->fluence_in_spkr_mode = true;
2579 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2580 }
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2581
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2582 property_get("persist.vendor.audio.fluence.mode",value,"");
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2583 if (!strncmp("broadside", value, sizeof("broadside"))) {
2584 my_data->fluence_mode = FLUENCE_BROADSIDE;
2585 }
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2586
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2587 property_get("persist.vendor.audio.fluence.hfpcall",value,"");
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2588 if (!strncmp("true", value, sizeof("true"))) {
2589 my_data->fluence_in_hfp_call = true;
2590 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2591 }
Sachin Mohan Gadagbe2054d2018-01-29 16:05:05 +0530[diff] [blame]2592 /* Check for Ambisonic Capture Enablement */
2593 if (property_get_bool("persist.vendor.audio.ambisonic.capture",false))
2594 my_data->ambisonic_capture = true;
2595
2596 /* Check for Ambisonic Profile Assignment*/
2597 if (property_get_bool("persist.vendor.audio.ambisonic.auto.profile",false))
2598 my_data->ambisonic_profile = true;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2599
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]2600 my_data->voice_speaker_stereo =
2601 property_get_bool("persist.vendor.audio.voicecall.speaker.stereo", false);
2602
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2603 /* Check if Vbat speaker enabled property is set, this should be done before acdb init */
2604 bool ret = false;
2605 ret = audio_extn_can_use_vbat();
2606 if (ret)
2607 my_data->is_vbat_speaker = true;
2608
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]2609 ret = audio_extn_can_use_bcl();
2610 if (ret)
2611 my_data->is_bcl_speaker = true;
2612
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2613 list_init(&my_data->acdb_meta_key_list);
2614
2615 set_platform_defaults(my_data);
2616
2617 /* Initialize ACDB ID's */
2618 if (my_data->is_i2s_ext_modem)
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2619 platform_info_init(PLATFORM_INFO_XML_PATH_I2S, my_data, PLATFORM);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2620 else if (!strncmp(snd_card_name, "sdm660-snd-card-skush",
2621 sizeof("sdm660-snd-card-skush")))
2622 platform_info_init(PLATFORM_INFO_XML_PATH_SKUSH, my_data, PLATFORM);
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]2623 else if (!strncmp(snd_card_name, "sdm670-skuw-snd-card",
2624 sizeof("sdm670-skuw-snd-card")))
2625 platform_info_init(PLATFORM_INFO_XML_PATH_SKUW, my_data, PLATFORM);
kunleiz291f3412018-09-04 16:04:44 +0800[diff] [blame]2626 else if (!strncmp(snd_card_name, "sm6150-qrd-snd-card",
2627 sizeof("sm6150-qrd-snd-card")))
2628 platform_info_init(PLATFORM_INFO_XML_PATH_QRD, my_data, PLATFORM);
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]2629 else if (!strncmp(snd_card_name, "kona-qrd-snd-card",
2630 sizeof("kona-qrd-snd-card")))
2631 platform_info_init(PLATFORM_INFO_XML_PATH_QRD, my_data, PLATFORM);
Ramu Gottipati54ed9482018-08-21 16:00:22 +0530[diff] [blame]2632 else if (!strncmp(snd_card_name, "qcs405-wsa-snd-card",
2633 sizeof("qcs405-wsa-snd-card")))
2634 platform_info_init(PLATFORM_INFO_XML_PATH_WSA, my_data, PLATFORM);
Dhananjay Kumarb34c5c12018-09-25 16:04:26 +0530[diff] [blame]2635 else if (!strncmp(snd_card_name, "qcs405-tdm-snd-card",
2636 sizeof("qcs405-tdm-snd-card")))
2637 platform_info_init(PLATFORM_INFO_XML_PATH_TDM, my_data, PLATFORM);
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]2638 else if (my_data->is_internal_codec)
2639 platform_info_init(PLATFORM_INFO_XML_PATH_INTCODEC, my_data, PLATFORM);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2640 else {
2641 // Try to load pixel or default
2642 audio_extn_utils_get_platform_info(snd_card_name, platform_info_file);
2643 platform_info_init(platform_info_file, my_data, PLATFORM);
2644 }
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2645
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]2646 /* CSRA devices support multiple sample rates via I2S at spkr out */
2647 if (!strncmp(snd_card_name, "qcs405-csra", strlen("qcs405-csra"))) {
2648 ALOGE("%s: soundcard: %s supports multiple sample rates", __func__, snd_card_name);
2649 my_data->use_sprk_default_sample_rate = false;
2650 } else {
2651 my_data->use_sprk_default_sample_rate = true;
2652 ALOGE("%s: soundcard: %s supports only default sample rate", __func__, snd_card_name);
2653 }
2654
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2655 my_data->voice_feature_set = VOICE_FEATURE_SET_DEFAULT;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2656 my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
2657 if (my_data->acdb_handle == NULL) {
2658 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER);
2659 } else {
2660 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);
2661 my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle,
2662 "acdb_loader_deallocate_ACDB");
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2663 if (!my_data->acdb_deallocate)
2664 ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s",
2665 __func__, LIB_ACDB_LOADER);
2666
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2667 my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle,
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]2668 "acdb_loader_send_audio_cal_v2");
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2669 if (!my_data->acdb_send_audio_cal)
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2670 ALOGE("%s: Could not find the symbol acdb_send_audio_cal_v2 from %s",
2671 __func__, LIB_ACDB_LOADER);
2672
2673 my_data->acdb_send_audio_cal_v3 = (acdb_send_audio_cal_v3_t)dlsym(my_data->acdb_handle,
2674 "acdb_loader_send_audio_cal_v3");
2675 if (!my_data->acdb_send_audio_cal_v3)
2676 ALOGE("%s: Could not find the symbol acdb_send_audio_cal_v3 from %s",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2677 __func__, LIB_ACDB_LOADER);
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2678
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]2679 my_data->acdb_set_audio_cal = (acdb_set_audio_cal_t)dlsym(my_data->acdb_handle,
2680 "acdb_loader_set_audio_cal_v2");
2681 if (!my_data->acdb_set_audio_cal)
2682 ALOGE("%s: Could not find the symbol acdb_set_audio_cal_v2 from %s",
2683 __func__, LIB_ACDB_LOADER);
2684
2685 my_data->acdb_get_audio_cal = (acdb_get_audio_cal_t)dlsym(my_data->acdb_handle,
2686 "acdb_loader_get_audio_cal_v2");
2687 if (!my_data->acdb_get_audio_cal)
2688 ALOGE("%s: Could not find the symbol acdb_get_audio_cal_v2 from %s",
2689 __func__, LIB_ACDB_LOADER);
2690
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2691 my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle,
2692 "acdb_loader_send_voice_cal");
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2693 if (!my_data->acdb_send_voice_cal)
2694 ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s",
2695 __func__, LIB_ACDB_LOADER);
2696
2697 my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle,
2698 "acdb_loader_reload_vocvoltable");
2699 if (!my_data->acdb_reload_vocvoltable)
2700 ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s",
2701 __func__, LIB_ACDB_LOADER);
2702
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]2703 my_data->acdb_get_default_app_type = (acdb_get_default_app_type_t)dlsym(
2704 my_data->acdb_handle,
2705 "acdb_loader_get_default_app_type");
2706 if (!my_data->acdb_get_default_app_type)
2707 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2708 __func__, LIB_ACDB_LOADER);
2709
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]2710 my_data->acdb_send_gain_dep_cal = (acdb_send_gain_dep_cal_t)dlsym(my_data->acdb_handle,
2711 "acdb_loader_send_gain_dep_cal");
2712 if (!my_data->acdb_send_gain_dep_cal)
2713 ALOGV("%s: Could not find the symbol acdb_loader_send_gain_dep_cal from %s",
2714 __func__, LIB_ACDB_LOADER);
2715
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2716 my_data->acdb_send_common_top = (acdb_send_common_top_t)dlsym(
2717 my_data->acdb_handle,
2718 "acdb_loader_send_common_custom_topology");
2719 if (!my_data->acdb_send_common_top)
2720 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2721 __func__, LIB_ACDB_LOADER);
2722
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2723 my_data->acdb_set_codec_data = (acdb_set_codec_data_t)dlsym(
2724 my_data->acdb_handle,
2725 "acdb_loader_set_codec_data");
2726 if (!my_data->acdb_set_codec_data)
2727 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2728 __func__, LIB_ACDB_LOADER);
2729
2730
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]2731 my_data->acdb_init_v4 = (acdb_init_v4_t)dlsym(my_data->acdb_handle,
2732 "acdb_loader_init_v4");
2733 if (my_data->acdb_init_v4 == NULL) {
2734 ALOGE("%s: dlsym error %s for acdb_loader_init_v4", __func__, dlerror());
2735 }
2736
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2737 my_data->acdb_init_v3 = (acdb_init_v3_t)dlsym(my_data->acdb_handle,
2738 "acdb_loader_init_v3");
2739 if (my_data->acdb_init_v3 == NULL) {
2740 ALOGE("%s: dlsym error %s for acdb_loader_init_v3", __func__, dlerror());
2741 }
2742
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2743 my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle,
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2744 "acdb_loader_init_v3");
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2745 if (my_data->acdb_init == NULL) {
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2746 ALOGE("%s: dlsym error %s for acdb_loader_init_v3", __func__, dlerror());
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2747 goto acdb_init_fail;
2748 }
2749
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2750 my_data->acdb_reload_v2 = (acdb_reload_v2_t)dlsym(my_data->acdb_handle,
2751 "acdb_loader_reload_acdb_files_v2");
2752 if (my_data->acdb_reload_v2 == NULL) {
2753 ALOGE("%s: dlsym error %s for acdb_loader_reload_acdb_files_v2", __func__, dlerror());
2754 }
2755
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]2756 my_data->acdb_reload = (acdb_reload_t)dlsym(my_data->acdb_handle,
2757 "acdb_loader_reload_acdb_files");
2758 if (my_data->acdb_reload == NULL) {
2759 ALOGE("%s: dlsym error %s for acdb_loader_reload_acdb_files", __func__, dlerror());
2760 goto acdb_init_fail;
2761 }
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2762
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]2763 int result = acdb_init_v2(adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2764 if (!result) {
2765 my_data->is_acdb_initialized = true;
2766 ALOGD("ACDB initialized");
2767 audio_hwdep_send_cal(my_data);
2768 } else {
2769 my_data->is_acdb_initialized = false;
2770 ALOGD("ACDB initialization failed");
2771 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2772 }
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530[diff] [blame]2773 /* init keep-alive for compress passthru */
2774 audio_extn_keep_alive_init(adev);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2775
2776#ifdef FLICKER_SENSOR_INPUT
2777 configure_flicker_sensor_input(adev->mixer);
2778#endif
2779
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]2780#ifdef DYNAMIC_LOG_ENABLED
2781 log_utils_init();
2782#endif
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2783acdb_init_fail:
2784
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]2785
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2786 /*
2787 * Get the be_dai_name_table from kernel which provides a mapping
2788 * between a backend string name and a backend ID
2789 */
2790 init_be_dai_name_table(adev);
2791
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]2792 if (audio_extn_can_use_ras()) {
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2793 if (property_get_bool("persist.vendor.audio.speaker.prot.enable", false)) {
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]2794 platform_set_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED,
2795 acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS]);
2796 platform_set_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT,
2797 acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS]);
2798 } else {
2799 ALOGD("%s: RAS Feature should be enabled with Speaker Protection", __func__);
2800 }
2801 }
2802
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]2803 /* If platform is apq8084 and baseband is MDM, load CSD Client specific
2804 * symbols. Voice call is handled by MDM and apps processor talks to
2805 * MDM through CSD Client
2806 */
2807 property_get("ro.board.platform", platform, "");
2808 property_get("ro.baseband", baseband, "");
Josh Kirschc3894372016-03-28 15:59:48 -0700[diff] [blame]2809 if ((!strncmp("apq8084", platform, sizeof("apq8084")) ||
Xiaoyu Yec494c752017-11-02 18:52:48 -0700[diff] [blame]2810 !strncmp("msm8996", platform, sizeof("msm8996")) ||
Josh Kirschf20adbf2018-03-06 16:26:22 -0800[diff] [blame]2811 !strncmp("sdx", platform, sizeof("sdx")) ||
2812 !strncmp("sdm845", platform, sizeof("sdm845"))) &&
2813 ( !strncmp("mdm", baseband, (sizeof("mdm")-1)) ||
2814 !strncmp("sdx", baseband, (sizeof("sdx")-1)))) {
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]2815 my_data->csd = open_csd_client(my_data->is_i2s_ext_modem);
2816 } else {
2817 my_data->csd = NULL;
2818 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]2819
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2820 /* obtain source mic type from max mic count*/
2821 get_source_mic_type(my_data);
2822 ALOGD("%s: Fluence_Type(%d) max_mic_count(%d) mic_type(0x%x) fluence_in_voice_call(%d)"
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2823 " fluence_in_voice_rec(%d) fluence_in_spkr_mode(%d) fluence_in_hfp_call(%d) ",
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2824 __func__, my_data->fluence_type, my_data->max_mic_count, my_data->source_mic_type,
2825 my_data->fluence_in_voice_call, my_data->fluence_in_voice_rec,
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2826 my_data->fluence_in_spkr_mode, my_data->fluence_in_hfp_call);
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2827
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]2828 /* init usb */
2829 audio_extn_usb_init(adev);
2830
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]2831 /*init a2dp*/
2832 audio_extn_a2dp_init(adev);
2833
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]2834 /* init dap hal */
2835 audio_extn_dap_hal_init(adev->snd_card);
2836
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]2837 /* Read one time ssr property */
Mingming Yin49be8032013-12-19 12:51:25 -0800[diff] [blame]2838 audio_extn_ssr_update_enabled();
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]2839 audio_extn_spkr_prot_init(adev);
Dhananjay Kumar89ea3bd2014-04-29 15:45:57 +0530[diff] [blame]2840
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]2841 audio_extn_hwdep_cal_send(adev->snd_card, my_data->acdb_handle);
Dhananjay Kumar89ea3bd2014-04-29 15:45:57 +0530[diff] [blame]2842
Lior Barenboim0b61bc72014-05-13 13:01:37 +0300[diff] [blame]2843 /* init audio device arbitration */
2844 audio_extn_dev_arbi_init();
2845
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2846 default_rx_backend = strdup("SLIMBUS_0_RX");
2847
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]2848 /* initialize backend config */
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2849 for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {
2850 my_data->current_backend_cfg[idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
2851 if (idx == HEADPHONE_44_1_BACKEND)
2852 my_data->current_backend_cfg[idx].sample_rate = OUTPUT_SAMPLING_RATE_44100;
2853 my_data->current_backend_cfg[idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]2854 my_data->current_backend_cfg[idx].channels = CODEC_BACKEND_DEFAULT_CHANNELS;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2855 if (idx > MAX_RX_CODEC_BACKENDS)
2856 my_data->current_backend_cfg[idx].channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]2857 my_data->current_backend_cfg[idx].format = AUDIO_FORMAT_PCM;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]2858 my_data->current_backend_cfg[idx].bitwidth_mixer_ctl = NULL;
2859 my_data->current_backend_cfg[idx].samplerate_mixer_ctl = NULL;
2860 my_data->current_backend_cfg[idx].channels_mixer_ctl = NULL;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]2861 }
2862
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2863 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2864 strdup("SLIM_0_RX Format");
2865 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2866 strdup("SLIM_0_RX SampleRate");
2867
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2868 my_data->current_backend_cfg[DSD_NATIVE_BACKEND].bitwidth_mixer_ctl =
2869 strdup("SLIM_2_RX Format");
2870 my_data->current_backend_cfg[DSD_NATIVE_BACKEND].samplerate_mixer_ctl =
2871 strdup("SLIM_2_RX SampleRate");
2872
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2873 my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].bitwidth_mixer_ctl =
2874 strdup("SLIM_5_RX Format");
2875 my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].samplerate_mixer_ctl =
2876 strdup("SLIM_5_RX SampleRate");
2877
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2878 if (!my_data->is_slimbus_interface) {
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]2879 //TODO:: make generic interfaceface to check Slimbus/I2S/CDC_DMA
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]2880 if (!strncmp(snd_card_name, "sm6150", strlen("sm6150")) ||
2881 !strncmp(snd_card_name, "kona", strlen("kona"))) {
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]2882 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2883 strdup("WSA_CDC_DMA_RX_0 Format");
2884 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2885 strdup("WSA_CDC_DMA_RX_0 SampleRate");
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]2886 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2887 strdup("TX_CDC_DMA_TX_3 Format");
2888 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2889 strdup("TX_CDC_DMA_TX_3 SampleRate");
2890 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2891 strdup("RX_CDC_DMA_RX_0 Format");
2892 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2893 strdup("RX_CDC_DMA_RX_0 SampleRate");
2894
2895 if (default_rx_backend)
2896 free(default_rx_backend);
2897 default_rx_backend = strdup("WSA_CDC_DMA_RX_0");
2898 } else if (!strncmp(snd_card_name, "sdm660", strlen("sdm660")) ||
Sachin Mohan Gadageffd7562018-02-13 17:10:09 +0530[diff] [blame]2899 !strncmp(snd_card_name, "sdm670", strlen("sdm670")) ||
2900 !strncmp(snd_card_name, "qcs605", strlen("qcs605"))) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2901
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2902
2903 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2904 strdup("INT4_MI2S_RX Format");
2905 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2906 strdup("INT4_MI2S_RX SampleRate");
2907
2908 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2909 strdup("INT3_MI2S_TX Format");
2910 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2911 strdup("INT3_MI2S_TX SampleRate");
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]2912 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2913 strdup("INT0_MI2S_RX Format");
2914 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2915 strdup("INT0_MI2S_RX SampleRate");
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2916
2917 if (default_rx_backend)
2918 free(default_rx_backend);
2919 default_rx_backend = strdup("INT4_MI2S_RX");
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2920 } else {
2921 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2922 strdup("MI2S_RX Format");
2923 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2924 strdup("MI2S_RX SampleRate");
2925 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].channels_mixer_ctl =
2926 strdup("MI2S_RX Channels");
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2927 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2928 strdup("MI2S_TX Format");
2929 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2930 strdup("MI2S_TX SampleRate");
Naresh Tanniruc21e2022018-08-13 21:58:06 +0530[diff] [blame]2931 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2932 strdup("INT0_MI2S_RX Format");
2933 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2934 strdup("INT0_MI2S_RX SampleRate");
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2935 }
Revathi Uddaraju75843112017-11-30 14:30:47 +0530[diff] [blame]2936 } else {
Dhananjay Kumar75c9a0c2018-06-07 15:59:00 +0530[diff] [blame]2937 if (!strncmp(snd_card_name, "qcs405", strlen("qcs405"))) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2938
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]2939 if (!strncmp(snd_card_name, "qcs405-csra", strlen("qcs405-csra"))) {
2940 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2941 strdup("PRIM_MI2S_RX Format");
2942 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2943 strdup("PRIM_MI2S_RX SampleRate");
2944 } else {
2945 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2946 strdup("WSA_CDC_DMA_RX_0 Format");
2947 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2948 strdup("WSA_CDC_DMA_RX_0 SampleRate");
2949 }
Dhananjay Kumar75c9a0c2018-06-07 15:59:00 +0530[diff] [blame]2950 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2951 strdup("VA_CDC_DMA_TX_0 Format");
2952 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2953 strdup("VA_CDC_DMA_TX_0 SampleRate");
2954 } else {
2955 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2956 strdup("SLIM_0_TX Format");
2957 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2958 strdup("SLIM_0_TX SampleRate");
2959 }
Revathi Uddaraju75843112017-11-30 14:30:47 +0530[diff] [blame]2960 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2961 strdup("SLIM_6_RX Format");
2962 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2963 strdup("SLIM_6_RX SampleRate");
Samyak Jainb3f3ca52019-01-02 18:24:35 +0530[diff] [blame]2964 //TODO: enable CONCURRENT_CAPTURE_ENABLED flag only if separate backend is defined
2965 //for headset-mic. This is to capture separate data from headset-mic and handset-mic.
2966#ifdef CONCURRENT_CAPTURE_ENABLED
2967 my_data->current_backend_cfg[HEADSET_TX_BACKEND].bitwidth_mixer_ctl =
2968 strdup("SLIM_1_RX Format");
2969 my_data->current_backend_cfg[HEADSET_TX_BACKEND].samplerate_mixer_ctl =
2970 strdup("SLIM_1_RX SampleRate");
2971#endif
Revathi Uddaraju75843112017-11-30 14:30:47 +0530[diff] [blame]2972 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]2973
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2974 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].bitwidth_mixer_ctl =
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2975 strdup("USB_AUDIO_TX Format");
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2976 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].samplerate_mixer_ctl =
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2977 strdup("USB_AUDIO_TX SampleRate");
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2978 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].channels_mixer_ctl =
2979 strdup("USB_AUDIO_TX Channels");
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2980
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]2981 if (!strncmp(platform_get_snd_device_backend_interface(SND_DEVICE_IN_HDMI_MIC),
2982 "SEC_MI2S_TX", sizeof("SEC_MI2S_TX"))) {
2983 my_data->current_backend_cfg[HDMI_TX_BACKEND].bitwidth_mixer_ctl =
2984 strdup("SEC_MI2S_TX Format");
2985 my_data->current_backend_cfg[HDMI_TX_BACKEND].samplerate_mixer_ctl =
2986 strdup("SEC_MI2S_TX SampleRate");
2987 my_data->current_backend_cfg[HDMI_TX_BACKEND].channels_mixer_ctl =
2988 strdup("SEC_MI2S_TX Channels");
2989 } else {
2990 my_data->current_backend_cfg[HDMI_TX_BACKEND].bitwidth_mixer_ctl =
2991 strdup("QUAT_MI2S_TX Format");
2992 my_data->current_backend_cfg[HDMI_TX_BACKEND].samplerate_mixer_ctl =
2993 strdup("QUAT_MI2S_TX SampleRate");
2994 my_data->current_backend_cfg[HDMI_TX_BACKEND].channels_mixer_ctl =
2995 strdup("QUAT_MI2S_TX Channels");
2996 }
2997
2998 my_data->current_backend_cfg[SPDIF_TX_BACKEND].bitwidth_mixer_ctl =
2999 strdup("PRIM_SPDIF_TX Format");
3000 my_data->current_backend_cfg[SPDIF_TX_BACKEND].samplerate_mixer_ctl =
3001 strdup("PRIM_SPDIF_TX SampleRate");
3002 my_data->current_backend_cfg[SPDIF_TX_BACKEND].channels_mixer_ctl =
3003 strdup("PRIM_SPDIF_TX Channels");
3004
3005 my_data->current_backend_cfg[HDMI_ARC_TX_BACKEND].bitwidth_mixer_ctl =
3006 strdup("SEC_SPDIF_TX Format");
3007 my_data->current_backend_cfg[HDMI_ARC_TX_BACKEND].samplerate_mixer_ctl =
3008 strdup("SEC_SPDIF_TX SampleRate");
3009 my_data->current_backend_cfg[HDMI_ARC_TX_BACKEND].channels_mixer_ctl =
3010 strdup("SEC_SPDIF_TX Channels");
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]3011
mpang00a03542018-11-01 17:05:19 +0800[diff] [blame]3012 my_data->current_backend_cfg[HDMI_RX_BACKEND].bitwidth_mixer_ctl =
3013 strdup("HDMI_RX Bit Format");
3014 my_data->current_backend_cfg[HDMI_RX_BACKEND].samplerate_mixer_ctl =
3015 strdup("HDMI_RX SampleRate");
3016 my_data->current_backend_cfg[HDMI_RX_BACKEND].channels_mixer_ctl =
3017 strdup("HDMI_RX Channels");
3018 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].bitwidth_mixer_ctl =
3019 strdup("Display Port RX Bit Format");
3020 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].samplerate_mixer_ctl =
3021 strdup("Display Port RX SampleRate");
3022 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].channels_mixer_ctl =
3023 strdup("Display Port RX Channels");
3024
3025 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].bitwidth_mixer_ctl =
3026 strdup("USB_AUDIO_RX Format");
3027 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].samplerate_mixer_ctl =
3028 strdup("USB_AUDIO_RX SampleRate");
3029 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].channels_mixer_ctl =
3030 strdup("USB_AUDIO_RX Channels");
3031
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]3032 for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {
3033 if (my_data->current_backend_cfg[idx].bitwidth_mixer_ctl) {
3034 ctl = mixer_get_ctl_by_name(adev->mixer,
3035 my_data->current_backend_cfg[idx].bitwidth_mixer_ctl);
3036 id_string = platform_get_mixer_control(ctl);
3037 if (id_string) {
3038 cfg_value = audio_extn_utils_get_bit_width_from_string(id_string);
3039 if (cfg_value > 0)
3040 my_data->current_backend_cfg[idx].bit_width = cfg_value;
3041 }
3042 }
3043
3044 if (my_data->current_backend_cfg[idx].samplerate_mixer_ctl) {
3045 ctl = mixer_get_ctl_by_name(adev->mixer,
3046 my_data->current_backend_cfg[idx].samplerate_mixer_ctl);
3047 id_string = platform_get_mixer_control(ctl);
3048 if (id_string) {
3049 cfg_value = audio_extn_utils_get_sample_rate_from_string(id_string);
3050 if (cfg_value > 0)
3051 my_data->current_backend_cfg[idx].sample_rate = cfg_value;
3052 }
3053 }
3054
3055 if (my_data->current_backend_cfg[idx].channels_mixer_ctl) {
3056 ctl = mixer_get_ctl_by_name(adev->mixer,
3057 my_data->current_backend_cfg[idx].channels_mixer_ctl);
3058 id_string = platform_get_mixer_control(ctl);
3059 if (id_string) {
3060 cfg_value = audio_extn_utils_get_channels_from_string(id_string);
3061 if (cfg_value > 0)
3062 my_data->current_backend_cfg[idx].channels = cfg_value;
3063 }
3064 }
3065 }
3066
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3067 ret = audio_extn_utils_get_codec_version(snd_card_name,
3068 my_data->adev->snd_card,
3069 my_data->codec_version);
3070
3071 if (NATIVE_AUDIO_MODE_INVALID != platform_get_native_support()) {
3072 /*
3073 * Native playback is enabled from the UI.
3074 */
3075 if(strstr(snd_card_name, "tasha")) {
3076 if (strstr(my_data->codec_version, "WCD9335_1_0") ||
3077 strstr(my_data->codec_version, "WCD9335_1_1")) {
3078 ALOGD("%s:napb: TASHA 1.0 or 1.1 only SRC mode is supported",
3079 __func__);
3080 platform_set_native_support(NATIVE_AUDIO_MODE_SRC);
3081 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3082 }
Ashish Jain4826f6c2017-02-06 13:33:20 +0530[diff] [blame]3083 if (strstr(snd_card_name, "tavil")) {
3084 ALOGD("%s:DSD playback is supported", __func__);
3085 my_data->is_dsd_supported = true;
3086 my_data->is_asrc_supported = true;
3087 platform_set_native_support(NATIVE_AUDIO_MODE_MULTIPLE_44_1);
3088 }
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3089 }
3090
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]3091 if (property_get_bool("vendor.audio.apptype.multirec.enabled", false))
3092 my_data->use_generic_handset = true;
3093
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +0530[diff] [blame]3094 /* Initialize keep alive for HDMI/loopback silence */
3095 audio_extn_keep_alive_init(adev);
3096
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]3097 my_data->edid_info = NULL;
Sudheer Papothi4e0ea9a2015-09-30 06:57:51 +0530[diff] [blame]3098 free(snd_card_name);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3099 return my_data;
3100}
3101
Ramu Gottipati62f6d9b2018-05-01 15:21:38 +0530[diff] [blame]3102void platform_release_acdb_metainfo_key(void *platform)
3103{
3104 struct platform_data *my_data = (struct platform_data *)platform;
3105 struct listnode *node, *tempnode;
3106
3107 list_for_each_safe(node, tempnode, &my_data->acdb_meta_key_list) {
3108 list_remove(node);
3109 free(node_to_item(node, struct meta_key_list, list));
3110 }
3111}
3112
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3113void platform_deinit(void *platform)
3114{
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]3115 struct platform_data *my_data = (struct platform_data *)platform;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3116 struct operator_info *info_item;
3117 struct operator_specific_device *device_item;
3118 struct app_type_entry *ap;
3119 struct listnode *node;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]3120
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +0530[diff] [blame]3121 audio_extn_keep_alive_deinit();
3122
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]3123 if (my_data->edid_info) {
3124 free(my_data->edid_info);
3125 my_data->edid_info = NULL;
3126 }
3127
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]3128 if (be_dai_name_table) {
3129 free((void *)be_dai_name_table);
3130 be_dai_name_table = NULL;
3131 }
3132
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]3133 if (my_data->hw_dep_fd >= 0) {
3134 close(my_data->hw_dep_fd);
3135 my_data->hw_dep_fd = -1;
3136 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3137 if (default_rx_backend)
3138 free(default_rx_backend);
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]3139
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]3140 hw_info_deinit(my_data->hw_info);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3141 close_csd_client(my_data->csd);
3142
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3143 int32_t dev;
3144 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3145 if (backend_tag_table[dev]) {
3146 free(backend_tag_table[dev]);
3147 backend_tag_table[dev]= NULL;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3148 }
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3149
3150 if (hw_interface_table[dev]) {
3151 free(hw_interface_table[dev]);
3152 hw_interface_table[dev] = NULL;
3153 }
3154
3155 if (operator_specific_device_table[dev]) {
3156 while (!list_empty(operator_specific_device_table[dev])) {
3157 node = list_head(operator_specific_device_table[dev]);
3158 list_remove(node);
3159 device_item = node_to_item(node,
3160 struct operator_specific_device, list);
3161 free(device_item->operator);
3162 device_item->operator = NULL;
3163 free(device_item->mixer_path);
3164 device_item->mixer_path = NULL;
3165 free(device_item);
3166 device_item = NULL;
3167 }
3168 free(operator_specific_device_table[dev]);
3169 operator_specific_device_table[dev] = NULL;
3170 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3171 }
3172
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3173 while (!list_empty(&operator_info_list)) {
3174 node = list_head(&operator_info_list);
3175 list_remove(node);
3176 info_item = node_to_item(node, struct operator_info, list);
3177 free(info_item->name);
3178 info_item->name = NULL;
3179 free(info_item->mccmnc);
3180 info_item->mccmnc = NULL;
3181 free(info_item);
3182 info_item = NULL;
3183 }
3184
3185 while (!list_empty(&app_type_entry_list)) {
3186 node = list_head(&app_type_entry_list);
3187 list_remove(node);
3188 ap = node_to_item(node, struct app_type_entry, node);
3189 if (ap->mode) {
3190 free(ap->mode);
3191 ap->mode = NULL;
3192 }
3193 free(ap);
3194 ap = NULL;
3195 }
3196
Lior Barenboim0b61bc72014-05-13 13:01:37 +0300[diff] [blame]3197 /* deinit audio device arbitration */
3198 audio_extn_dev_arbi_deinit();
3199
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]3200 if (my_data->edid_info) {
3201 free(my_data->edid_info);
3202 my_data->edid_info = NULL;
3203 }
3204
Dhananjay Kumara5ba5f22016-11-30 16:01:29 +0530[diff] [blame]3205 if (my_data->adev->mixer) {
Soumya Managoli9fee7c62018-04-06 16:21:50 +0530[diff] [blame]3206 audio_extn_utils_close_snd_mixer(my_data->adev->mixer);
Dhananjay Kumara5ba5f22016-11-30 16:01:29 +0530[diff] [blame]3207 my_data->adev->mixer = NULL;
3208 }
3209
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]3210
3211
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]3212 if (my_data->spkr_ch_map) {
3213 free(my_data->spkr_ch_map);
3214 my_data->spkr_ch_map = NULL;
3215 }
3216
Ramu Gottipati62f6d9b2018-05-01 15:21:38 +0530[diff] [blame]3217 int32_t idx;
3218
3219 for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {
3220 if (my_data->current_backend_cfg[idx].bitwidth_mixer_ctl) {
3221 free(my_data->current_backend_cfg[idx].bitwidth_mixer_ctl);
3222 my_data->current_backend_cfg[idx].bitwidth_mixer_ctl = NULL;
3223 }
3224
3225 if (my_data->current_backend_cfg[idx].samplerate_mixer_ctl) {
3226 free(my_data->current_backend_cfg[idx].samplerate_mixer_ctl);
3227 my_data->current_backend_cfg[idx].samplerate_mixer_ctl = NULL;
3228 }
3229
3230 if (my_data->current_backend_cfg[idx].channels_mixer_ctl) {
3231 free(my_data->current_backend_cfg[idx].channels_mixer_ctl);
3232 my_data->current_backend_cfg[idx].channels_mixer_ctl = NULL;
3233 }
3234 }
3235
3236 /* free acdb_meta_key_list */
3237 platform_release_acdb_metainfo_key(platform);
3238
Aditya Bavanaric1c1ba62018-06-08 16:33:43 +0530[diff] [blame]3239 if (my_data->acdb_deallocate)
3240 my_data->acdb_deallocate();
3241
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3242 free(platform);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3243 /* deinit usb */
3244 audio_extn_usb_deinit();
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]3245 audio_extn_dap_hal_deinit();
Aditya Bavanaria56da222017-07-14 17:54:21 +0530[diff] [blame]3246 if (audio_extn_spkr_prot_is_enabled())
3247 audio_extn_spkr_prot_deinit();
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]3248#ifdef DYNAMIC_LOG_ENABLED
3249 log_utils_deinit();
3250#endif
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3251}
3252
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]3253static int platform_is_acdb_initialized(void *platform)
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]3254{
3255 struct platform_data *my_data = (struct platform_data *)platform;
3256 ALOGD("%s: acdb initialized %d\n", __func__, my_data->is_acdb_initialized);
3257 return my_data->is_acdb_initialized;
3258}
3259
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]3260void platform_snd_card_update(void *platform, card_status_t card_status)
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]3261{
3262 struct platform_data *my_data = (struct platform_data *)platform;
3263
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]3264 if (card_status == CARD_STATUS_ONLINE) {
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]3265 if (!platform_is_acdb_initialized(my_data)) {
3266 if(platform_acdb_init(my_data))
3267 ALOGE("%s: acdb initialization is failed", __func__);
3268 } else if (my_data->acdb_send_common_top() < 0) {
3269 ALOGD("%s: acdb did not set common topology", __func__);
3270 }
3271 }
3272}
3273
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3274const char *platform_get_snd_device_name(snd_device_t snd_device)
3275{
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3276 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
3277 if (operator_specific_device_table[snd_device] != NULL) {
3278 return get_operator_specific_device_mixer_path(snd_device);
3279 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3280 return device_table[snd_device];
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3281 } else
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3282 return "";
3283}
3284
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]3285int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
3286 char *device_name)
3287{
3288 struct platform_data *my_data = (struct platform_data *)platform;
3289
3290 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3291 if (operator_specific_device_table[snd_device] != NULL) {
3292 strlcpy(device_name, get_operator_specific_device_mixer_path(snd_device),
3293 DEVICE_NAME_MAX_SIZE);
3294 } else
3295 strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]3296 hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
3297 } else {
3298 strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE);
3299 return -EINVAL;
3300 }
3301
3302 return 0;
3303}
3304
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3305void platform_add_backend_name(char *mixer_path, snd_device_t snd_device,
3306 struct audio_usecase *usecase)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3307{
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3308 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
3309 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
3310 return;
3311 }
3312
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3313 if ((snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
3314 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3315 !(usecase->type == VOICE_CALL || usecase->type == VOIP_CALL)) {
3316 ALOGI("%s: Not adding vbat speaker device to non voice use cases", __func__);
3317 return;
3318 }
3319
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3320 const char * suffix = backend_tag_table[snd_device];
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3321
3322 if (suffix != NULL) {
3323 strlcat(mixer_path, " ", MIXER_PATH_MAX_LENGTH);
3324 strlcat(mixer_path, suffix, MIXER_PATH_MAX_LENGTH);
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]3325
3326 /* if we can use display-port for voice call and usb mic
3327 * is connected, choose dp_rx, usb_tx audio route
3328 */
3329 if (usecase->type == VOICE_CALL) {
3330 struct audio_device *adev = usecase->stream.out->dev;
3331 if ((snd_device == SND_DEVICE_OUT_DISPLAY_PORT) &&
3332 adev->dp_allowed_for_voice &&
3333 (usecase->in_snd_device == SND_DEVICE_IN_VOICE_USB_HEADSET_MIC)) {
3334 strlcat(mixer_path, "-and-usb-headset-mic", MIXER_PATH_MAX_LENGTH);
3335 }
3336 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3337 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3338}
3339
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3340bool platform_check_backends_match(snd_device_t snd_device1, snd_device_t snd_device2)
3341{
3342 bool result = true;
3343
3344 ALOGV("%s: snd_device1 = %s, snd_device2 = %s", __func__,
3345 platform_get_snd_device_name(snd_device1),
3346 platform_get_snd_device_name(snd_device2));
3347
3348 if ((snd_device1 < SND_DEVICE_MIN) || (snd_device1 >= SND_DEVICE_OUT_END)) {
3349 ALOGE("%s: Invalid snd_device = %s", __func__,
3350 platform_get_snd_device_name(snd_device1));
3351 return false;
3352 }
3353 if ((snd_device2 < SND_DEVICE_MIN) || (snd_device2 >= SND_DEVICE_OUT_END)) {
3354 ALOGE("%s: Invalid snd_device = %s", __func__,
3355 platform_get_snd_device_name(snd_device2));
3356 return false;
3357 }
3358 const char * be_itf1 = hw_interface_table[snd_device1];
3359 const char * be_itf2 = hw_interface_table[snd_device2];
3360
3361 if (NULL != be_itf1 && NULL != be_itf2) {
Kuirong Wangb9fbb1e2016-05-03 18:36:39 -0700[diff] [blame]3362 if ((NULL == strstr(be_itf2, be_itf1)) && (NULL == strstr(be_itf1, be_itf2)))
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3363 result = false;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3364 } else if (NULL == be_itf1 && NULL != be_itf2 && (NULL == strstr(be_itf2, default_rx_backend))) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3365 result = false;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3366 } else if (NULL != be_itf1 && NULL == be_itf2 && (NULL == strstr(be_itf1, default_rx_backend))) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3367 result = false;
3368 }
3369
3370 ALOGV("%s: be_itf1 = %s, be_itf2 = %s, match %d", __func__, be_itf1, be_itf2, result);
3371 return result;
3372}
3373
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3374int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
3375{
3376 int device_id;
3377 if (device_type == PCM_PLAYBACK)
3378 device_id = pcm_device_table[usecase][0];
3379 else
3380 device_id = pcm_device_table[usecase][1];
3381 return device_id;
3382}
3383
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3384static int find_index(struct name_to_index * table, int32_t len, const char * name)
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]3385{
3386 int ret = 0;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3387 int32_t i;
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]3388
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3389 if (table == NULL) {
3390 ALOGE("%s: table is NULL", __func__);
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]3391 ret = -ENODEV;
3392 goto done;
3393 }
3394
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3395 if (name == NULL) {
3396 ALOGE("null key");
3397 ret = -ENODEV;
3398 goto done;
3399 }
3400
3401 for (i=0; i < len; i++) {
3402 const char* tn = table[i].name;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]3403 size_t len = strlen(tn);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3404 if (strncmp(tn, name, len) == 0) {
3405 if (strlen(name) != len) {
3406 continue; // substring
3407 }
3408 ret = table[i].index;
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]3409 goto done;
3410 }
3411 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3412 ALOGE("%s: Could not find index for name = %s",
3413 __func__, name);
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]3414 ret = -ENODEV;
3415done:
3416 return ret;
3417}
3418
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]3419int platform_set_fluence_type(void *platform, char *value)
3420{
3421 int ret = 0;
3422 int fluence_type = FLUENCE_NONE;
3423 int fluence_flag = NONE_FLAG;
3424 struct platform_data *my_data = (struct platform_data *)platform;
3425 struct audio_device *adev = my_data->adev;
3426
3427 ALOGV("%s: fluence type:%d", __func__, my_data->fluence_type);
3428
3429 /* only dual mic turn on and off is supported as of now through setparameters */
3430 if (!strncmp(AUDIO_PARAMETER_VALUE_DUALMIC,value, sizeof(AUDIO_PARAMETER_VALUE_DUALMIC))) {
3431 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro")) ||
3432 !strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
3433 ALOGV("fluence dualmic feature enabled \n");
3434 fluence_type = FLUENCE_DUAL_MIC;
3435 fluence_flag = DMIC_FLAG;
3436 } else {
3437 ALOGE("%s: Failed to set DUALMIC", __func__);
3438 ret = -1;
3439 goto done;
3440 }
3441 } else if (!strncmp(AUDIO_PARAMETER_KEY_NO_FLUENCE, value, sizeof(AUDIO_PARAMETER_KEY_NO_FLUENCE))) {
3442 ALOGV("fluence disabled");
3443 fluence_type = FLUENCE_NONE;
3444 } else {
3445 ALOGE("Invalid fluence value : %s",value);
3446 ret = -1;
3447 goto done;
3448 }
3449
3450 if (fluence_type != my_data->fluence_type) {
3451 ALOGV("%s: Updating fluence_type to :%d", __func__, fluence_type);
3452 my_data->fluence_type = fluence_type;
3453 adev->acdb_settings = (adev->acdb_settings & FLUENCE_MODE_CLEAR) | fluence_flag;
3454 }
3455done:
3456 return ret;
3457}
3458
3459int platform_get_fluence_type(void *platform, char *value, uint32_t len)
3460{
3461 int ret = 0;
3462 struct platform_data *my_data = (struct platform_data *)platform;
3463
3464 if (my_data->fluence_type == FLUENCE_QUAD_MIC) {
3465 strlcpy(value, "quadmic", len);
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]3466 } else if (my_data->fluence_type == FLUENCE_TRI_MIC) {
3467 strlcpy(value, "trimic", len);
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]3468 } else if (my_data->fluence_type == FLUENCE_DUAL_MIC) {
3469 strlcpy(value, "dualmic", len);
3470 } else if (my_data->fluence_type == FLUENCE_NONE) {
3471 strlcpy(value, "none", len);
3472 } else
3473 ret = -1;
3474
3475 return ret;
3476}
3477
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]3478int platform_get_snd_device_index(char *device_name)
3479{
3480 return find_index(snd_device_name_index, SND_DEVICE_MAX, device_name);
3481}
3482
3483int platform_get_usecase_index(const char *usecase_name)
3484{
3485 return find_index(usecase_name_index, AUDIO_USECASE_MAX, usecase_name);
3486}
3487
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3488void platform_add_operator_specific_device(snd_device_t snd_device,
3489 const char *operator,
3490 const char *mixer_path,
3491 unsigned int acdb_id)
3492{
3493 struct operator_specific_device *device;
3494
3495 if (operator_specific_device_table[snd_device] == NULL) {
3496 operator_specific_device_table[snd_device] =
3497 (struct listnode *)calloc(1, sizeof(struct listnode));
3498 list_init(operator_specific_device_table[snd_device]);
3499 }
3500
3501 device = (struct operator_specific_device *)calloc(1, sizeof(struct operator_specific_device));
3502
3503 device->operator = strdup(operator);
3504 device->mixer_path = strdup(mixer_path);
3505 device->acdb_id = acdb_id;
3506
3507 list_add_tail(operator_specific_device_table[snd_device], &device->list);
3508
3509 ALOGD("%s: device[%s] -> operator[%s] mixer_path[%s] acdb_id[%d]", __func__,
3510 platform_get_snd_device_name(snd_device), operator, mixer_path, acdb_id);
3511
3512}
3513
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]3514int platform_get_effect_config_data(snd_device_t snd_device,
3515 struct audio_effect_config *effect_config,
3516 effect_type_t effect_type)
3517{
3518 int ret = 0;
3519
3520 if ((snd_device < SND_DEVICE_IN_BEGIN) || (snd_device >= SND_DEVICE_MAX) ||
3521 (effect_type <= EFFECT_NONE) || (effect_type >= EFFECT_MAX)) {
3522 ALOGE("%s: Invalid snd_device = %d",
3523 __func__, snd_device);
3524 ret = -EINVAL;
3525 goto done;
3526 }
3527
3528 if(effect_config == NULL) {
3529 ALOGE("%s: Invalid effect_config", __func__);
3530 ret = -EINVAL;
3531 goto done;
3532 }
3533
3534 ALOGV("%s: snd_device = %d module_id = %d",
3535 __func__, snd_device, effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type].module_id);
3536 memcpy(effect_config, &effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type],
3537 sizeof(struct audio_effect_config));
3538
3539done:
3540 return ret;
3541}
3542
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]3543int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)
3544{
3545 int ret = 0;
3546
3547 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
3548 ALOGE("%s: Invalid snd_device = %d",
3549 __func__, snd_device);
3550 ret = -EINVAL;
3551 goto done;
3552 }
3553
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3554 ALOGV("%s: acdb_device_table[%s]: old = %d new = %d", __func__,
3555 platform_get_snd_device_name(snd_device), acdb_device_table[snd_device], acdb_id);
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]3556 acdb_device_table[snd_device] = acdb_id;
3557done:
3558 return ret;
3559}
3560
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]3561int platform_set_effect_config_data(snd_device_t snd_device,
3562 struct audio_effect_config effect_config,
3563 effect_type_t effect_type)
3564{
3565 int ret = 0;
3566
3567 if ((snd_device < SND_DEVICE_IN_BEGIN) || (snd_device >= SND_DEVICE_MAX) ||
3568 (effect_type <= EFFECT_NONE) || (effect_type >= EFFECT_MAX)) {
3569 ALOGE("%s: Invalid snd_device = %d",
3570 __func__, snd_device);
3571 ret = -EINVAL;
3572 goto done;
3573 }
3574
3575 ALOGV("%s 0x%x 0x%x 0x%x 0x%x", __func__, effect_config.module_id,
3576 effect_config.instance_id, effect_config.param_id,
3577 effect_config.param_value);
3578 effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type] = effect_config;
3579
3580done:
3581 return ret;
3582}
3583
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]3584int platform_set_acdb_metainfo_key(void *platform, char *name, int key)
3585{
3586 struct meta_key_list *key_info;
3587 struct platform_data *pdata = (struct platform_data *)platform;
3588
3589 key_info = (struct meta_key_list *)calloc(1, sizeof(struct meta_key_list));
3590 if (!key_info) {
3591 ALOGE("%s: Could not allocate memory for key %d", __func__, key);
3592 return -ENOMEM;
3593 }
3594
3595 key_info->cal_info.nKey = key;
3596 strlcpy(key_info->name, name, sizeof(key_info->name));
3597 list_add_tail(&pdata->acdb_meta_key_list, &key_info->list);
3598
3599 ALOGD("%s: successfully added module %s and key %d to the list", __func__,
3600 key_info->name, key_info->cal_info.nKey);
3601 return 0;
3602}
3603
3604int platform_get_meta_info_key_from_list(void *platform, char *mod_name)
3605{
3606 struct listnode *node;
3607 struct meta_key_list *key_info;
3608 struct platform_data *pdata = (struct platform_data *)platform;
3609 int key = 0;
3610
3611 ALOGV("%s: for module %s", __func__, mod_name);
3612
3613 list_for_each(node, &pdata->acdb_meta_key_list) {
3614 key_info = node_to_item(node, struct meta_key_list, list);
3615 if (strcmp(key_info->name, mod_name) == 0) {
3616 key = key_info->cal_info.nKey;
3617 ALOGD("%s: Found key %d for module %s", __func__, key, mod_name);
3618 break;
3619 }
3620 }
3621 return key;
3622}
3623
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]3624int platform_get_default_app_type(void *platform)
3625{
3626 struct platform_data *my_data = (struct platform_data *)platform;
3627
3628 if (my_data->acdb_get_default_app_type)
3629 return my_data->acdb_get_default_app_type();
3630 else
Srikanth Uyyalaa1e32352015-10-09 14:48:04 +0530[diff] [blame]3631 return DEFAULT_APP_TYPE_RX_PATH;
3632}
3633
3634int platform_get_default_app_type_v2(void *platform, usecase_type_t type)
3635{
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]3636 ALOGV("%s: Platform: %p, type: %d", __func__, platform, type);
Srikanth Uyyalaa1e32352015-10-09 14:48:04 +0530[diff] [blame]3637 if(type == PCM_CAPTURE)
3638 return DEFAULT_APP_TYPE_TX_PATH;
3639 else
3640 return DEFAULT_APP_TYPE_RX_PATH;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]3641}
3642
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -0700[diff] [blame]3643int platform_get_snd_device_acdb_id(snd_device_t snd_device)
3644{
3645 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
3646 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
3647 return -EINVAL;
3648 }
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]3649
3650 /*
3651 * If speaker protection is enabled, function returns supported
3652 * sound device for speaker. Else same sound device is returned.
3653 */
3654 snd_device = platform_get_spkr_prot_snd_device(snd_device);
3655
3656 if (operator_specific_device_table[snd_device] != NULL)
3657 return get_operator_specific_device_acdb_id(snd_device);
3658 else
3659 return acdb_device_table[snd_device];
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -0700[diff] [blame]3660}
3661
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]3662int platform_set_snd_device_bit_width(snd_device_t snd_device, unsigned int bit_width)
3663{
3664 int ret = 0;
3665
3666 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
3667 ALOGE("%s: Invalid snd_device = %d",
3668 __func__, snd_device);
3669 ret = -EINVAL;
3670 goto done;
3671 }
3672
3673 backend_bit_width_table[snd_device] = bit_width;
3674done:
3675 return ret;
3676}
3677
3678int platform_get_snd_device_bit_width(snd_device_t snd_device)
3679{
3680 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
3681 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]3682 return CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]3683 }
3684 return backend_bit_width_table[snd_device];
3685}
3686
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3687int platform_set_native_support(int na_mode)
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3688{
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3689 if (NATIVE_AUDIO_MODE_SRC == na_mode || NATIVE_AUDIO_MODE_TRUE_44_1 == na_mode
3690 || NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3691 na_props.platform_na_prop_enabled = na_props.ui_na_prop_enabled = true;
3692 na_props.na_mode = na_mode;
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]3693 ALOGD("%s:napb: native audio playback enabled in (%s) mode", __func__,
3694 ((na_mode == NATIVE_AUDIO_MODE_SRC)?"SRC":
3695 (na_mode == NATIVE_AUDIO_MODE_TRUE_44_1)?"True":"Multiple"));
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3696 }
3697 else {
3698 na_props.platform_na_prop_enabled = false;
3699 na_props.na_mode = NATIVE_AUDIO_MODE_INVALID;
3700 ALOGD("%s:napb: native audio playback disabled", __func__);
3701 }
3702
3703 return 0;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3704}
3705
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3706bool platform_check_codec_dsd_support(void *platform)
3707{
3708 struct platform_data *my_data = (struct platform_data *)platform;
3709 return my_data->is_dsd_supported;
3710}
3711
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530[diff] [blame]3712bool platform_check_codec_asrc_support(void *platform)
3713{
3714 struct platform_data *my_data = (struct platform_data *)platform;
3715 return my_data->is_asrc_supported;
3716}
3717
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3718int platform_get_native_support()
3719{
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3720 int ret = NATIVE_AUDIO_MODE_INVALID;
3721 if (na_props.platform_na_prop_enabled &&
3722 na_props.ui_na_prop_enabled) {
3723 ret = na_props.na_mode;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3724 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3725 ALOGV("%s:napb: ui Prop enabled(%d) version(%d)", __func__,
3726 na_props.ui_na_prop_enabled, na_props.na_mode);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3727 return ret;
3728}
3729
3730void native_audio_get_params(struct str_parms *query,
3731 struct str_parms *reply,
3732 char *value, int len)
3733{
3734 int ret;
3735 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
3736 value, len);
3737 if (ret >= 0) {
3738 if (na_props.platform_na_prop_enabled) {
3739 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
3740 na_props.ui_na_prop_enabled ? "true" : "false");
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3741 ALOGV("%s:napb: na_props.ui_na_prop_enabled: %d", __func__,
3742 na_props.ui_na_prop_enabled);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3743 } else {
3744 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
3745 "false");
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3746 ALOGV("%s:napb: native audio not supported: %d", __func__,
3747 na_props.platform_na_prop_enabled);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3748 }
3749 }
3750}
3751
3752int native_audio_set_params(struct platform_data *platform,
3753 struct str_parms *parms, char *value, int len)
3754{
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]3755 int ret = -1;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3756 struct audio_usecase *usecase;
3757 struct listnode *node;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3758 int mode = NATIVE_AUDIO_MODE_INVALID;
3759
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]3760 if (!value || !parms)
3761 return ret;
3762
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3763 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO_MODE,
3764 value, len);
3765 if (ret >= 0) {
3766 if (value && !strncmp(value, "src", sizeof("src")))
3767 mode = NATIVE_AUDIO_MODE_SRC;
3768 else if (value && !strncmp(value, "true", sizeof("true")))
3769 mode = NATIVE_AUDIO_MODE_TRUE_44_1;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3770 else if (value && !strncmp(value, "multiple", sizeof("multiple")))
3771 mode = NATIVE_AUDIO_MODE_MULTIPLE_44_1;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3772 else {
3773 mode = NATIVE_AUDIO_MODE_INVALID;
3774 ALOGE("%s:napb:native_audio_mode in platform info xml,invalid mode string",
3775 __func__);
3776 }
3777 ALOGD("%s:napb updating mode (%d) from XML",__func__, mode);
3778 platform_set_native_support(mode);
3779 }
3780
3781
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3782
3783 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
3784 value, len);
3785 if (ret >= 0) {
3786 if (na_props.platform_na_prop_enabled) {
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]3787 if (!strncmp("true", value, sizeof("true"))) {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3788 na_props.ui_na_prop_enabled = true;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3789 ALOGD("%s:napb: native audio feature enabled from UI",
3790 __func__);
3791 } else {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3792 na_props.ui_na_prop_enabled = false;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3793 ALOGD("%s:napb: native audio feature disabled from UI",
3794 __func__);
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]3795 }
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3796
3797 str_parms_del(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO);
3798
3799 /*
3800 * Iterate through the usecase list and trigger device switch for
3801 * all the appropriate usecases
3802 */
3803 list_for_each(node, &(platform->adev)->usecase_list) {
3804 usecase = node_to_item(node, struct audio_usecase, list);
3805
3806 if (is_offload_usecase(usecase->id) &&
3807 (usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
3808 usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) &&
3809 OUTPUT_SAMPLING_RATE_44100 == usecase->stream.out->sample_rate) {
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]3810 ALOGD("%s:napb: triggering dynamic device switch for usecase %d, %s"
3811 " stream %p, device (%u)", __func__, usecase->id,
3812 use_case_table[usecase->id],
3813 (void*) usecase->stream.out,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3814 usecase->stream.out->devices);
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]3815 select_devices(platform->adev, usecase->id);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3816 }
3817 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3818 } else
3819 ALOGD("%s:napb: native audio cannot be enabled from UI",
3820 __func__);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3821 }
3822 return ret;
3823}
3824
Sidipotu Ashokad8fff82016-02-02 10:48:42 +0530[diff] [blame]3825int check_hdset_combo_device(snd_device_t snd_device)
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3826{
3827 int ret = false;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3828
Sidipotu Ashokad8fff82016-02-02 10:48:42 +0530[diff] [blame]3829 if (SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES == snd_device ||
3830 SND_DEVICE_OUT_SPEAKER_AND_LINE == snd_device ||
3831 SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1 == snd_device ||
3832 SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2 == snd_device ||
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]3833 SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET == snd_device ||
3834 SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET == snd_device)
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3835 ret = true;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3836
3837 return ret;
3838}
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3839
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3840int codec_device_supports_native_playback(audio_devices_t out_device)
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3841{
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3842 int ret = false;
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3843
3844 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
3845 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
Revathi Uddaraju413a6f02018-11-09 12:57:27 +0530[diff] [blame]3846 out_device & AUDIO_DEVICE_OUT_LINE ||
3847 out_device & AUDIO_DEVICE_OUT_USB_HEADSET)
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3848 ret = true;
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3849
3850 return ret;
3851}
3852
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3853int platform_get_backend_index(snd_device_t snd_device)
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3854{
3855 int32_t port = DEFAULT_CODEC_BACKEND;
3856
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3857 if (snd_device >= SND_DEVICE_OUT_BEGIN && snd_device < SND_DEVICE_OUT_END) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3858 if (backend_tag_table[snd_device] != NULL) {
3859 if (strncmp(backend_tag_table[snd_device], "headphones-44.1",
3860 sizeof("headphones-44.1")) == 0)
3861 port = HEADPHONE_44_1_BACKEND;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3862 else if (strncmp(backend_tag_table[snd_device], "headphones-dsd",
3863 sizeof("headphones-dsd")) == 0)
3864 port = DSD_NATIVE_BACKEND;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3865 else if (strncmp(backend_tag_table[snd_device], "headphones",
3866 sizeof("headphones")) == 0)
3867 port = HEADPHONE_BACKEND;
3868 else if (strcmp(backend_tag_table[snd_device], "hdmi") == 0)
3869 port = HDMI_RX_BACKEND;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3870 else if (strcmp(backend_tag_table[snd_device], "display-port") == 0)
3871 port = DISP_PORT_RX_BACKEND;
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]3872 else if ((strcmp(backend_tag_table[snd_device], "usb-headphones") == 0) ||
3873 (strcmp(backend_tag_table[snd_device], "usb-headset") == 0))
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]3874 port = USB_AUDIO_RX_BACKEND;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3875 }
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3876 } else if (snd_device >= SND_DEVICE_IN_BEGIN && snd_device < SND_DEVICE_IN_END) {
3877 port = DEFAULT_CODEC_TX_BACKEND;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3878 if (backend_tag_table[snd_device] != NULL) {
3879 if (strcmp(backend_tag_table[snd_device], "usb-headset-mic") == 0)
3880 port = USB_AUDIO_TX_BACKEND;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]3881 else if (strstr(backend_tag_table[snd_device], "bt-sco") != NULL)
3882 port = BT_SCO_TX_BACKEND;
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]3883 else if (strcmp(backend_tag_table[snd_device], "spdif-in") == 0)
3884 port = SPDIF_TX_BACKEND;
3885 else if (strcmp(backend_tag_table[snd_device], "hdmi-in") == 0)
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]3886 port = HDMI_TX_BACKEND;
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]3887 else if (strcmp(backend_tag_table[snd_device], "hdmi-arc-in") == 0)
3888 port = HDMI_ARC_TX_BACKEND;
Samyak Jainb3f3ca52019-01-02 18:24:35 +0530[diff] [blame]3889 else if (strcmp(backend_tag_table[snd_device], "headset-mic") == 0)
3890 port = HEADSET_TX_BACKEND;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3891 }
3892 } else {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3893 ALOGW("%s:napb: Invalid device - %d ", __func__, snd_device);
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3894 }
3895
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3896 ALOGV("%s:napb: backend port - %d device - %d ", __func__, port, snd_device);
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3897 return port;
3898}
3899
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3900int platform_send_audio_calibration(void *platform, struct audio_usecase *usecase,
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]3901 int app_type, int sample_rate)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3902{
3903 struct platform_data *my_data = (struct platform_data *)platform;
3904 int acdb_dev_id, acdb_dev_type;
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3905 int snd_device = SND_DEVICE_OUT_SPEAKER;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]3906 int new_snd_device[SND_DEVICE_OUT_END] = {0};
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3907 int i, num_devices = 1;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3908
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3909 if (usecase->type == PCM_PLAYBACK)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3910 snd_device = usecase->out_snd_device;
Karthik Reddy Katta81c42612015-11-13 17:49:07 +0530[diff] [blame]3911 else if ((usecase->type == PCM_CAPTURE) &&
3912 voice_is_in_call_rec_stream(usecase->stream.in))
3913 snd_device = voice_get_incall_rec_snd_device(usecase->in_snd_device);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3914 else if ((usecase->type == PCM_HFP_CALL) || (usecase->type == PCM_CAPTURE))
Vidyakumar Athotab0975c32015-07-21 14:15:03 -0700[diff] [blame]3915 snd_device = usecase->in_snd_device;
Surendar Karka93cd25a2018-08-28 14:21:37 +0530[diff] [blame]3916 else if (usecase->type == TRANSCODE_LOOPBACK_RX)
Siddartha Shaik343abc62017-08-08 11:15:25 +0530[diff] [blame]3917 snd_device = usecase->out_snd_device;
Vidyakumar Athotab0975c32015-07-21 14:15:03 -0700[diff] [blame]3918
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]3919 acdb_dev_id = acdb_device_table[platform_get_spkr_prot_snd_device(snd_device)];
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3920 if (acdb_dev_id < 0) {
3921 ALOGE("%s: Could not find acdb id for device(%d)",
3922 __func__, snd_device);
3923 return -EINVAL;
3924 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3925
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3926 if (platform_split_snd_device(my_data, snd_device,
3927 &num_devices, new_snd_device) < 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3928 new_snd_device[0] = snd_device;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3929 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3930
3931 for (i = 0; i < num_devices; i++) {
3932 acdb_dev_id = acdb_device_table[platform_get_spkr_prot_snd_device(new_snd_device[i])];
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3933
3934 // Do not use Rx path default app type for TX path
3935 if ((usecase->type == PCM_CAPTURE) && (app_type == DEFAULT_APP_TYPE_RX_PATH)) {
3936 ALOGD("Resetting app type for Tx path to default");
3937 app_type = DEFAULT_APP_TYPE_TX_PATH;
3938 }
3939
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3940 if (acdb_dev_id < 0) {
3941 ALOGE("%s: Could not find acdb id for device(%d)",
3942 __func__, new_snd_device[i]);
3943 return -EINVAL;
3944 }
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]3945 ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
3946 __func__, new_snd_device[i], acdb_dev_id);
3947 if (new_snd_device[i] >= SND_DEVICE_OUT_BEGIN &&
3948 new_snd_device[i] < SND_DEVICE_OUT_END)
3949 acdb_dev_type = ACDB_DEV_TYPE_OUT;
3950 else
3951 acdb_dev_type = ACDB_DEV_TYPE_IN;
3952
3953 if (my_data->acdb_send_audio_cal_v3) {
3954 my_data->acdb_send_audio_cal_v3(acdb_dev_id, acdb_dev_type,
3955 app_type, sample_rate, i);
3956 } else if (my_data->acdb_send_audio_cal) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3957 my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type, app_type,
3958 sample_rate);
3959 }
3960 }
3961
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3962 return 0;
3963}
3964
3965int platform_switch_voice_call_device_pre(void *platform)
3966{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3967 struct platform_data *my_data = (struct platform_data *)platform;
3968 int ret = 0;
3969
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]3970 if (my_data->csd != NULL &&
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -0700[diff] [blame]3971 voice_is_in_call(my_data->adev)) {
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3972 /* This must be called before disabling mixer controls on APQ side */
3973 ret = my_data->csd->disable_device();
3974 if (ret < 0) {
3975 ALOGE("%s: csd_client_disable_device, failed, error %d",
3976 __func__, ret);
3977 }
3978 }
3979 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3980}
3981
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3982int platform_switch_voice_call_enable_device_config(void *platform,
3983 snd_device_t out_snd_device,
3984 snd_device_t in_snd_device)
3985{
3986 struct platform_data *my_data = (struct platform_data *)platform;
3987 int acdb_rx_id, acdb_tx_id;
3988 int ret = 0;
3989
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3990 if (my_data->csd == NULL)
3991 return ret;
3992
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3993 if ((out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3994 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
3995 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
3996 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3997 audio_extn_spkr_prot_is_enabled()) {
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]3998 if (my_data->is_vbat_speaker || my_data->is_bcl_speaker)
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3999 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT];
4000 else
4001 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED];
4002 } else
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4003 acdb_rx_id = platform_get_snd_device_acdb_id(out_snd_device);
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4004
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4005 acdb_tx_id = platform_get_snd_device_acdb_id(in_snd_device);
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]4006
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4007 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
4008 ret = my_data->csd->enable_device_config(acdb_rx_id, acdb_tx_id);
4009 if (ret < 0) {
4010 ALOGE("%s: csd_enable_device_config, failed, error %d",
4011 __func__, ret);
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]4012 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4013 } else {
4014 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
4015 acdb_rx_id, acdb_tx_id);
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]4016 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4017
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]4018 return ret;
4019}
4020
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4021int platform_switch_voice_call_device_post(void *platform,
4022 snd_device_t out_snd_device,
4023 snd_device_t in_snd_device)
4024{
4025 struct platform_data *my_data = (struct platform_data *)platform;
4026 int acdb_rx_id, acdb_tx_id;
4027
4028 if (my_data->acdb_send_voice_cal == NULL) {
4029 ALOGE("%s: dlsym error for acdb_send_voice_call", __func__);
4030 } else {
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4031 if (audio_extn_spkr_prot_is_enabled()) {
4032 if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER)
4033 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]4034 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_STEREO)
4035 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4036 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT)
4037 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT;
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]4038 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2)
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4039 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED;
4040 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT)
4041 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT;
4042 }
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]4043
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4044 acdb_rx_id = platform_get_snd_device_acdb_id(out_snd_device);
4045 acdb_tx_id = platform_get_snd_device_acdb_id(in_snd_device);
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]4046
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4047 if (acdb_rx_id > 0 && acdb_tx_id > 0)
4048 my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id);
4049 else
4050 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
4051 acdb_rx_id, acdb_tx_id);
4052 }
4053
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]4054 return 0;
4055}
4056
4057int platform_switch_voice_call_usecase_route_post(void *platform,
4058 snd_device_t out_snd_device,
4059 snd_device_t in_snd_device)
4060{
4061 struct platform_data *my_data = (struct platform_data *)platform;
4062 int acdb_rx_id, acdb_tx_id;
4063 int ret = 0;
4064
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4065 if (my_data->csd == NULL)
4066 return ret;
4067
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]4068 if ((out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4069 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
4070 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
4071 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]4072 audio_extn_spkr_prot_is_enabled()) {
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]4073 if (my_data->is_vbat_speaker || my_data->is_bcl_speaker)
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]4074 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT];
4075 else
4076 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED];
4077 } else
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4078 acdb_rx_id = platform_get_snd_device_acdb_id(out_snd_device);
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4079
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4080 acdb_tx_id = platform_get_snd_device_acdb_id(in_snd_device);
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]4081
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4082 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
4083 ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id,
4084 my_data->adev->acdb_settings);
4085 if (ret < 0) {
4086 ALOGE("%s: csd_enable_device, failed, error %d", __func__, ret);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4087 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4088 } else {
4089 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
4090 acdb_rx_id, acdb_tx_id);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4091 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]4092
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4093 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4094}
4095
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4096int platform_start_voice_call(void *platform, uint32_t vsid)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4097{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4098 struct platform_data *my_data = (struct platform_data *)platform;
4099 int ret = 0;
4100
4101 if (my_data->csd != NULL) {
4102 ret = my_data->csd->start_voice(vsid);
4103 if (ret < 0) {
4104 ALOGE("%s: csd_start_voice error %d\n", __func__, ret);
4105 }
4106 }
4107 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4108}
4109
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4110int platform_stop_voice_call(void *platform, uint32_t vsid)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4111{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4112 struct platform_data *my_data = (struct platform_data *)platform;
4113 int ret = 0;
4114
4115 if (my_data->csd != NULL) {
4116 ret = my_data->csd->stop_voice(vsid);
4117 if (ret < 0) {
4118 ALOGE("%s: csd_stop_voice error %d\n", __func__, ret);
4119 }
4120 }
4121 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4122}
4123
Vignesh Kulothungan7d374312018-02-21 17:12:00 -0800[diff] [blame]4124int platform_set_mic_break_det(void *platform, bool enable)
4125{
4126 int ret = 0;
4127 struct platform_data *my_data = (struct platform_data *)platform;
4128 struct audio_device *adev = my_data->adev;
4129 const char *mixer_ctl_name = "Voice Mic Break Enable";
4130 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4131 if (!ctl) {
4132 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4133 __func__, mixer_ctl_name);
4134 return -EINVAL;
4135 }
4136
4137 ret = mixer_ctl_set_value(ctl, 0, enable);
4138 if(ret)
4139 ALOGE("%s: Failed to set mixer ctl: %s", __func__, mixer_ctl_name);
4140
4141 return ret;
4142}
4143
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]4144int platform_get_sample_rate(void *platform, uint32_t *rate)
4145{
4146 struct platform_data *my_data = (struct platform_data *)platform;
4147 int ret = 0;
4148
4149 if ((my_data->csd != NULL) && my_data->is_i2s_ext_modem) {
4150 ret = my_data->csd->get_sample_rate(rate);
4151 if (ret < 0) {
4152 ALOGE("%s: csd_get_sample_rate error %d\n", __func__, ret);
4153 }
4154 }
4155 return ret;
4156}
4157
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4158void platform_set_speaker_gain_in_combo(struct audio_device *adev,
4159 snd_device_t snd_device,
4160 bool enable)
4161{
4162 const char* name;
4163 switch (snd_device) {
4164 case SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES:
4165 if (enable)
4166 name = "spkr-gain-in-headphone-combo";
4167 else
4168 name = "speaker-gain-default";
4169 break;
4170 case SND_DEVICE_OUT_SPEAKER_AND_LINE:
4171 if (enable)
4172 name = "spkr-gain-in-line-combo";
4173 else
4174 name = "speaker-gain-default";
4175 break;
4176 case SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES:
4177 if (enable)
4178 name = "spkr-safe-gain-in-headphone-combo";
4179 else
4180 name = "speaker-safe-gain-default";
4181 break;
4182 case SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE:
4183 if (enable)
4184 name = "spkr-safe-gain-in-line-combo";
4185 else
4186 name = "speaker-safe-gain-default";
4187 break;
4188 default:
4189 return;
4190 }
4191
4192 audio_route_apply_and_update_path(adev->audio_route, name);
4193}
4194
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4195int platform_set_voice_volume(void *platform, int volume)
4196{
4197 struct platform_data *my_data = (struct platform_data *)platform;
4198 struct audio_device *adev = my_data->adev;
4199 struct mixer_ctl *ctl;
sangwoo53b2cf02013-07-25 19:18:44 -0700[diff] [blame]4200 const char *mixer_ctl_name = "Voice Rx Gain";
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4201 const char *mute_mixer_ctl_name = "Voice Rx Device Mute";
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4202 int vol_index = 0, ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]4203 long set_values[ ] = {0,
4204 ALL_SESSION_VSID,
4205 DEFAULT_VOLUME_RAMP_DURATION_MS};
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4206
4207 // Voice volume levels are mapped to adsp volume levels as follows.
4208 // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0
4209 // But this values don't changed in kernel. So, below change is need.
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4210 vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, my_data->max_vol_index);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4211 set_values[0] = vol_index;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4212
4213 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4214 if (!ctl) {
4215 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4216 __func__, mixer_ctl_name);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4217 return -EINVAL;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4218 }
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4219 ALOGV("%s: Setting voice volume index: %ld", __func__, set_values[0]);
4220 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
4221
4222 // Send mute command in case volume index is max since indexes are inverted
4223 // for mixer controls.
4224 if (vol_index == my_data->max_vol_index)
4225 set_values[0] = 1;
4226 else
4227 set_values[0] = 0;
4228
4229 ctl = mixer_get_ctl_by_name(adev->mixer, mute_mixer_ctl_name);
4230 if (!ctl) {
4231 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4232 __func__, mute_mixer_ctl_name);
4233 return -EINVAL;
4234 }
4235 ALOGV("%s: Setting RX Device Mute to: %ld", __func__, set_values[0]);
4236 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4237
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4238 if (my_data->csd != NULL) {
Vidyakumar Athotac37f42a2014-03-11 11:57:48 -0700[diff] [blame]4239 ret = my_data->csd->volume(ALL_SESSION_VSID, volume,
4240 DEFAULT_VOLUME_RAMP_DURATION_MS);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4241 if (ret < 0) {
4242 ALOGE("%s: csd_volume error %d", __func__, ret);
4243 }
4244 }
4245 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4246}
4247
4248int platform_set_mic_mute(void *platform, bool state)
4249{
4250 struct platform_data *my_data = (struct platform_data *)platform;
4251 struct audio_device *adev = my_data->adev;
4252 struct mixer_ctl *ctl;
4253 const char *mixer_ctl_name = "Voice Tx Mute";
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4254 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]4255 long set_values[ ] = {0,
4256 ALL_SESSION_VSID,
4257 DEFAULT_MUTE_RAMP_DURATION_MS};
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4258
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4259 if (adev->mode != AUDIO_MODE_IN_CALL &&
4260 adev->mode != AUDIO_MODE_IN_COMMUNICATION)
4261 return 0;
4262
4263 if (adev->enable_hfp)
4264 mixer_ctl_name = "HFP Tx Mute";
4265
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4266 set_values[0] = state;
4267 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4268 if (!ctl) {
4269 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4270 __func__, mixer_ctl_name);
Josh Kirsch5669ad92016-12-09 10:48:52 -0800[diff] [blame]4271 ret = -EINVAL;
4272 } else {
4273 ALOGV("%s Setting voice mute state: %d", __func__, state);
4274 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4275 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4276
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4277 if (my_data->csd != NULL) {
Vidyakumar Athotac37f42a2014-03-11 11:57:48 -0700[diff] [blame]4278 ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state,
4279 DEFAULT_MUTE_RAMP_DURATION_MS);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4280 if (ret < 0) {
4281 ALOGE("%s: csd_mic_mute error %d", __func__, ret);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4282 }
4283 }
4284 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4285}
4286
Shiv Maliyappanahallic6fd8ee2014-03-07 15:31:55 -0800[diff] [blame]4287int platform_set_device_mute(void *platform, bool state, char *dir)
4288{
4289 struct platform_data *my_data = (struct platform_data *)platform;
4290 struct audio_device *adev = my_data->adev;
4291 struct mixer_ctl *ctl;
4292 char *mixer_ctl_name = NULL;
4293 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]4294 long set_values[ ] = {0,
4295 ALL_SESSION_VSID,
4296 0};
Shiv Maliyappanahallic6fd8ee2014-03-07 15:31:55 -0800[diff] [blame]4297 if(dir == NULL) {
4298 ALOGE("%s: Invalid direction:%s", __func__, dir);
4299 return -EINVAL;
4300 }
4301
4302 if (!strncmp("rx", dir, sizeof("rx"))) {
4303 mixer_ctl_name = "Voice Rx Device Mute";
4304 } else if (!strncmp("tx", dir, sizeof("tx"))) {
4305 mixer_ctl_name = "Voice Tx Device Mute";
4306 } else {
4307 return -EINVAL;
4308 }
4309
4310 set_values[0] = state;
4311 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4312 if (!ctl) {
4313 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4314 __func__, mixer_ctl_name);
4315 return -EINVAL;
4316 }
4317
4318 ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s",
4319 __func__,state, mixer_ctl_name);
4320 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
4321
4322 return ret;
4323}
4324
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4325int platform_split_snd_device(void *platform,
4326 snd_device_t snd_device,
4327 int *num_devices,
4328 snd_device_t *new_snd_devices)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4329{
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4330 int ret = -EINVAL;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4331 struct platform_data *my_data = (struct platform_data *)platform;
4332
4333 if ( NULL == num_devices || NULL == new_snd_devices || NULL == my_data) {
4334 ALOGE("%s: NULL pointer ..", __func__);
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4335 return -EINVAL;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4336 }
4337
4338 /*
4339 * If wired headset/headphones/line devices share the same backend
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4340 * with speaker/earpiece this routine returns -EINVAL.
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4341 */
4342 if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES &&
4343 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HEADPHONES)) {
4344 *num_devices = 2;
4345 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4346 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4347 ret = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4348 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_LINE &&
4349 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_LINE)) {
4350 *num_devices = 2;
4351 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4352 new_snd_devices[1] = SND_DEVICE_OUT_LINE;
4353 ret = 0;
4354 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES &&
4355 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE, SND_DEVICE_OUT_HEADPHONES)) {
4356 *num_devices = 2;
4357 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4358 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
4359 ret = 0;
4360 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE &&
4361 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE, SND_DEVICE_OUT_LINE)) {
4362 *num_devices = 2;
4363 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4364 new_snd_devices[1] = SND_DEVICE_OUT_LINE;
4365 ret = 0;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4366 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET &&
4367 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_ANC_HEADSET)) {
4368 *num_devices = 2;
4369 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4370 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
4371 ret = 0;
4372 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET &&
4373 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_ANC_FB_HEADSET)) {
4374 *num_devices = 2;
4375 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4376 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
4377 ret = 0;
4378 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES &&
4379 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_HEADPHONES)) {
4380 *num_devices = 2;
4381 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
4382 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_HEADPHONES;
4383 ret = 0;
4384 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET &&
4385 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_ANC_HEADSET)) {
4386 *num_devices = 2;
4387 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
4388 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
4389 ret = 0;
4390 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET &&
4391 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)) {
4392 *num_devices = 2;
4393 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
4394 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
4395 ret = 0;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]4396 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_HEADPHONES &&
4397 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER_STEREO, SND_DEVICE_OUT_VOICE_HEADPHONES)) {
4398 *num_devices = 2;
4399 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER_STEREO;
4400 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_HEADPHONES;
4401 ret = 0;
4402 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_HEADSET &&
4403 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER_STEREO, SND_DEVICE_OUT_VOICE_ANC_HEADSET)) {
4404 *num_devices = 2;
4405 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER_STEREO;
4406 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
4407 ret = 0;
4408 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_AND_VOICE_ANC_FB_HEADSET &&
4409 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER_STEREO, SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)) {
4410 *num_devices = 2;
4411 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER_STEREO;
4412 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
4413 ret = 0;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4414 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI &&
4415 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HDMI)) {
4416 *num_devices = 2;
4417 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4418 new_snd_devices[1] = SND_DEVICE_OUT_HDMI;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4419 ret = 0;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4420 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT &&
4421 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_DISPLAY_PORT)) {
4422 *num_devices = 2;
4423 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4424 new_snd_devices[1] = SND_DEVICE_OUT_DISPLAY_PORT;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4425 ret = 0;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]4426 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET &&
4427 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_USB_HEADSET)) {
4428 *num_devices = 2;
4429 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4430 new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4431 ret = 0;
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]4432 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_SCO &&
4433 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_BT_SCO)) {
4434 *num_devices = 2;
4435 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4436 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO;
4437 ret = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4438 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO &&
4439 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE,
4440 SND_DEVICE_OUT_BT_SCO)) {
4441 *num_devices = 2;
4442 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4443 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO;
4444 ret = 0;
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]4445 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB &&
4446 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_BT_SCO_WB)) {
4447 *num_devices = 2;
4448 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4449 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO_WB;
4450 ret = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4451 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB &&
4452 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE,
4453 SND_DEVICE_OUT_BT_SCO_WB)) {
4454 *num_devices = 2;
4455 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4456 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO_WB;
4457 ret = 0;
4458 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET &&
4459 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE, SND_DEVICE_OUT_USB_HEADSET)) {
4460 *num_devices = 2;
4461 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4462 new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
4463 ret = 0;
Naresh Tannirucd2353e2016-08-19 00:37:25 +0530[diff] [blame]4464 } else if (SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) {
4465 *num_devices = 2;
4466 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
4467 new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4468 ret = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4469 } else if (SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP == snd_device &&
4470 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER_SAFE,
4471 SND_DEVICE_OUT_BT_A2DP)) {
4472 *num_devices = 2;
4473 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
4474 new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
4475 ret = 0;
Divya Narayanan Poojary85d0a592018-02-06 14:25:16 +0530[diff] [blame]4476 } else if (SND_DEVICE_IN_INCALL_REC_RX_TX == snd_device) {
4477 *num_devices = 2;
4478 new_snd_devices[0] = SND_DEVICE_IN_INCALL_REC_RX;
4479 new_snd_devices[1] = SND_DEVICE_IN_INCALL_REC_TX;
4480 ret = 0;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4481 }
4482
4483 ALOGD("%s: snd_device(%d) num devices(%d) new_snd_devices(%d)", __func__,
4484 snd_device, *num_devices, *new_snd_devices);
4485
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]4486 return ret;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]4487}
4488
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4489int platform_get_ext_disp_type(void *platform)
4490{
4491 int disp_type;
4492 struct platform_data *my_data = (struct platform_data *)platform;
4493
4494 if (my_data->ext_disp_type != EXT_DISPLAY_TYPE_NONE) {
4495 ALOGD("%s: Returning cached ext disp type:%s",
4496 __func__, (my_data->ext_disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
4497 return my_data->ext_disp_type;
4498 }
4499
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]4500 if (audio_extn_is_display_port_enabled()) {
4501 struct audio_device *adev = my_data->adev;
4502 struct mixer_ctl *ctl;
4503 char *mixer_ctl_name = "External Display Type";
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4504
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]4505 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4506 if (!ctl) {
4507 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4508 __func__, mixer_ctl_name);
4509 return -EINVAL;
4510 }
4511
4512 disp_type = mixer_ctl_get_value(ctl, 0);
4513 if (disp_type == EXT_DISPLAY_TYPE_NONE) {
4514 ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
4515 return -EINVAL;
4516 }
4517 } else {
4518 disp_type = EXT_DISPLAY_TYPE_HDMI;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4519 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4520 my_data->ext_disp_type = disp_type;
4521 ALOGD("%s: ext disp type:%s", __func__, (disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
4522 return disp_type;
4523}
4524
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4525snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *out)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4526{
4527 struct platform_data *my_data = (struct platform_data *)platform;
4528 struct audio_device *adev = my_data->adev;
4529 audio_mode_t mode = adev->mode;
4530 snd_device_t snd_device = SND_DEVICE_NONE;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4531 audio_devices_t devices = out->devices;
4532 unsigned int sample_rate = out->sample_rate;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]4533 int na_mode = platform_get_native_support();
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4534
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4535 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
4536 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
4537 int channel_count = popcount(channel_mask);
4538
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4539 ALOGV("%s: enter: output devices(%#x)", __func__, devices);
4540 if (devices == AUDIO_DEVICE_NONE ||
4541 devices & AUDIO_DEVICE_BIT_IN) {
4542 ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
4543 goto exit;
4544 }
4545
Shiv Maliyappanahallibd401262015-08-17 11:02:21 -0700[diff] [blame]4546 if (popcount(devices) == 2) {
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4547 bool is_active_voice_call = false;
4548
4549 /*
4550 * This is special case handling for combo device use case during
4551 * voice call. APM route use case to combo device if stream type is
4552 * enforced audible (e.g. Camera shutter sound).
4553 */
4554 if ((mode == AUDIO_MODE_IN_CALL) ||
4555 voice_is_in_call(adev) ||
4556 voice_extn_compress_voip_is_active(adev))
4557 is_active_voice_call = true;
4558
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]4559 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
4560 AUDIO_DEVICE_OUT_SPEAKER)) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4561 if (my_data->external_spk_1)
4562 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1;
4563 else if (my_data->external_spk_2)
4564 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4565 else if (is_active_voice_call)
4566 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4567 else
4568 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]4569 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
4570 AUDIO_DEVICE_OUT_SPEAKER)) {
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]4571 if (audio_extn_get_anc_enabled()) {
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4572 if (audio_extn_should_use_fb_anc()) {
4573 if (is_active_voice_call)
4574 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET;
4575 else
4576 snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET;
4577 } else {
4578 if (is_active_voice_call)
4579 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET;
4580 else
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4581 snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4582 }
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]4583 } else if (my_data->external_spk_1)
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4584 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1;
4585 else if (my_data->external_spk_2)
4586 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]4587 else {
4588 if (is_active_voice_call)
4589 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES;
4590 else
4591 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
4592 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4593 } else if (devices == (AUDIO_DEVICE_OUT_LINE |
4594 AUDIO_DEVICE_OUT_SPEAKER)) {
4595 snd_device = SND_DEVICE_OUT_SPEAKER_AND_LINE;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4596 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
4597 AUDIO_DEVICE_OUT_SPEAKER_SAFE) ||
4598 devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
4599 AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
4600 snd_device = SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES;
4601 } else if (devices == (AUDIO_DEVICE_OUT_LINE |
4602 AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
4603 snd_device = SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]4604 } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL |
4605 AUDIO_DEVICE_OUT_SPEAKER)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4606 switch(my_data->ext_disp_type) {
4607 case EXT_DISPLAY_TYPE_HDMI:
4608 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI;
4609 break;
4610 case EXT_DISPLAY_TYPE_DP:
4611 snd_device = SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT;
4612 break;
4613 default:
4614 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
4615 goto exit;
4616 }
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]4617 } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
4618 AUDIO_DEVICE_OUT_SPEAKER)) {
4619 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]4620 } else if ((devices == (AUDIO_DEVICE_OUT_USB_DEVICE |
4621 AUDIO_DEVICE_OUT_SPEAKER)) ||
4622 (devices == (AUDIO_DEVICE_OUT_USB_HEADSET |
4623 AUDIO_DEVICE_OUT_SPEAKER))) {
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]4624 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]4625 } else if ((devices & AUDIO_DEVICE_OUT_SPEAKER) &&
4626 (devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
4627 snd_device = SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4628 } else if ((devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) &&
4629 (devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
4630 snd_device = SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP;
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]4631 } else if ((devices & AUDIO_DEVICE_OUT_ALL_SCO) &&
4632 ((devices & ~AUDIO_DEVICE_OUT_ALL_SCO) == AUDIO_DEVICE_OUT_SPEAKER)) {
4633 snd_device = adev->bt_wb_speech_enabled ?
4634 SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB :
4635 SND_DEVICE_OUT_SPEAKER_AND_BT_SCO;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4636 } else if ((devices & AUDIO_DEVICE_OUT_ALL_SCO) &&
4637 ((devices & ~AUDIO_DEVICE_OUT_ALL_SCO) == AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
4638 snd_device = adev->bt_wb_speech_enabled ?
4639 SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO_WB :
4640 SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_SCO;
4641 } else if ((devices == (AUDIO_DEVICE_OUT_USB_DEVICE |
4642 AUDIO_DEVICE_OUT_SPEAKER_SAFE)) ||
4643 (devices == (AUDIO_DEVICE_OUT_USB_HEADSET |
4644 AUDIO_DEVICE_OUT_SPEAKER_SAFE))) {
4645 snd_device = SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]4646 } else {
4647 ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
4648 goto exit;
4649 }
4650 if (snd_device != SND_DEVICE_NONE) {
4651 goto exit;
4652 }
4653 }
4654
4655 if (popcount(devices) != 1) {
4656 ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
4657 goto exit;
4658 }
4659
Venkata Narendra Kumar Guttabfdfa152015-06-22 14:25:35 +0530[diff] [blame]4660 if ((mode == AUDIO_MODE_IN_CALL) ||
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]4661 voice_is_in_call(adev) ||
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4662 voice_extn_compress_voip_is_active(adev) ||
4663 adev->enable_voicerx ||
4664 audio_extn_hfp_is_active(adev)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4665 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4666 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
4667 devices & AUDIO_DEVICE_OUT_LINE) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4668 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
4669 !voice_extn_compress_voip_is_active(adev)) {
4670 switch (adev->voice.tty_mode) {
4671 case TTY_MODE_FULL:
4672 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
4673 break;
4674 case TTY_MODE_VCO:
4675 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
4676 break;
4677 case TTY_MODE_HCO:
4678 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
4679 break;
4680 default:
4681 ALOGE("%s: Invalid TTY mode (%#x)",
4682 __func__, adev->voice.tty_mode);
4683 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4684 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
4685 snd_device = SND_DEVICE_OUT_VOICE_LINE;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4686 } else if (audio_extn_get_anc_enabled()) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4687 if (audio_extn_should_use_fb_anc())
4688 snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
4689 else
4690 snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4691 } else {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4692 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4693 }
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]4694 } else if (devices &
4695 (AUDIO_DEVICE_OUT_USB_DEVICE |
4696 AUDIO_DEVICE_OUT_USB_HEADSET)) {
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]4697 if (voice_is_in_call(adev)) {
4698 switch (adev->voice.tty_mode) {
4699 case TTY_MODE_FULL:
4700 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_USB;
4701 break;
4702 case TTY_MODE_VCO:
4703 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_USB;
4704 break;
4705 case TTY_MODE_HCO:
4706 // since Hearing will be on handset\speaker, use existing device
4707 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
4708 break;
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4709 case TTY_MODE_OFF:
4710 break;
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]4711 default:
4712 ALOGE("%s: Invalid TTY mode (%#x)",
4713 __func__, adev->voice.tty_mode);
4714 }
4715 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4716 if (snd_device == SND_DEVICE_NONE) {
4717 snd_device = audio_extn_usb_is_capture_supported() ?
4718 SND_DEVICE_OUT_VOICE_USB_HEADSET :
4719 SND_DEVICE_OUT_VOICE_USB_HEADPHONES;
4720 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4721 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]4722 if (adev->bt_wb_speech_enabled)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4723 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
4724 else
4725 snd_device = SND_DEVICE_OUT_BT_SCO;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4726 } else if (devices & (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
4727 if (!adev->enable_hfp) {
4728 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
4729 } else {
4730 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_HFP;
4731 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4732 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
Aditya Bavanari9b589022018-09-20 08:47:55 +0530[diff] [blame]4733 if (my_data->is_vbat_speaker || my_data->is_bcl_speaker) {
kunleizaa6a3f12017-01-19 12:28:28 +0800[diff] [blame]4734 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
4735 if (my_data->mono_speaker == SPKR_1)
4736 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_VBAT;
4737 else
4738 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT;
4739 } else
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4740 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_VBAT;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4741 } else {
kunleizaa6a3f12017-01-19 12:28:28 +0800[diff] [blame]4742 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]4743 if (my_data->voice_speaker_stereo)
4744 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_STEREO;
4745 else {
4746 if (my_data->mono_speaker == SPKR_1)
4747 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
4748 else
4749 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2;
4750 }
kunleizaa6a3f12017-01-19 12:28:28 +0800[diff] [blame]4751 } else
4752 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4753 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]4754 } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
4755 snd_device = SND_DEVICE_OUT_BT_A2DP;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4756 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
4757 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
4758 snd_device = SND_DEVICE_OUT_USB_HEADSET;
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]4759 } else if ((devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
4760 adev->dp_allowed_for_voice) {
4761 switch(my_data->ext_disp_type) {
4762 case EXT_DISPLAY_TYPE_DP:
4763 snd_device = SND_DEVICE_OUT_DISPLAY_PORT;
4764 break;
4765 default:
4766 ALOGE("%s: Invalid disp_type %d", __func__,
4767 my_data->ext_disp_type);
4768 goto exit;
4769 }
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]4770 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
4771 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4772 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4773 if(adev->voice.hac)
4774 snd_device = SND_DEVICE_OUT_VOICE_HAC_HANDSET;
4775 else if (is_operator_tmus())
4776 snd_device = SND_DEVICE_OUT_VOICE_HANDSET_TMUS;
4777 else if (audio_extn_should_use_handset_anc(channel_count))
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4778 snd_device = SND_DEVICE_OUT_ANC_HANDSET;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4779 else
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]4780 snd_device = SND_DEVICE_OUT_VOICE_HANDSET;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]4781 } else if (devices & AUDIO_DEVICE_OUT_TELEPHONY_TX)
4782 snd_device = SND_DEVICE_OUT_VOICE_TX;
4783
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4784 if (snd_device != SND_DEVICE_NONE) {
4785 goto exit;
4786 }
4787 }
4788
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4789 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]4790 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
4791 devices & AUDIO_DEVICE_OUT_LINE) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4792 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET
4793 && audio_extn_get_anc_enabled()) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4794 if (audio_extn_should_use_fb_anc())
4795 snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET;
4796 else
4797 snd_device = SND_DEVICE_OUT_ANC_HEADSET;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]4798 } else if (NATIVE_AUDIO_MODE_SRC == na_mode &&
4799 OUTPUT_SAMPLING_RATE_44100 == sample_rate) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4800 snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]4801 } else if (NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode &&
4802 (sample_rate % OUTPUT_SAMPLING_RATE_44100 == 0) &&
4803 (out->format != AUDIO_FORMAT_DSD)) {
4804 snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;
4805 } else if (out->format == AUDIO_FORMAT_DSD) {
4806 snd_device = SND_DEVICE_OUT_HEADPHONES_DSD;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]4807 } else
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4808 snd_device = SND_DEVICE_OUT_HEADPHONES;
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4809 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
4810 snd_device = SND_DEVICE_OUT_LINE;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4811 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
4812 snd_device = SND_DEVICE_OUT_SPEAKER_SAFE;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4813 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4814 if (my_data->external_spk_1)
4815 snd_device = SND_DEVICE_OUT_SPEAKER_EXTERNAL_1;
4816 else if (my_data->external_spk_2)
4817 snd_device = SND_DEVICE_OUT_SPEAKER_EXTERNAL_2;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4818 else if (adev->speaker_lr_swap) {
4819 /*
4820 * Perform device switch only if acdb tuning is
4821 * different between SPEAKER & SPEAKER_REVERSE,
4822 * Or there will be a small pause while performing
4823 * device switch.
4824 */
4825 if (acdb_device_table[SND_DEVICE_OUT_SPEAKER] !=
4826 acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE])
4827 snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE;
4828 else
4829 snd_device = SND_DEVICE_OUT_SPEAKER;
4830 } else if (my_data->is_vbat_speaker || my_data->is_bcl_speaker)
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]4831 snd_device = SND_DEVICE_OUT_SPEAKER_VBAT;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4832 else
4833 snd_device = SND_DEVICE_OUT_SPEAKER;
4834 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]4835 if (adev->bt_wb_speech_enabled)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4836 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
4837 else
4838 snd_device = SND_DEVICE_OUT_BT_SCO;
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]4839 } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
4840 snd_device = SND_DEVICE_OUT_BT_A2DP;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4841 } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4842 switch(my_data->ext_disp_type) {
4843 case EXT_DISPLAY_TYPE_HDMI:
4844 snd_device = SND_DEVICE_OUT_HDMI;
4845 break;
4846 case EXT_DISPLAY_TYPE_DP:
4847 snd_device = SND_DEVICE_OUT_DISPLAY_PORT;
4848 break;
4849 default:
4850 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
4851 goto exit;
4852 }
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4853 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
4854 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]4855 ALOGD("%s: setting USB hadset channel capability(2) for Proxy", __func__);
4856 audio_extn_set_afe_proxy_channel_mixer(adev, 2);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4857 snd_device = SND_DEVICE_OUT_USB_HEADSET;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]4858 } else if (devices &
4859 (AUDIO_DEVICE_OUT_USB_DEVICE |
4860 AUDIO_DEVICE_OUT_USB_HEADSET)) {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]4861 if (audio_extn_qdsp_supported_usb())
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4862 snd_device = SND_DEVICE_OUT_USB_HEADSET_SPEC;
4863 else if (audio_extn_usb_is_capture_supported())
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]4864 snd_device = SND_DEVICE_OUT_USB_HEADSET;
4865 else
4866 snd_device = SND_DEVICE_OUT_USB_HEADPHONES;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]4867 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
4868 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4869 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4870 /*HAC support for voice-ish audio (eg visual voicemail)*/
4871 if(adev->voice.hac)
4872 snd_device = SND_DEVICE_OUT_VOICE_HAC_HANDSET;
4873 else
4874 snd_device = SND_DEVICE_OUT_HANDSET;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4875 } else if (devices & AUDIO_DEVICE_OUT_PROXY) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]4876 channel_count = audio_extn_get_afe_proxy_channel_count();
4877 ALOGD("%s: setting sink capability(%d) for Proxy", __func__, channel_count);
4878 audio_extn_set_afe_proxy_channel_mixer(adev, channel_count);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4879 snd_device = SND_DEVICE_OUT_AFE_PROXY;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4880 } else {
4881 ALOGE("%s: Unknown device(s) %#x", __func__, devices);
4882 }
4883exit:
4884 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
4885 return snd_device;
4886}
4887
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]4888static snd_device_t get_snd_device_for_voice_comm_ecns_enabled(struct platform_data *my_data,
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4889 audio_devices_t out_device,
4890 audio_devices_t in_device)
4891{
4892 struct audio_device *adev = my_data->adev;
4893 snd_device_t snd_device = SND_DEVICE_NONE;
4894
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]4895 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
4896 if (my_data->fluence_in_spkr_mode) {
4897 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4898 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4899 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS;
4900 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
4901 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4902 snd_device = SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS;
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]4903 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]4904 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
4905 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
4906 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
4907 else
4908 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
4909 }
4910 adev->acdb_settings |= DMIC_FLAG;
4911 } else
4912 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
4913 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
4914 if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
4915 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4916 snd_device = SND_DEVICE_IN_HANDSET_TMIC_AEC_NS;
4917 adev->acdb_settings |= TMIC_FLAG;
4918 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
4919 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
4920 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
4921 adev->acdb_settings |= DMIC_FLAG;
4922 } else
4923 snd_device = SND_DEVICE_IN_HANDSET_MIC;
4924 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
4925 snd_device = SND_DEVICE_IN_HEADSET_MIC;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4926 }
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]4927 platform_set_echo_reference(adev, true, out_device);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4928
4929 return snd_device;
4930}
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]4931
4932static snd_device_t get_snd_device_for_voice_comm_ecns_disabled(struct platform_data *my_data,
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4933 audio_devices_t out_device,
4934 audio_devices_t in_device)
4935{
4936 struct audio_device *adev = my_data->adev;
4937 snd_device_t snd_device = SND_DEVICE_NONE;
4938
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]4939 if (adev->active_input->enable_aec &&
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4940 adev->active_input->enable_ns) {
4941 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
4942 if (my_data->fluence_in_spkr_mode) {
4943 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4944 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4945 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS;
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]4946 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
4947 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4948 snd_device = SND_DEVICE_IN_SPEAKER_TMIC_AEC_NS;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4949 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4950 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
4951 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4952 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
4953 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
4954 else
4955 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
4956 }
4957 adev->acdb_settings |= DMIC_FLAG;
4958 } else
4959 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
4960 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]4961 if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
4962 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4963 snd_device = SND_DEVICE_IN_HANDSET_TMIC_AEC_NS;
4964 adev->acdb_settings |= TMIC_FLAG;
4965 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4966 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
4967 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4968 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
4969 adev->acdb_settings |= DMIC_FLAG;
4970 } else
4971 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
4972 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
4973 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
kunleiz1a1d26c2018-06-14 18:48:16 +0800[diff] [blame]4974 } else if (audio_extn_usb_connected(NULL) && audio_is_usb_in_device(in_device | AUDIO_DEVICE_BIT_IN)) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4975 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC_AEC;
4976 }
4977 platform_set_echo_reference(adev, true, out_device);
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]4978 } else if (adev->active_input->enable_aec) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4979 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
4980 if (my_data->fluence_in_spkr_mode) {
4981 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4982 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4983 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC;
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]4984 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
4985 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4986 snd_device = SND_DEVICE_IN_SPEAKER_TMIC_AEC;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4987 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]4988 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
4989 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4990 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
4991 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE;
4992 else
4993 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
4994 }
4995 adev->acdb_settings |= DMIC_FLAG;
4996 } else
4997 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
4998 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]4999 if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5000 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5001 snd_device = SND_DEVICE_IN_HANDSET_TMIC_AEC;
5002 adev->acdb_settings |= TMIC_FLAG;
5003 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5004 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5005 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5006 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
5007 adev->acdb_settings |= DMIC_FLAG;
5008 } else
5009 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
5010 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
5011 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
kunleiz1a1d26c2018-06-14 18:48:16 +0800[diff] [blame]5012 } else if (audio_extn_usb_connected(NULL) && audio_is_usb_in_device(in_device | AUDIO_DEVICE_BIT_IN)) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5013 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC_AEC;
5014 }
5015 platform_set_echo_reference(adev, true, out_device);
Vignesh Kulothungan033c7cb2018-07-12 11:35:57 -0700[diff] [blame]5016 } else if (adev->active_input->enable_ns) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5017 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
5018 if (my_data->fluence_in_spkr_mode) {
5019 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5020 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
5021 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_NS;
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]5022 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5023 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5024 snd_device = SND_DEVICE_IN_SPEAKER_TMIC_NS;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5025 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5026 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5027 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5028 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
5029 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE;
5030 else
5031 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
5032 }
5033 adev->acdb_settings |= DMIC_FLAG;
5034 } else
5035 snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
5036 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]5037 if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5038 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5039 snd_device = SND_DEVICE_IN_HANDSET_TMIC_NS;
5040 adev->acdb_settings |= TMIC_FLAG;
5041 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5042 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5043 my_data->fluence_in_voice_comm) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5044 snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
5045 adev->acdb_settings |= DMIC_FLAG;
5046 } else
5047 snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
5048 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
5049 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
5050 }
5051 platform_set_echo_reference(adev, false, out_device);
5052 } else
5053 platform_set_echo_reference(adev, false, out_device);
5054
5055 return snd_device;
5056}
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]5057
5058static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
5059 audio_devices_t out_device,
5060 audio_devices_t in_device)
5061{
5062 if(voice_extn_is_dynamic_ecns_enabled())
5063 return get_snd_device_for_voice_comm_ecns_enabled(my_data, out_device, in_device);
5064 else
5065 return get_snd_device_for_voice_comm_ecns_disabled(my_data, out_device, in_device);
5066}
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5067
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5068snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
5069{
5070 struct platform_data *my_data = (struct platform_data *)platform;
5071 struct audio_device *adev = my_data->adev;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]5072 /*
5073 * TODO: active_input always points to last opened input. Source returned will
5074 * be wrong if more than one active inputs are present.
5075 */
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5076 audio_source_t source = (adev->active_input == NULL) ?
5077 AUDIO_SOURCE_DEFAULT : adev->active_input->source;
5078
5079 audio_mode_t mode = adev->mode;
5080 audio_devices_t in_device = ((adev->active_input == NULL) ?
5081 AUDIO_DEVICE_NONE : adev->active_input->device)
5082 & ~AUDIO_DEVICE_BIT_IN;
5083 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
5084 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
5085 snd_device_t snd_device = SND_DEVICE_NONE;
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]5086 int channel_count = popcount(channel_mask);
Ashish Jainb8d55fd2016-12-29 14:00:24 +0530[diff] [blame]5087 int str_bitwidth = (adev->active_input == NULL) ?
5088 CODEC_BACKEND_DEFAULT_BIT_WIDTH : adev->active_input->bit_width;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5089
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5090 ALOGV("%s: enter: out_device(%#x) in_device(%#x) channel_count (%d) channel_mask (0x%x)",
5091 __func__, out_device, in_device, channel_count, channel_mask);
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]5092 if (my_data->external_mic) {
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]5093 if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) || voice_is_in_call(adev) ||
Venkata Narendra Kumar Guttabfdfa152015-06-22 14:25:35 +0530[diff] [blame]5094 voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]5095 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
5096 out_device & AUDIO_DEVICE_OUT_EARPIECE ||
5097 out_device & AUDIO_DEVICE_OUT_SPEAKER )
5098 snd_device = SND_DEVICE_IN_HANDSET_MIC_EXTERNAL;
5099 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
5100 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
5101 snd_device = SND_DEVICE_IN_HANDSET_MIC_EXTERNAL;
5102 }
5103 }
5104
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]5105 if (snd_device != AUDIO_DEVICE_NONE)
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]5106 goto exit;
5107
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]5108 if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) || voice_is_in_call(adev) ||
Satya Krishna Pindiproli071950f2014-05-21 14:45:28 +0530[diff] [blame]5109 voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]5110 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
5111 !voice_extn_compress_voip_is_active(adev)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5112 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]5113 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
5114 out_device & AUDIO_DEVICE_OUT_LINE) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5115 switch (adev->voice.tty_mode) {
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]5116 case TTY_MODE_FULL:
5117 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
5118 break;
5119 case TTY_MODE_VCO:
5120 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
5121 break;
5122 case TTY_MODE_HCO:
5123 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
5124 break;
5125 default:
5126 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->voice.tty_mode);
5127 }
5128 goto exit;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]5129 } else if (out_device &
5130 (AUDIO_DEVICE_OUT_USB_DEVICE |
5131 AUDIO_DEVICE_OUT_USB_HEADSET)) {
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]5132 switch (adev->voice.tty_mode) {
5133 case TTY_MODE_FULL:
5134 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC;
5135 break;
5136 case TTY_MODE_VCO:
5137 // since voice will be captured from handset mic, use existing device
5138 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
5139 break;
5140 case TTY_MODE_HCO:
5141 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC;
5142 break;
5143 default:
5144 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->voice.tty_mode);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5145 }
5146 goto exit;
5147 }
5148 }
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]5149 if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]5150 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
5151 out_device & AUDIO_DEVICE_OUT_LINE) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]5152 if (out_device & AUDIO_DEVICE_OUT_EARPIECE &&
5153 audio_extn_should_use_handset_anc(channel_count)) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5154 if ((my_data->fluence_type != FLUENCE_NONE) &&
5155 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]5156 snd_device = SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC;
5157 adev->acdb_settings |= DMIC_FLAG;
5158 } else {
5159 snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC;
5160 }
Banajit Goswamide0ea452014-04-07 12:11:47 -0700[diff] [blame]5161 adev->acdb_settings |= ANC_FLAG;
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]5162 } else if (my_data->fluence_type == FLUENCE_NONE ||
Vikram Pandurangae7b21342017-06-05 15:57:23 -0700[diff] [blame]5163 (my_data->fluence_in_voice_call == false &&
5164 my_data->fluence_in_hfp_call == false)) {
Ramu Gottipati97a89a42018-12-03 16:41:09 +0530[diff] [blame]5165 if (out_device & AUDIO_DEVICE_OUT_LINE &&
5166 audio_extn_hfp_is_active(adev)) {
5167 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
5168 } else {
5169 snd_device = SND_DEVICE_IN_HANDSET_MIC;
5170 }
5171 if (audio_extn_hfp_is_active(adev))
5172 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5173 } else {
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]5174 if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5175 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5176 snd_device = SND_DEVICE_IN_HANDSET_TMIC;
5177 adev->acdb_settings |= TMIC_FLAG;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5178 } else if (is_operator_tmus())
5179 snd_device = SND_DEVICE_IN_VOICE_DMIC_TMUS;
5180 else { /* for FLUENCE_DUAL_MIC and SOURCE_DUAL_MIC */
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]5181 snd_device = SND_DEVICE_IN_VOICE_DMIC;
5182 adev->acdb_settings |= DMIC_FLAG;
5183 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5184 }
5185 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
5186 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]5187 if (audio_extn_hfp_is_active(adev))
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]5188 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5189 } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]5190 if (adev->bt_wb_speech_enabled) {
5191 if (adev->bluetooth_nrec)
5192 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
5193 else
5194 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
5195 } else {
5196 if (adev->bluetooth_nrec)
5197 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
5198 else
5199 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
5200 }
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]5201 } else if ((out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
5202 adev->dp_allowed_for_voice) {
5203 if (audio_extn_usb_is_capture_supported())
5204 snd_device = SND_DEVICE_IN_VOICE_USB_HEADSET_MIC;
5205 else
5206 snd_device = SND_DEVICE_IN_HANDSET_MIC;
5207
5208 if (voice_is_in_call(adev))
5209 platform_set_echo_reference(adev, true, out_device);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5210 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER ||
5211 out_device & AUDIO_DEVICE_OUT_SPEAKER_SAFE ||
5212 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
5213 out_device & AUDIO_DEVICE_OUT_LINE) {
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]5214 if (my_data->fluence_type != FLUENCE_NONE &&
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]5215 (my_data->fluence_in_voice_call ||
5216 my_data->fluence_in_hfp_call) &&
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]5217 my_data->fluence_in_spkr_mode) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5218 if((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5219 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]5220 adev->acdb_settings |= QMIC_FLAG;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]5221 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC;
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]5222 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5223 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5224 adev->acdb_settings |= TMIC_FLAG;
5225 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_TMIC;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]5226 } else {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]5227 adev->acdb_settings |= DMIC_FLAG;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]5228 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
5229 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE;
5230 else
5231 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]5232 }
Dhanalakshmi Siddani1eb3a352017-06-05 15:18:23 +0530[diff] [blame]5233 if (audio_extn_hfp_is_active(adev))
5234 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5235 } else {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5236 if (adev->enable_hfp) {
5237 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]5238 platform_set_echo_reference(adev, true, out_device);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5239 } else {
5240 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
5241 if (audio_extn_hfp_is_active(adev))
5242 platform_set_echo_reference(adev, true, out_device);
5243 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5244 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]5245 } else if (out_device & AUDIO_DEVICE_OUT_TELEPHONY_TX) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]5246 snd_device = SND_DEVICE_IN_VOICE_RX;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]5247 } else if (out_device &
5248 (AUDIO_DEVICE_OUT_USB_DEVICE |
5249 AUDIO_DEVICE_OUT_USB_HEADSET)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5250 if (audio_extn_usb_is_capture_supported()) {
5251 snd_device = SND_DEVICE_IN_VOICE_USB_HEADSET_MIC;
5252 } else if (my_data->fluence_in_voice_call && my_data->fluence_in_spkr_mode) {
5253 if (my_data->source_mic_type & SOURCE_DUAL_MIC) {
5254 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC;
5255 } else {
5256 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
5257 }
5258 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]5259 }
Dhananjay Kumar704ce6f2017-09-28 22:08:00 +0530[diff] [blame]5260 } else if (my_data->use_generic_handset == true && // system prop is enabled
5261 (my_data->source_mic_type & SOURCE_QUAD_MIC) && // AND 4mic is available
5262 ((in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) || // AND device is buit-in mic or back mic
5263 (in_device & AUDIO_DEVICE_IN_BACK_MIC)) &&
5264 (my_data->fluence_in_audio_rec == true && // AND fluencepro is enabled
5265 my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5266 (source == AUDIO_SOURCE_CAMCORDER || // AND source is cam/mic/unprocessed
5267 source == AUDIO_SOURCE_UNPROCESSED ||
5268 source == AUDIO_SOURCE_MIC)) {
5269 snd_device = SND_DEVICE_IN_HANDSET_GENERIC_QMIC;
5270 platform_set_echo_reference(adev, true, out_device);
Sachin Mohan Gadage6aa1952018-03-05 17:50:02 +0530[diff] [blame]5271 } else if (my_data->use_generic_handset == true && // System prop is enabled
5272 (my_data->ambisonic_capture == true) && // Enable Ambisonic capture
Sachin Mohan Gadagbe2054d2018-01-29 16:05:05 +0530[diff] [blame]5273 (my_data->source_mic_type & SOURCE_QUAD_MIC) && // AND 4mic is available
Sachin Mohan Gadage6aa1952018-03-05 17:50:02 +0530[diff] [blame]5274 ((in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) || // AND device is Built-in
5275 (in_device & AUDIO_DEVICE_IN_BACK_MIC)) && // OR Back-mic
5276 (source == AUDIO_SOURCE_MIC || // AND source is MIC for 16bit
5277 source == AUDIO_SOURCE_UNPROCESSED || // OR unprocessed for 24bit
5278 source == AUDIO_SOURCE_CAMCORDER)) { // OR camera usecase
Sachin Mohan Gadagbe2054d2018-01-29 16:05:05 +0530[diff] [blame]5279 snd_device = SND_DEVICE_IN_HANDSET_GENERIC_QMIC;
5280 /* Below check is true only in LA build to set
5281 ambisonic profile. In LE hal client will set profile
5282 */
5283 if (my_data->ambisonic_profile == true) {
5284 strlcpy(adev->active_input->profile, "record_ambisonic",
5285 sizeof(adev->active_input->profile));
5286 }
Sachin Mohan Gadage6aa1952018-03-05 17:50:02 +0530[diff] [blame]5287
5288 if (!strncmp(adev->active_input->profile, "record_ambisonic",
5289 strlen("record_ambisonic"))) {
5290 /* Validate input stream configuration for
5291 Ambisonic capture.
5292 */
5293 if (((int)channel_mask != (int)AUDIO_CHANNEL_INDEX_MASK_4) ||
5294 (adev->active_input->sample_rate != 48000)) {
5295 snd_device = SND_DEVICE_NONE;
5296 ALOGW("Unsupported Input configuration for ambisonic capture");
5297 goto exit;
5298 }
5299 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5300 } else if (source == AUDIO_SOURCE_CAMCORDER) {
5301 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
5302 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]5303
5304 if (str_bitwidth == 16) {
5305 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
5306 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5307 (channel_count == 2))
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5308 snd_device = SND_DEVICE_IN_HANDSET_DMIC_STEREO;
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]5309 else
5310 snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
5311 }
5312 /*
5313 * for other bit widths
5314 */
5315 else {
5316 if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
5317 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
5318 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
5319 snd_device = SND_DEVICE_IN_UNPROCESSED_STEREO_MIC;
5320 }
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5321 else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]5322 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5323 snd_device = SND_DEVICE_IN_UNPROCESSED_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5324 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]5325 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
5326 snd_device = SND_DEVICE_IN_UNPROCESSED_QUAD_MIC;
5327 } else {
5328 snd_device = SND_DEVICE_IN_UNPROCESSED_MIC;
5329 }
5330 }
5331 }
5332 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5333 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5334 if (my_data->fluence_in_voice_rec && channel_count == 1) {
5335 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5336 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5337 if (adev->active_input->enable_aec)
5338 snd_device = SND_DEVICE_IN_HANDSET_QMIC_AEC;
5339 else
5340 snd_device = SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5341 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5342 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5343 if (adev->active_input->enable_aec)
5344 snd_device = SND_DEVICE_IN_HANDSET_TMIC_AEC;
5345 else
5346 snd_device = SND_DEVICE_IN_VOICE_REC_TMIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5347 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
5348 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5349 if (adev->active_input->enable_aec)
5350 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
5351 else
5352 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
Vidyakumar Athota78b70c02015-06-29 17:19:45 -0700[diff] [blame]5353 }
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5354 platform_set_echo_reference(adev, true, out_device);
5355 } else if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
5356 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
5357 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
5358 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5359 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5360 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5361 snd_device = SND_DEVICE_IN_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5362 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5363 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
5364 snd_device = SND_DEVICE_IN_QUAD_MIC;
5365 }
5366 if (snd_device == SND_DEVICE_NONE) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5367 if (adev->active_input->enable_aec) {
5368 if (adev->active_input->enable_ns) {
5369 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS;
5370 } else {
5371 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_AEC;
5372 }
5373 platform_set_echo_reference(adev, true, out_device);
5374 } else if (adev->active_input->enable_ns)
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5375 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
5376 else
5377 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]5378 }
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5379 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
5380 snd_device = SND_DEVICE_IN_VOICE_REC_HEADSET_MIC;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]5381 } else if (audio_is_usb_in_device(in_device | AUDIO_DEVICE_BIT_IN)) {
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]5382 snd_device = fixup_usb_headset_mic_snd_device(platform,
5383 SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC,
5384 SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MULTI_CHANNEL_MIC);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5385 }
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]5386 } else if (source == AUDIO_SOURCE_UNPROCESSED) {
5387 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
5388 if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
5389 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
5390 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
5391 snd_device = SND_DEVICE_IN_UNPROCESSED_STEREO_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5392 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]5393 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
5394 snd_device = SND_DEVICE_IN_UNPROCESSED_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]5395 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]5396 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
5397 snd_device = SND_DEVICE_IN_UNPROCESSED_QUAD_MIC;
5398 } else {
5399 snd_device = SND_DEVICE_IN_UNPROCESSED_MIC;
5400 }
5401 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]5402 snd_device = SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]5403 } else if (audio_is_usb_in_device(in_device | AUDIO_DEVICE_BIT_IN)) {
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]5404 snd_device = fixup_usb_headset_mic_snd_device(platform,
5405 SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC,
5406 SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MULTI_CHANNEL_MIC);
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]5407 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]5408 } else if ((source == AUDIO_SOURCE_VOICE_COMMUNICATION) ||
5409 (mode == AUDIO_MODE_IN_COMMUNICATION)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5410 if (out_device & (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE) ||
5411 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
5412 (out_device & (AUDIO_DEVICE_OUT_USB_DEVICE | AUDIO_DEVICE_OUT_USB_HEADSET) &&
5413 !audio_extn_usb_is_capture_supported()))
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5414 in_device = AUDIO_DEVICE_IN_BACK_MIC;
kunleizdcf967a2018-08-07 17:09:11 +0800[diff] [blame]5415 else if (out_device & AUDIO_DEVICE_OUT_EARPIECE)
5416 in_device = AUDIO_DEVICE_IN_BUILTIN_MIC;
5417 else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET)
5418 in_device = AUDIO_DEVICE_IN_WIRED_HEADSET;
5419 else if (out_device & AUDIO_DEVICE_OUT_USB_DEVICE)
5420 in_device = AUDIO_DEVICE_IN_USB_DEVICE;
5421
5422 in_device = ((out_device == AUDIO_DEVICE_NONE) ?
5423 AUDIO_DEVICE_IN_BUILTIN_MIC : in_device) & ~AUDIO_DEVICE_BIT_IN;
5424
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5425 if (adev->active_input) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]5426 snd_device = get_snd_device_for_voice_comm(my_data, out_device, in_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5427 }
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]5428 } else if (source == AUDIO_SOURCE_MIC) {
Apoorv Raghuvanshic0536542013-11-14 16:25:59 -0800[diff] [blame]5429 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC &&
5430 channel_count == 1 ) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]5431 if(my_data->fluence_in_audio_rec) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5432 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5433 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]5434 snd_device = SND_DEVICE_IN_HANDSET_QMIC;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]5435 platform_set_echo_reference(adev, true, out_device);
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5436 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
5437 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
Aditya Bavanari4051c8d2017-12-13 13:31:26 +0530[diff] [blame]5438 snd_device = SND_DEVICE_IN_HANDSET_TMIC_FLUENCE_PRO;
5439 } else if ((my_data->fluence_type & FLUENCE_TRI_MIC) &&
5440 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5441 snd_device = SND_DEVICE_IN_HANDSET_TMIC;
5442 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
5443 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]5444 snd_device = SND_DEVICE_IN_HANDSET_DMIC;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]5445 platform_set_echo_reference(adev, true, out_device);
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]5446 }
Ravi Kumar Alamanda7076b162014-03-07 11:40:24 -0800[diff] [blame]5447 }
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]5448 }
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]5449 } else if (source == AUDIO_SOURCE_FM_TUNER) {
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]5450 snd_device = SND_DEVICE_IN_CAPTURE_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5451 } else if (source == AUDIO_SOURCE_DEFAULT) {
5452 goto exit;
5453 }
5454
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -0700[diff] [blame]5455 if (adev->active_input && (audio_extn_ssr_get_stream() == adev->active_input))
5456 snd_device = SND_DEVICE_IN_THREE_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5457
5458 if (snd_device != SND_DEVICE_NONE) {
5459 goto exit;
5460 }
5461
5462 if (in_device != AUDIO_DEVICE_NONE &&
5463 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
5464 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
5465 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5466 if ((adev->active_input && (audio_extn_ssr_get_stream() == adev->active_input)) ||
5467 ((my_data->source_mic_type & SOURCE_QUAD_MIC) &&
5468 channel_mask == AUDIO_CHANNEL_INDEX_MASK_4))
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]5469 snd_device = SND_DEVICE_IN_QUAD_MIC;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5470 else if ((my_data->source_mic_type & SOURCE_THREE_MIC) &&
5471 channel_mask == AUDIO_CHANNEL_INDEX_MASK_3)
5472 snd_device = SND_DEVICE_IN_THREE_MIC;
Vikram Pandurangaf0ca0b12018-05-04 16:00:07 -0700[diff] [blame]5473 else if ((my_data->fluence_type & (FLUENCE_DUAL_MIC | FLUENCE_TRI_MIC | FLUENCE_QUAD_MIC)) &&
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5474 (channel_count == 2) && (my_data->source_mic_type & SOURCE_DUAL_MIC))
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5475 snd_device = SND_DEVICE_IN_HANDSET_DMIC_STEREO;
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]5476 else
5477 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5478 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5479 if ((my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5480 channel_count == 2)
5481 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_STEREO;
5482 else
5483 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
Ramu Gottipati813ae982018-07-25 14:14:48 +0530[diff] [blame]5484 } else if (in_device & AUDIO_DEVICE_IN_LINE) {
5485 snd_device = SND_DEVICE_IN_LINE;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5486 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
5487 snd_device = SND_DEVICE_IN_HEADSET_MIC;
5488 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]5489 if (adev->bt_wb_speech_enabled) {
5490 if (adev->bluetooth_nrec)
5491 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
5492 else
5493 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
5494 } else {
5495 if (adev->bluetooth_nrec)
5496 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
5497 else
5498 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
5499 }
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]5500 } else if (in_device & AUDIO_DEVICE_IN_SPDIF) {
5501 snd_device = SND_DEVICE_IN_SPDIF;
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]5502 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
5503 snd_device = SND_DEVICE_IN_BT_A2DP;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5504 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
5505 snd_device = SND_DEVICE_IN_HDMI_MIC;
Ralf Herz76b455c2018-09-10 13:58:04 +0200[diff] [blame]5506 } else if (in_device & AUDIO_DEVICE_IN_HDMI_ARC) {
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]5507 snd_device = SND_DEVICE_IN_HDMI_ARC;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]5508 } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
5509 in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
5510 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]5511 } else if (in_device & AUDIO_DEVICE_IN_FM_TUNER) {
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]5512 snd_device = SND_DEVICE_IN_CAPTURE_FM;
kunleiz1a1d26c2018-06-14 18:48:16 +0800[diff] [blame]5513 } else if (audio_extn_usb_connected(NULL) && audio_is_usb_in_device(in_device | AUDIO_DEVICE_BIT_IN)) {
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]5514 snd_device = fixup_usb_headset_mic_snd_device(platform,
5515 SND_DEVICE_IN_USB_HEADSET_MIC,
5516 SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5517 } else {
5518 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
5519 ALOGW("%s: Using default handset-mic", __func__);
5520 snd_device = SND_DEVICE_IN_HANDSET_MIC;
5521 }
5522 } else {
5523 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
5524 snd_device = SND_DEVICE_IN_HANDSET_MIC;
5525 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
5526 snd_device = SND_DEVICE_IN_HEADSET_MIC;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5527 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER ||
5528 out_device & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5529 if ((my_data->source_mic_type & SOURCE_DUAL_MIC) &&
5530 (channel_count == 2)) {
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5531 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_STEREO;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5532 } else if ((my_data->source_mic_type & SOURCE_MONO_MIC) &&
5533 (channel_count == 1)) {
5534 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
5535 } else {
5536 ALOGE("%s: something wrong: source type (%d) channel_count (%d) .."
5537 " no combination found .. setting to mono", __func__,
5538 my_data->source_mic_type, channel_count);
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]5539 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]5540 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]5541 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
5542 out_device & AUDIO_DEVICE_OUT_LINE) {
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]5543 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5544 } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]5545 if (adev->bt_wb_speech_enabled) {
5546 if (adev->bluetooth_nrec)
5547 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
5548 else
5549 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
5550 } else {
5551 if (adev->bluetooth_nrec)
5552 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
5553 else
5554 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
5555 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5556 } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
5557 snd_device = SND_DEVICE_IN_HDMI_MIC;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]5558 } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
5559 out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
5560 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +0530[diff] [blame]5561 } else if (out_device &
5562 (AUDIO_DEVICE_OUT_USB_DEVICE |
5563 AUDIO_DEVICE_OUT_USB_HEADSET)) {
kunleiz1a1d26c2018-06-14 18:48:16 +0800[diff] [blame]5564 if (audio_extn_usb_is_capture_supported() && audio_extn_usb_connected(NULL))
Karthikeyan Mani07faa602018-08-20 11:01:32 -0700[diff] [blame]5565 snd_device = fixup_usb_headset_mic_snd_device(platform,
5566 SND_DEVICE_IN_USB_HEADSET_MIC,
5567 SND_DEVICE_IN_USB_HEADSET_MULTI_CHANNEL_MIC);
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]5568 else
5569 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]5570
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5571 } else {
5572 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
5573 ALOGW("%s: Using default handset-mic", __func__);
5574 snd_device = SND_DEVICE_IN_HANDSET_MIC;
5575 }
5576 }
5577exit:
5578 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
5579 return snd_device;
5580}
5581
5582int platform_set_hdmi_channels(void *platform, int channel_count)
5583{
5584 struct platform_data *my_data = (struct platform_data *)platform;
5585 struct audio_device *adev = my_data->adev;
5586 struct mixer_ctl *ctl;
5587 const char *channel_cnt_str = NULL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5588 char *mixer_ctl_name;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5589 switch (channel_count) {
5590 case 8:
5591 channel_cnt_str = "Eight"; break;
5592 case 7:
5593 channel_cnt_str = "Seven"; break;
5594 case 6:
5595 channel_cnt_str = "Six"; break;
5596 case 5:
5597 channel_cnt_str = "Five"; break;
5598 case 4:
5599 channel_cnt_str = "Four"; break;
5600 case 3:
5601 channel_cnt_str = "Three"; break;
5602 default:
5603 channel_cnt_str = "Two"; break;
5604 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5605
5606 switch(my_data->ext_disp_type) {
5607 case EXT_DISPLAY_TYPE_HDMI:
5608 mixer_ctl_name = "HDMI_RX Channels";
5609 break;
5610 case EXT_DISPLAY_TYPE_DP:
5611 mixer_ctl_name = "Display Port RX Channels";
5612 break;
5613 default:
5614 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
5615 return -EINVAL;
5616 }
5617
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5618 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5619 if (!ctl) {
5620 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5621 __func__, mixer_ctl_name);
5622 return -EINVAL;
5623 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5624 ALOGV("Ext disp channel count: %s", channel_cnt_str);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5625 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
5626 return 0;
5627}
5628
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]5629int platform_edid_get_max_channels(void *platform)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5630{
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]5631 int channel_count;
5632 int max_channels = 2;
5633 int i = 0, ret = 0;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]5634 struct platform_data *my_data = (struct platform_data *)platform;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]5635 edid_audio_info *info = NULL;
5636 ret = platform_get_edid_info(platform);
5637 info = (edid_audio_info *)my_data->edid_info;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5638
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]5639 if(ret == 0 && info != NULL) {
5640 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
5641 ALOGV("%s:format %d channel %d", __func__,
5642 info->audio_blocks_array[i].format_id,
5643 info->audio_blocks_array[i].channels);
5644 if (info->audio_blocks_array[i].format_id == LPCM) {
5645 channel_count = info->audio_blocks_array[i].channels;
5646 if (channel_count > max_channels) {
5647 max_channels = channel_count;
5648 }
5649 }
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]5650 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5651 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]5652 return max_channels;
5653}
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5654
5655static int platform_set_slowtalk(struct platform_data *my_data, bool state)
5656{
5657 int ret = 0;
5658 struct audio_device *adev = my_data->adev;
5659 struct mixer_ctl *ctl;
5660 const char *mixer_ctl_name = "Slowtalk Enable";
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]5661 long set_values[ ] = {0,
5662 ALL_SESSION_VSID};
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5663
5664 set_values[0] = state;
5665 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5666 if (!ctl) {
5667 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5668 __func__, mixer_ctl_name);
5669 ret = -EINVAL;
5670 } else {
5671 ALOGV("Setting slowtalk state: %d", state);
5672 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
5673 my_data->slowtalk = state;
5674 }
5675
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]5676 if (my_data->csd != NULL) {
5677 ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state);
5678 if (ret < 0) {
5679 ALOGE("%s: csd_client_disable_device, failed, error %d",
5680 __func__, ret);
5681 }
5682 }
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5683 return ret;
5684}
5685
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]5686static int set_hd_voice(struct platform_data *my_data, bool state)
5687{
5688 struct audio_device *adev = my_data->adev;
5689 struct mixer_ctl *ctl;
5690 char *mixer_ctl_name = "HD Voice Enable";
5691 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]5692 long set_values[ ] = {0,
5693 ALL_SESSION_VSID};
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]5694
5695 set_values[0] = state;
5696 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5697 if (!ctl) {
5698 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5699 __func__, mixer_ctl_name);
5700 return -EINVAL;
5701 } else {
5702 ALOGV("Setting HD Voice state: %d", state);
5703 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
5704 my_data->hd_voice = state;
5705 }
5706
5707 return ret;
5708}
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]5709
5710static int update_external_device_status(struct platform_data *my_data,
5711 char* event_name, bool status)
5712{
5713 int ret = 0;
5714 struct audio_usecase *usecase;
5715 struct listnode *node;
5716
5717 ALOGD("Recieved external event switch %s", event_name);
5718
5719 if (!strcmp(event_name, EVENT_EXTERNAL_SPK_1))
5720 my_data->external_spk_1 = status;
5721 else if (!strcmp(event_name, EVENT_EXTERNAL_SPK_2))
5722 my_data->external_spk_2 = status;
5723 else if (!strcmp(event_name, EVENT_EXTERNAL_MIC))
5724 my_data->external_mic = status;
5725 else {
5726 ALOGE("The audio event type is not found");
5727 return -EINVAL;
5728 }
5729
5730 list_for_each(node, &my_data->adev->usecase_list) {
5731 usecase = node_to_item(node, struct audio_usecase, list);
5732 select_devices(my_data->adev, usecase->id);
5733 }
5734
5735 return ret;
5736}
5737
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5738static int parse_audiocal_cfg(struct str_parms *parms, acdb_audio_cal_cfg_t *cal)
5739{
5740 int err;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5741 char value[64];
5742 int ret = 0;
5743
5744 if(parms == NULL || cal == NULL)
5745 return ret;
5746
5747 err = str_parms_get_str(parms, "cal_persist", value, sizeof(value));
5748 if (err >= 0) {
5749 str_parms_del(parms, "cal_persist");
5750 cal->persist = (uint32_t) strtoul(value, NULL, 0);
5751 ret = ret | 0x1;
5752 }
5753 err = str_parms_get_str(parms, "cal_apptype", value, sizeof(value));
5754 if (err >= 0) {
5755 str_parms_del(parms, "cal_apptype");
5756 cal->app_type = (uint32_t) strtoul(value, NULL, 0);
5757 ret = ret | 0x2;
5758 }
5759 err = str_parms_get_str(parms, "cal_caltype", value, sizeof(value));
5760 if (err >= 0) {
5761 str_parms_del(parms, "cal_caltype");
5762 cal->cal_type = (uint32_t) strtoul(value, NULL, 0);
5763 ret = ret | 0x4;
5764 }
5765 err = str_parms_get_str(parms, "cal_samplerate", value, sizeof(value));
5766 if (err >= 0) {
5767 str_parms_del(parms, "cal_samplerate");
5768 cal->sampling_rate = (uint32_t) strtoul(value, NULL, 0);
5769 ret = ret | 0x8;
5770 }
5771 err = str_parms_get_str(parms, "cal_devid", value, sizeof(value));
5772 if (err >= 0) {
5773 str_parms_del(parms, "cal_devid");
5774 cal->dev_id = (uint32_t) strtoul(value, NULL, 0);
5775 ret = ret | 0x10;
5776 }
5777 err = str_parms_get_str(parms, "cal_snddevid", value, sizeof(value));
5778 if (err >= 0) {
5779 str_parms_del(parms, "cal_snddevid");
5780 cal->snd_dev_id = (uint32_t) strtoul(value, NULL, 0);
5781 ret = ret | 0x20;
5782 }
5783 err = str_parms_get_str(parms, "cal_topoid", value, sizeof(value));
5784 if (err >= 0) {
5785 str_parms_del(parms, "cal_topoid");
5786 cal->topo_id = (uint32_t) strtoul(value, NULL, 0);
5787 ret = ret | 0x40;
5788 }
5789 err = str_parms_get_str(parms, "cal_moduleid", value, sizeof(value));
5790 if (err >= 0) {
5791 str_parms_del(parms, "cal_moduleid");
5792 cal->module_id = (uint32_t) strtoul(value, NULL, 0);
5793 ret = ret | 0x80;
5794 }
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]5795#ifdef INSTANCE_ID_ENABLED
5796 err = str_parms_get_str(parms, "cal_instanceid", value, sizeof(value));
5797 if (err >= 0) {
5798 str_parms_del(parms, "cal_instanceid");
5799 cal->instance_id = (uint32_t) strtoul(value, NULL, 0);
5800 ret = ret | 0x100;
5801 }
5802#endif
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5803 err = str_parms_get_str(parms, "cal_paramid", value, sizeof(value));
5804 if (err >= 0) {
5805 str_parms_del(parms, "cal_paramid");
5806 cal->param_id = (uint32_t) strtoul(value, NULL, 0);
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]5807 ret = ret | 0x200;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5808 }
5809 return ret;
5810}
5811
5812static void set_audiocal(void *platform, struct str_parms *parms, char *value, int len) {
5813 struct platform_data *my_data = (struct platform_data *)platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5814 struct stream_out out;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]5815 acdb_audio_cal_cfg_t cal;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5816 uint8_t *dptr = NULL;
5817 int32_t dlen;
5818 int err, ret;
5819 if(value == NULL || platform == NULL || parms == NULL) {
5820 ALOGE("[%s] received null pointer, failed",__func__);
5821 goto done_key_audcal;
5822 }
5823
Aditya Bavanarie293d5b2017-11-15 12:48:36 +0530[diff] [blame]5824 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5825 /* parse audio calibration keys */
5826 ret = parse_audiocal_cfg(parms, &cal);
5827
5828 /* handle audio calibration data now */
5829 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_AUD_CALDATA, value, len);
5830 if (err >= 0) {
5831 str_parms_del(parms, AUDIO_PARAMETER_KEY_AUD_CALDATA);
5832 dlen = strlen(value);
5833 if(dlen <= 0) {
5834 ALOGE("[%s] null data received",__func__);
5835 goto done_key_audcal;
5836 }
5837 dptr = (uint8_t*) calloc(dlen, sizeof(uint8_t));
5838 if(dptr == NULL) {
5839 ALOGE("[%s] memory allocation failed for %d",__func__, dlen);
5840 goto done_key_audcal;
5841 }
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]5842 dlen = b64_pton(value, dptr, dlen);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5843 if(dlen<=0) {
5844 ALOGE("[%s] data decoding failed %d", __func__, dlen);
5845 goto done_key_audcal;
5846 }
5847
5848 if(cal.dev_id) {
5849 if(audio_is_input_device(cal.dev_id)) {
5850 cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);
5851 } else {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5852 out.devices = cal.dev_id;
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]5853 out.sample_rate = cal.sampling_rate;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5854 cal.snd_dev_id = platform_get_output_snd_device(platform, &out);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5855 }
5856 }
5857 cal.acdb_dev_id = platform_get_snd_device_acdb_id(cal.snd_dev_id);
5858 ALOGD("Setting audio calibration for snd_device(%d) acdb_id(%d)",
5859 cal.snd_dev_id, cal.acdb_dev_id);
5860 if(cal.acdb_dev_id == -EINVAL) {
5861 ALOGE("[%s] Invalid acdb_device id %d for snd device id %d",
5862 __func__, cal.acdb_dev_id, cal.snd_dev_id);
5863 goto done_key_audcal;
5864 }
5865 if(my_data->acdb_set_audio_cal) {
5866 ret = my_data->acdb_set_audio_cal((void *)&cal, (void*)dptr, dlen);
5867 }
5868 }
5869done_key_audcal:
5870 if(dptr != NULL)
5871 free(dptr);
5872}
5873
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]5874static void true_32_bit_set_params(struct str_parms *parms,
5875 char *value, int len)
5876{
5877 int ret = 0;
5878
5879 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TRUE_32_BIT,
5880 value,len);
5881 if (ret >= 0) {
5882 if (value && !strncmp(value, "true", sizeof("src")))
5883 supports_true_32_bit = true;
5884 else
5885 supports_true_32_bit = false;
5886 str_parms_del(parms, AUDIO_PARAMETER_KEY_TRUE_32_BIT);
5887 }
5888
5889}
5890
5891bool platform_supports_true_32bit()
5892{
5893 return supports_true_32_bit;
5894}
5895
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]5896static void perf_lock_set_params(struct platform_data *platform,
5897 struct str_parms *parms,
5898 char *value, int len)
5899{
5900 int err = 0, i = 0, num_opts = 0;
5901 char *test_r = NULL;
5902 char *opts = NULL;
5903 char *opts_size = NULL;
5904
5905 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS,
5906 value, len);
5907 if (err >= 0) {
5908 opts_size = strtok_r(value, ", ", &test_r);
5909 if (opts_size == NULL) {
5910 ALOGE("%s: incorrect perf lock opts\n", __func__);
5911 return;
5912 }
5913 num_opts = atoi(opts_size);
5914 if (num_opts > 0) {
5915 if (num_opts > MAX_PERF_LOCK_OPTS) {
5916 ALOGD("%s: num_opts %d exceeds max %d, setting to max\n",
5917 __func__, num_opts, MAX_PERF_LOCK_OPTS);
5918 num_opts = MAX_PERF_LOCK_OPTS;
5919 }
5920 for (i = 0; i < num_opts; i++) {
5921 opts = strtok_r(NULL, ", ", &test_r);
5922 if (opts == NULL) {
5923 ALOGE("%s: incorrect perf lock opts\n", __func__);
5924 break;
5925 }
5926 platform->adev->perf_lock_opts[i] = strtoul(opts, NULL, 16);
5927 }
5928 platform->adev->perf_lock_opts_size = i;
5929 }
5930 str_parms_del(parms, AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS);
5931 }
5932}
5933
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]5934static void platform_spkr_device_set_params(struct platform_data *platform,
5935 struct str_parms *parms,
5936 char *value, int len)
5937{
5938 int err = 0, i = 0, num_ch = 0;
5939 char *test_r = NULL;
5940 char *opts = NULL;
5941 char *ch_count = NULL;
5942
5943 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP,
5944 value, len);
5945 if (err >= 0) {
5946 platform->spkr_ch_map = calloc(1, sizeof(struct spkr_device_chmap));
5947 if (!platform->spkr_ch_map) {
5948 ALOGE("%s: failed to allocate mem for adm channel map\n", __func__);
5949 str_parms_del(parms, AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP);
5950 return ;
5951 }
5952
5953 ch_count = strtok_r(value, ", ", &test_r);
5954 if (ch_count == NULL) {
5955 ALOGE("%s: incorrect ch_map\n", __func__);
5956 free(platform->spkr_ch_map);
5957 platform->spkr_ch_map = NULL;
5958 str_parms_del(parms, AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP);
5959 return;
5960 }
5961
5962 num_ch = atoi(ch_count);
5963 if ((num_ch > 0) && (num_ch <= AUDIO_CHANNEL_COUNT_MAX) ) {
5964 platform->spkr_ch_map->num_ch = num_ch;
5965 for (i = 0; i < num_ch; i++) {
5966 opts = strtok_r(NULL, ", ", &test_r);
Jhansi Konathalad72b20e2018-10-16 13:35:14 +0530[diff] [blame]5967 if (opts == NULL) {
5968 ALOGE("%s: incorrect ch_map\n", __func__);
5969 free(platform->spkr_ch_map);
5970 platform->spkr_ch_map = NULL;
5971 str_parms_del(parms, AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP);
5972 return;
5973 } else {
5974 platform->spkr_ch_map->chmap[i] = strtoul(opts, NULL, 16);
5975 }
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]5976 }
5977 }
5978 str_parms_del(parms, AUDIO_PARAMETER_KEY_SPKR_DEVICE_CHMAP);
5979 }
5980}
5981
Jhansi Konathala170875c2018-10-11 18:34:10 +0530[diff] [blame]5982static void platform_set_fluence_params(void *platform, struct str_parms *parms, char *value, int len)
5983{
5984 struct platform_data *my_data = (struct platform_data *)platform;
5985 int err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_TYPE, value, len);
5986
5987 if (err >= 0) {
5988 if (!strncmp("fluence", value, sizeof("fluence")))
5989 my_data->fluence_type = FLUENCE_DUAL_MIC;
5990 else if (!strncmp("fluencepro", value, sizeof("fluencepro")))
5991 my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
5992 else if (!strncmp("none", value, sizeof("none")))
5993 my_data->fluence_type = FLUENCE_NONE;
5994
5995 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_TYPE);
5996 }
5997
5998 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_TRI_MIC, value, len);
5999 if (err >= 0) {
6000 if (!strncmp("true", value, sizeof("true")))
6001 my_data->fluence_type |= FLUENCE_TRI_MIC;
6002
6003 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_TRI_MIC);
6004 }
6005
6006 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_VOICE_CALL, value, len);
6007 if (err >= 0) {
6008 if (!strncmp("true", value, sizeof("true")))
6009 my_data->fluence_in_voice_call = true;
6010 else
6011 my_data->fluence_in_voice_call = false;
6012
6013 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_VOICE_CALL);
6014 }
6015
6016 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_VOICE_REC, value, len);
6017 if (err >= 0) {
6018 if (!strncmp("true", value, sizeof("true")))
6019 my_data->fluence_in_voice_rec = true;
6020 else
6021 my_data->fluence_in_voice_rec = false;
6022
6023 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_VOICE_REC);
6024 }
6025
6026 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_AUDIO_REC, value, len);
6027 if (err >= 0) {
6028 if (!strncmp("true", value, sizeof("true")))
6029 my_data->fluence_in_audio_rec = true;
6030 else
6031 my_data->fluence_in_audio_rec = false;
6032
6033 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_AUDIO_REC);
6034 }
6035
6036 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_SPEAKER, value, len);
6037 if (err >= 0) {
6038 if (!strncmp("true", value, sizeof("true")))
6039 my_data->fluence_in_spkr_mode = true;
6040 else
6041 my_data->fluence_in_spkr_mode = false;
6042
6043 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_SPEAKER);
6044 }
6045
6046 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_MODE, value, len);
6047 if (err >= 0) {
6048 if (!strncmp("broadside", value, sizeof("broadside")))
6049 my_data->fluence_mode = FLUENCE_BROADSIDE;
6050 else if (!strncmp("endfire", value, sizeof("endfire")))
6051 my_data->fluence_mode = FLUENCE_ENDFIRE;
6052
6053 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_MODE);
6054 }
6055
6056 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_FLUENCE_HFPCALL, value, len);
6057 if (err >= 0) {
6058 if (!strncmp("true", value, sizeof("true")))
6059 my_data->fluence_in_hfp_call = true;
6060 else
6061 my_data->fluence_in_hfp_call = false;
6062
6063 str_parms_del(parms, AUDIO_PARAMETER_KEY_FLUENCE_HFPCALL);
6064 }
6065}
6066
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6067int platform_set_parameters(void *platform, struct str_parms *parms)
6068{
6069 struct platform_data *my_data = (struct platform_data *)platform;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6070 char *value=NULL;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]6071 int len;
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]6072 int ret = 0, err;
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]6073 char *kv_pairs = str_parms_to_str(parms);
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]6074 struct listnode *node;
6075 struct meta_key_list *key_info;
6076 int key = 0;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6077
Mingming Yin7b762e72015-03-04 13:47:32 -0800[diff] [blame]6078 if(kv_pairs == NULL) {
6079 ret = -ENOMEM;
6080 ALOGE("[%s] key-value pair is NULL",__func__);
6081 goto done;
6082 }
6083
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]6084 ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6085
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6086 len = strlen(kv_pairs);
6087 value = (char*)calloc(len, sizeof(char));
6088 if(value == NULL) {
6089 ret = -ENOMEM;
6090 ALOGE("[%s] failed to allocate memory",__func__);
6091 goto done;
6092 }
6093 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SLOWTALK, value, len);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]6094 if (err >= 0) {
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]6095 bool state = false;
6096 if (!strncmp("true", value, sizeof("true"))) {
6097 state = true;
6098 }
6099
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6100 str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK);
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]6101 ret = platform_set_slowtalk(my_data, state);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6102 if (ret)
6103 ALOGE("%s: Failed to set slow talk err: %d", __func__, ret);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6104 }
6105
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6106 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HD_VOICE, value, len);
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]6107 if (err >= 0) {
6108 bool state = false;
6109 if (!strncmp("true", value, sizeof("true"))) {
6110 state = true;
6111 }
6112
6113 str_parms_del(parms, AUDIO_PARAMETER_KEY_HD_VOICE);
6114 if (my_data->hd_voice != state) {
6115 ret = set_hd_voice(my_data, state);
6116 if (ret)
6117 ALOGE("%s: Failed to set HD voice err: %d", __func__, ret);
6118 } else {
6119 ALOGV("%s: HD Voice already set to %d", __func__, state);
6120 }
6121 }
6122
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]6123 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6124 value, len);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]6125 if (err >= 0) {
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]6126 str_parms_del(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST);
6127
6128 if (my_data->acdb_reload_vocvoltable == NULL) {
6129 ALOGE("%s: acdb_reload_vocvoltable is NULL", __func__);
6130 } else if (!strcmp(value, "on")) {
6131 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_VOLUME_BOOST)) {
6132 my_data->voice_feature_set = 1;
6133 }
6134 } else {
6135 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_DEFAULT)) {
6136 my_data->voice_feature_set = 0;
6137 }
6138 }
6139 }
6140
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]6141 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_RELOAD_ACDB,
6142 value, len);
6143 if (err >= 0) {
6144 str_parms_del(parms, AUDIO_PARAMETER_KEY_RELOAD_ACDB);
6145
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]6146 if (my_data->acdb_reload_v2) {
6147 my_data->acdb_reload_v2(value, my_data->snd_card_name,
6148 my_data->cvd_version, &my_data->acdb_meta_key_list);
6149 } else if (my_data->acdb_reload) {
6150 node = list_head(&my_data->acdb_meta_key_list);
6151 key_info = node_to_item(node, struct meta_key_list, list);
6152 key = key_info->cal_info.nKey;
6153 my_data->acdb_reload(value, my_data->snd_card_name,
6154 my_data->cvd_version, key);
6155 }
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]6156 }
6157
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]6158 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
6159 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_MONO_SPEAKER, value, len);
6160 if (err >= 0) {
6161 if (!strncmp("left", value, sizeof("left")))
6162 my_data->mono_speaker = SPKR_1;
6163 else if (!strncmp("right", value, sizeof("right")))
6164 my_data->mono_speaker = SPKR_2;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]6165
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]6166 str_parms_del(parms, AUDIO_PARAMETER_KEY_MONO_SPEAKER);
6167 }
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]6168 }
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]6169 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE,
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6170 value, len);
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]6171 if (err >= 0) {
6172 char *event_name, *status_str;
6173 bool status = false;
6174 str_parms_del(parms, AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE);
6175 event_name = strtok_r(value, ",", &status_str);
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -0800[diff] [blame]6176 if (!event_name) {
6177 ret = -EINVAL;
6178 ALOGE("%s: event_name is NULL", __func__);
6179 goto done;
6180 }
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]6181 ALOGV("%s: recieved update of external audio device %s %s",
6182 __func__,
6183 event_name, status_str);
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]6184 if (!strncmp(status_str, "ON", sizeof("ON")))
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]6185 status = true;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]6186 else if (!strncmp(status_str, "OFF", sizeof("OFF")))
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]6187 status = false;
6188 update_external_device_status(my_data, event_name, status);
6189 }
6190
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]6191 err = str_parms_get_str(parms, PLATFORM_CONFIG_KEY_OPERATOR_INFO,
6192 value, len);
6193 if (err >= 0) {
6194 struct operator_info *info;
6195 char *str = value;
6196 char *name;
6197
6198 str_parms_del(parms, PLATFORM_CONFIG_KEY_OPERATOR_INFO);
6199 info = (struct operator_info *)calloc(1, sizeof(struct operator_info));
6200 name = strtok(str, ";");
6201 info->name = strdup(name);
6202 info->mccmnc = strdup(str + strlen(name) + 1);
6203
6204 list_add_tail(&operator_info_list, &info->list);
6205 ALOGV("%s: add operator[%s] mccmnc[%s]", __func__, info->name, info->mccmnc);
6206 }
6207
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]6208 err = str_parms_get_str(parms, PLATFORM_MAX_MIC_COUNT,
6209 value, sizeof(value));
6210 if (err >= 0) {
6211 str_parms_del(parms, PLATFORM_MAX_MIC_COUNT);
6212 my_data->max_mic_count = atoi(value);
6213 ALOGV("%s: max_mic_count %d", __func__, my_data->max_mic_count);
6214 }
6215
Jhansi Konathala170875c2018-10-11 18:34:10 +0530[diff] [blame]6216 platform_set_fluence_params(platform, parms, value, len);
6217
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6218 /* handle audio calibration parameters */
6219 set_audiocal(platform, parms, value, len);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6220 native_audio_set_params(platform, parms, value, len);
Sudheer Papothi991966d2015-07-20 21:54:36 +0530[diff] [blame]6221 audio_extn_spkr_prot_set_parameters(parms, value, len);
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]6222 audio_extn_usb_set_sidetone_gain(parms, value, len);
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]6223 audio_extn_hfp_set_parameters(my_data->adev, parms);
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]6224 perf_lock_set_params(platform, parms, value, len);
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]6225 true_32_bit_set_params(parms, value, len);
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]6226 platform_spkr_device_set_params(platform, parms, value, len);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6227done:
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6228 ALOGV("%s: exit with code(%d)", __func__, ret);
Mingming Yin7b762e72015-03-04 13:47:32 -0800[diff] [blame]6229 if(kv_pairs != NULL)
6230 free(kv_pairs);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6231 if(value != NULL)
6232 free(value);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6233 return ret;
6234}
6235
Vidyakumar Athota2850d532013-11-19 16:02:12 -0800[diff] [blame]6236int platform_set_incall_recording_session_id(void *platform,
6237 uint32_t session_id, int rec_mode)
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]6238{
6239 int ret = 0;
6240 struct platform_data *my_data = (struct platform_data *)platform;
6241 struct audio_device *adev = my_data->adev;
6242 struct mixer_ctl *ctl;
6243 const char *mixer_ctl_name = "Voc VSID";
6244 int num_ctl_values;
6245 int i;
6246
6247 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6248 if (!ctl) {
6249 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6250 __func__, mixer_ctl_name);
6251 ret = -EINVAL;
6252 } else {
6253 num_ctl_values = mixer_ctl_get_num_values(ctl);
6254 for (i = 0; i < num_ctl_values; i++) {
6255 if (mixer_ctl_set_value(ctl, i, session_id)) {
6256 ALOGV("Error: invalid session_id: %x", session_id);
6257 ret = -EINVAL;
6258 break;
6259 }
6260 }
6261 }
6262
Vidyakumar Athota2850d532013-11-19 16:02:12 -0800[diff] [blame]6263 if (my_data->csd != NULL) {
6264 ret = my_data->csd->start_record(ALL_SESSION_VSID, rec_mode);
6265 if (ret < 0) {
6266 ALOGE("%s: csd_client_start_record failed, error %d",
6267 __func__, ret);
6268 }
6269 }
6270
6271 return ret;
6272}
6273
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]6274#ifdef INCALL_STEREO_CAPTURE_ENABLED
6275int platform_set_incall_recording_session_channels(void *platform,
6276 uint32_t channel_count)
6277{
6278 int ret = 0;
6279 struct platform_data *my_data = (struct platform_data *)platform;
6280 struct audio_device *adev = my_data->adev;
6281 const char *mixer_ctl_name = "Voc Rec Config";
6282 int num_ctl_values;
6283 int i;
6284 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6285
6286 if (!ctl) {
6287 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6288 __func__, mixer_ctl_name);
6289 ret = -EINVAL;
6290 } else {
6291 num_ctl_values = mixer_ctl_get_num_values(ctl);
6292 for (i = 0; i < num_ctl_values; i++) {
6293 if (mixer_ctl_set_value(ctl, i, channel_count)) {
6294 ALOGE("Error: invalid channel count: %x", channel_count);
6295 ret = -EINVAL;
6296 break;
6297 }
6298 }
6299 }
6300
6301 return ret;
6302}
6303#endif /* INCALL_STEREO_CAPTURE_ENABLED end */
6304
Vidyakumar Athota2850d532013-11-19 16:02:12 -0800[diff] [blame]6305int platform_stop_incall_recording_usecase(void *platform)
6306{
6307 int ret = 0;
6308 struct platform_data *my_data = (struct platform_data *)platform;
6309
6310 if (my_data->csd != NULL) {
6311 ret = my_data->csd->stop_record(ALL_SESSION_VSID);
6312 if (ret < 0) {
6313 ALOGE("%s: csd_client_stop_record failed, error %d",
6314 __func__, ret);
6315 }
6316 }
6317
6318 return ret;
6319}
6320
6321int platform_start_incall_music_usecase(void *platform)
6322{
6323 int ret = 0;
6324 struct platform_data *my_data = (struct platform_data *)platform;
6325
6326 if (my_data->csd != NULL) {
6327 ret = my_data->csd->start_playback(ALL_SESSION_VSID);
6328 if (ret < 0) {
6329 ALOGE("%s: csd_client_start_playback failed, error %d",
6330 __func__, ret);
6331 }
6332 }
6333
6334 return ret;
6335}
6336
6337int platform_stop_incall_music_usecase(void *platform)
6338{
6339 int ret = 0;
6340 struct platform_data *my_data = (struct platform_data *)platform;
6341
6342 if (my_data->csd != NULL) {
6343 ret = my_data->csd->stop_playback(ALL_SESSION_VSID);
6344 if (ret < 0) {
6345 ALOGE("%s: csd_client_stop_playback failed, error %d",
6346 __func__, ret);
6347 }
6348 }
6349
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]6350 return ret;
6351}
6352
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]6353int platform_update_lch(void *platform, struct voice_session *session,
6354 enum voice_lch_mode lch_mode)
6355{
6356 int ret = 0;
6357 struct platform_data *my_data = (struct platform_data *)platform;
6358
6359 if ((my_data->csd != NULL) && (my_data->csd->set_lch != NULL))
6360 ret = my_data->csd->set_lch(session->vsid, lch_mode);
6361 else
6362 ret = pcm_ioctl(session->pcm_tx, SNDRV_VOICE_IOCTL_LCH, &lch_mode);
6363
6364 return ret;
6365}
6366
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6367static void get_audiocal(void *platform, void *keys, void *pReply) {
6368 struct platform_data *my_data = (struct platform_data *)platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6369 struct stream_out out;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6370 struct str_parms *query = (struct str_parms *)keys;
6371 struct str_parms *reply=(struct str_parms *)pReply;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]6372 acdb_audio_cal_cfg_t cal;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6373 uint8_t *dptr = NULL;
6374 char value[512] = {0};
6375 char *rparms=NULL;
6376 int ret=0, err;
6377 uint32_t param_len;
6378
6379 if(query==NULL || platform==NULL || reply==NULL) {
6380 ALOGE("[%s] received null pointer",__func__);
6381 ret=-EINVAL;
6382 goto done;
6383 }
Aditya Bavanarie293d5b2017-11-15 12:48:36 +0530[diff] [blame]6384
6385 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6386 /* parse audiocal configuration keys */
6387 ret = parse_audiocal_cfg(query, &cal);
6388 if(ret == 0) {
6389 /* No calibration keys found */
6390 goto done;
6391 }
6392 err = str_parms_get_str(query, AUDIO_PARAMETER_KEY_AUD_CALDATA, value, sizeof(value));
6393 if (err >= 0) {
6394 str_parms_del(query, AUDIO_PARAMETER_KEY_AUD_CALDATA);
6395 } else {
6396 goto done;
6397 }
6398
6399 if(cal.dev_id & AUDIO_DEVICE_BIT_IN) {
6400 cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);
6401 } else if(cal.dev_id) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]6402 out.devices = cal.dev_id;
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]6403 out.sample_rate = cal.sampling_rate;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]6404 cal.snd_dev_id = platform_get_output_snd_device(platform, &out);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6405 }
6406 cal.acdb_dev_id = platform_get_snd_device_acdb_id(cal.snd_dev_id);
6407 if (cal.acdb_dev_id < 0) {
6408 ALOGE("%s: Failed. Could not find acdb id for snd device(%d)",
6409 __func__, cal.snd_dev_id);
6410 ret = -EINVAL;
6411 goto done_key_audcal;
6412 }
6413 ALOGD("[%s] Getting audio calibration for snd_device(%d) acdb_id(%d)",
6414 __func__, cal.snd_dev_id, cal.acdb_dev_id);
6415
6416 param_len = MAX_SET_CAL_BYTE_SIZE;
6417 dptr = (uint8_t*)calloc(param_len, sizeof(uint8_t));
6418 if(dptr == NULL) {
6419 ALOGE("[%s] Memory allocation failed for length %d",__func__,param_len);
6420 ret = -ENOMEM;
6421 goto done_key_audcal;
6422 }
6423 if (my_data->acdb_get_audio_cal != NULL) {
6424 ret = my_data->acdb_get_audio_cal((void*)&cal, (void*)dptr, &param_len);
6425 if (ret == 0) {
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6426 if(param_len == 0 || param_len == MAX_SET_CAL_BYTE_SIZE) {
6427 ret = -EINVAL;
6428 goto done_key_audcal;
6429 }
6430 /* Allocate memory for encoding */
6431 rparms = (char*)calloc((param_len*2), sizeof(char));
6432 if(rparms == NULL) {
6433 ALOGE("[%s] Memory allocation failed for size %d",
6434 __func__, param_len*2);
6435 ret = -ENOMEM;
6436 goto done_key_audcal;
6437 }
6438 if(cal.persist==0 && cal.module_id && cal.param_id) {
6439 err = b64encode(dptr+12, param_len-12, rparms);
6440 } else {
6441 err = b64encode(dptr, param_len, rparms);
6442 }
6443 if(err < 0) {
6444 ALOGE("[%s] failed to convert data to string", __func__);
6445 ret = -EINVAL;
6446 goto done_key_audcal;
6447 }
6448 str_parms_add_int(reply, AUDIO_PARAMETER_KEY_AUD_CALRESULT, ret);
6449 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_AUD_CALDATA, rparms);
6450 }
6451 }
6452done_key_audcal:
6453 if(ret != 0) {
6454 str_parms_add_int(reply, AUDIO_PARAMETER_KEY_AUD_CALRESULT, ret);
6455 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_AUD_CALDATA, "");
6456 }
6457done:
6458 if(dptr != NULL)
6459 free(dptr);
6460 if(rparms != NULL)
6461 free(rparms);
6462}
6463
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6464void platform_get_parameters(void *platform,
6465 struct str_parms *query,
6466 struct str_parms *reply)
6467{
6468 struct platform_data *my_data = (struct platform_data *)platform;
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]6469 struct audio_device *adev = my_data->adev;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6470 char value[512] = {0};
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6471 int ret;
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]6472 char *kv_pairs = NULL;
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]6473 char propValue[PROPERTY_VALUE_MAX]={0};
6474 bool prop_playback_enabled = false;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6475
Shiv Maliyappanahalli9d899292013-11-20 14:43:01 -0800[diff] [blame]6476 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK,
6477 value, sizeof(value));
6478 if (ret >= 0) {
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]6479 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SLOWTALK,
6480 my_data->slowtalk?"true":"false");
Shiv Maliyappanahalli9d899292013-11-20 14:43:01 -0800[diff] [blame]6481 }
6482
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]6483 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_HD_VOICE,
6484 value, sizeof(value));
6485 if (ret >= 0) {
6486 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_HD_VOICE,
6487 my_data->hd_voice?"true":"false");
6488 }
6489
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]6490 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
6491 value, sizeof(value));
6492 if (ret >= 0) {
6493 if (my_data->voice_feature_set == VOICE_FEATURE_SET_VOLUME_BOOST) {
6494 strlcpy(value, "on", sizeof(value));
6495 } else {
6496 strlcpy(value, "off", sizeof(value));
6497 }
6498
6499 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value);
6500 }
6501
Aalique Grahame37659862017-12-03 22:34:26 -0800[diff] [blame]6502 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_DP_FOR_VOICE_USECASE,
6503 value, sizeof(value));
6504
6505 if (ret >= 0) {
6506 if (my_data->ext_disp_type == EXT_DISPLAY_TYPE_DP &&
6507 adev->dp_allowed_for_voice)
6508 strlcpy(value, "true", sizeof(value));
6509 else
6510 strlcpy(value, "false", sizeof(value));
6511
6512 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_DP_FOR_VOICE_USECASE, value);
6513 }
6514
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]6515 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_DP_CHANNEL_MASK,
6516 value, sizeof(value));
6517 if (ret >= 0) {
6518 ret = platform_get_edid_info(platform);
6519 edid_audio_info *info = (edid_audio_info *)my_data->edid_info;
6520 if (ret == 0 && info != NULL) {
6521 str_parms_add_int(reply, AUDIO_PARAMETER_KEY_DP_CHANNEL_MASK, info->channel_mask);
6522 }
6523 }
6524
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6525 /* Handle audio calibration keys */
6526 get_audiocal(platform, query, reply);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6527 native_audio_get_params(query, reply, value, sizeof(value));
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]6528
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]6529 ret = str_parms_get_str(query, AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED,
6530 value, sizeof(value));
6531 if (ret >= 0) {
6532 int isallowed = 1; /*true*/
6533
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]6534 if (property_get("vendor.voice.playback.conc.disabled", propValue, NULL)) {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]6535 prop_playback_enabled = atoi(propValue) ||
6536 !strncmp("true", propValue, 4);
6537 }
6538
Dhanalakshmi Siddania15c6792016-08-10 15:33:53 +0530[diff] [blame]6539 if ((prop_playback_enabled && (voice_is_in_call(my_data->adev))) ||
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]6540 (CARD_STATUS_OFFLINE == my_data->adev->card_status)) {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]6541 char *decoder_mime_type = value;
6542
6543 //check if unsupported mime type or not
6544 if(decoder_mime_type) {
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]6545 unsigned int i = 0;
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]6546 for (i = 0; i < sizeof(dsp_only_decoders_mime)/sizeof(dsp_only_decoders_mime[0]); i++) {
6547 if (!strncmp(decoder_mime_type, dsp_only_decoders_mime[i],
6548 strlen(dsp_only_decoders_mime[i]))) {
6549 ALOGD("Rejecting request for DSP only session from HAL during voice call/SSR state");
6550 isallowed = 0;
6551 break;
6552 }
6553 }
6554 }
6555 }
6556 str_parms_add_int(reply, AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED, isallowed);
6557 }
6558
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]6559 kv_pairs = str_parms_to_str(reply);
6560 ALOGV_IF(kv_pairs != NULL, "%s: exit: returns - %s", __func__, kv_pairs);
Narsinga Rao Chellacde45d12014-02-13 11:44:31 -0800[diff] [blame]6561 free(kv_pairs);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]6562}
6563
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]6564unsigned char* platform_get_license(void *platform, int *size)
6565{
6566 struct platform_data *my_data = (struct platform_data *)platform;
6567 char value[PROPERTY_VALUE_MAX] = {0};
6568 acdb_audio_cal_cfg_t cal;
6569 unsigned char *dptr = NULL;
6570 int ret=0;
6571 uint32_t param_len;
6572
6573 if (platform == NULL) {
6574 ALOGE("[%s] received null pointer %d ",__func__, __LINE__);
6575 ret = -EINVAL;
6576 goto done;
6577 }
6578 memset(&cal, 0, sizeof(cal));
6579 cal.persist = 1;
6580 cal.cal_type = AUDIO_CORE_METAINFO_CAL_TYPE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]6581 if (!property_get("vendor.audio.qaf.acdbid", value , "") && !atoi(value)) {
6582 ALOGE("[%s] vendor.audio.qaf.acdbid is not set %d ",__func__, __LINE__);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]6583 ret = -EINVAL;
6584 goto done;
6585 }
6586 cal.acdb_dev_id = (uint32_t) atoi (value);
6587 param_len = MAX_SET_CAL_BYTE_SIZE;
Sachin Mohan Gadage64c61e2017-07-17 18:11:16 +0530[diff] [blame]6588 dptr = (unsigned char*) calloc(param_len, sizeof(unsigned char));
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]6589 if (dptr == NULL) {
6590 ALOGE("[%s] Memory allocation failed for length %d",__func__,param_len);
6591 ret = -ENOMEM;
6592 goto done;
6593 }
6594 if (my_data->acdb_get_audio_cal != NULL) {
6595 ret = my_data->acdb_get_audio_cal((void*)&cal, (void*)dptr, &param_len);
6596 ALOGE("%s, ret[%d], param_len[%d] line %d", __func__, ret, param_len, __LINE__);
6597 if (ret == 0) {
6598 *size = param_len;
6599 return dptr;
6600 } else {
6601 *size = 0;
6602 }
6603 }
6604done:
6605 if (dptr != NULL)
6606 free(dptr);
6607
6608 return NULL;
6609}
6610
6611/* Delay in Us */
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]6612/* Delay in Us, only to be used for PCM formats */
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]6613int64_t platform_render_latency(audio_usecase_t usecase)
6614{
6615 switch (usecase) {
6616 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
6617 return DEEP_BUFFER_PLATFORM_DELAY;
6618 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
6619 return LOW_LATENCY_PLATFORM_DELAY;
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]6620 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
6621 case USECASE_AUDIO_PLAYBACK_OFFLOAD2:
6622 return PCM_OFFLOAD_PLATFORM_DELAY;
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700[diff] [blame]6623 case USECASE_AUDIO_PLAYBACK_ULL:
6624 return ULL_PLATFORM_DELAY;
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]6625 case USECASE_AUDIO_PLAYBACK_MMAP:
6626 return MMAP_PLATFORM_DELAY;
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]6627 default:
6628 return 0;
6629 }
6630}
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]6631
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]6632int platform_update_usecase_from_source(int source, int usecase)
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]6633{
Mingming Yinab429782013-11-07 11:16:55 -0800[diff] [blame]6634 ALOGV("%s: input source :%d", __func__, source);
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]6635 if (source == AUDIO_SOURCE_FM_TUNER)
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]6636 usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
6637 return usecase;
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]6638}
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]6639
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]6640bool platform_listen_device_needs_event(snd_device_t snd_device)
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]6641{
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]6642 bool needs_event = false;
6643
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]6644 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
6645 (snd_device < SND_DEVICE_IN_END) &&
6646 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]6647 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK) &&
6648 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1) &&
6649 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2))
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]6650 needs_event = true;
6651
6652 return needs_event;
6653}
6654
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700[diff] [blame]6655bool platform_listen_usecase_needs_event(audio_usecase_t uc_id __unused)
6656{
6657 return false;
6658}
6659
6660bool platform_sound_trigger_device_needs_event(snd_device_t snd_device)
6661{
6662 bool needs_event = false;
6663
6664 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
6665 (snd_device < SND_DEVICE_IN_END) &&
6666 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]6667 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK) &&
6668 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1) &&
6669 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2))
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700[diff] [blame]6670 needs_event = true;
6671
6672 return needs_event;
6673}
6674
Quinn Malef15123f2017-04-27 18:58:05 -0700[diff] [blame]6675bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id)
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]6676{
Quinn Malef15123f2017-04-27 18:58:05 -0700[diff] [blame]6677 bool needs_event = false;
6678
6679 switch(uc_id){
6680 /* concurrent playback usecases needs event */
6681 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
6682 case USECASE_AUDIO_PLAYBACK_MULTI_CH:
6683 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
6684 case USECASE_AUDIO_PLAYBACK_OFFLOAD2:
6685 needs_event = true;
6686 break;
6687 /* concurrent playback in low latency allowed */
6688 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
6689 break;
6690 /* concurrent playback FM needs event */
6691 case USECASE_AUDIO_PLAYBACK_FM:
6692 needs_event = true;
6693 break;
6694
Dhanalakshmi Siddanif133cc52018-02-08 14:34:51 +0530[diff] [blame]6695 /* concurrent capture usecases which needs event */
6696 case USECASE_AUDIO_RECORD:
6697 case USECASE_AUDIO_RECORD_LOW_LATENCY:
6698 case USECASE_AUDIO_RECORD_COMPRESS:
6699 case USECASE_AUDIO_RECORD_MMAP:
6700 case USECASE_AUDIO_RECORD_HIFI:
6701 case USECASE_VOICE_CALL:
6702 case USECASE_VOICE2_CALL:
6703 case USECASE_VOLTE_CALL:
6704 case USECASE_QCHAT_CALL:
6705 case USECASE_VOWLAN_CALL:
6706 case USECASE_VOICEMMODE1_CALL:
6707 case USECASE_VOICEMMODE2_CALL:
6708 case USECASE_COMPRESS_VOIP_CALL:
Dhanalakshmi Siddanif133cc52018-02-08 14:34:51 +0530[diff] [blame]6709 case USECASE_INCALL_REC_UPLINK:
6710 case USECASE_INCALL_REC_DOWNLINK:
6711 case USECASE_INCALL_REC_UPLINK_AND_DOWNLINK:
6712 case USECASE_INCALL_REC_UPLINK_COMPRESS:
6713 case USECASE_INCALL_REC_DOWNLINK_COMPRESS:
6714 case USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS:
6715 case USECASE_INCALL_MUSIC_UPLINK:
6716 case USECASE_INCALL_MUSIC_UPLINK2:
Dhanalakshmi Siddanif133cc52018-02-08 14:34:51 +0530[diff] [blame]6717 case USECASE_AUDIO_RECORD_VOIP:
6718 needs_event = true;
6719 break;
Quinn Malef15123f2017-04-27 18:58:05 -0700[diff] [blame]6720 default:
6721 ALOGV("%s:usecase_id[%d] no need to raise event.", __func__, uc_id);
6722 }
6723 return needs_event;
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]6724}
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]6725
6726/* Read offload buffer size from a property.
6727 * If value is not power of 2 round it to
6728 * power of 2.
6729 */
6730uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info)
6731{
6732 char value[PROPERTY_VALUE_MAX] = {0};
6733 uint32_t fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]6734 if((property_get("vendor.audio.offload.buffer.size.kb", value, "")) &&
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]6735 atoi(value)) {
6736 fragment_size = atoi(value) * 1024;
6737 }
6738
vivek mehta80a44292015-08-10 12:58:10 -0700[diff] [blame]6739 /* Use incoming offload buffer size if default buffer size is less */
6740 if ((info != NULL) && (fragment_size < info->offload_buffer_size)) {
6741 ALOGI("%s:: Overwriting offload buffer size default:%d new:%d", __func__,
6742 fragment_size,
6743 info->offload_buffer_size);
6744 fragment_size = info->offload_buffer_size;
6745 }
6746
Ramjee Singh21ffaa82017-07-28 17:47:01 +0530[diff] [blame]6747 if (info != NULL) {
6748 if (info->is_streaming && info->has_video) {
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]6749 fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING;
6750 ALOGV("%s: offload fragment size reduced for AV streaming to %d",
6751 __func__, fragment_size);
6752 } else if (info->format == AUDIO_FORMAT_FLAC) {
6753 fragment_size = FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
6754 ALOGV("FLAC fragment size %d", fragment_size);
6755 } else if (info->format == AUDIO_FORMAT_DSD) {
6756 fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]6757 if((property_get("vendor.audio.native.dsd.buffer.size.kb", value, "")) &&
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]6758 atoi(value))
6759 fragment_size = atoi(value) * 1024;
6760 ALOGV("DSD fragment size %d", fragment_size);
6761 }
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]6762 }
6763
6764 fragment_size = ALIGN( fragment_size, 1024);
6765
6766 if(fragment_size < MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
6767 fragment_size = MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
6768 else if(fragment_size > MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
6769 fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
6770 ALOGV("%s: fragment_size %d", __func__, fragment_size);
6771 return fragment_size;
6772}
6773
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6774/*
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]6775 * return backend_idx on which voice call is active
6776 */
6777static int platform_get_voice_call_backend(struct audio_device* adev)
6778{
6779 struct audio_usecase *uc = NULL;
6780 struct listnode *node;
6781 snd_device_t out_snd_device = SND_DEVICE_NONE;
6782
6783 int backend_idx = -1;
6784
6785 if (voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION) {
6786 list_for_each(node, &adev->usecase_list) {
6787 uc = node_to_item(node, struct audio_usecase, list);
6788 if (uc && (uc->type == VOICE_CALL || uc->type == VOIP_CALL) && uc->stream.out) {
6789 out_snd_device = platform_get_output_snd_device(adev->platform, uc->stream.out);
6790 backend_idx = platform_get_backend_index(out_snd_device);
6791 break;
6792 }
6793 }
6794 }
6795 return backend_idx;
6796}
6797
6798/*
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6799 * configures afe with bit width and Sample Rate
6800 */
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6801static int platform_set_codec_backend_cfg(struct audio_device* adev,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6802 snd_device_t snd_device, struct audio_backend_cfg backend_cfg)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6803{
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6804 int ret = -EINVAL;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6805 int backend_idx = platform_get_backend_index(snd_device);
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]6806 struct platform_data *my_data = (struct platform_data *)adev->platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6807 backend_idx = platform_get_backend_index(snd_device);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6808 unsigned int bit_width = backend_cfg.bit_width;
6809 unsigned int sample_rate = backend_cfg.sample_rate;
6810 unsigned int channels = backend_cfg.channels;
6811 audio_format_t format = backend_cfg.format;
6812 bool passthrough_enabled = backend_cfg.passthrough_enabled;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6813 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
6814
6815 /* Override the config params if client has already set them */
6816 adev_device_cfg_ptr += backend_idx;
6817 if (adev_device_cfg_ptr->use_client_dev_cfg) {
6818 ALOGV("%s::: Updating with the config set by client "
6819 "bitwidth %d, samplerate %d, channels %d format %d",
6820 __func__, adev_device_cfg_ptr->dev_cfg_params.bit_width,
6821 adev_device_cfg_ptr->dev_cfg_params.sample_rate,
6822 adev_device_cfg_ptr->dev_cfg_params.channels,
6823 adev_device_cfg_ptr->dev_cfg_params.format);
6824
6825 bit_width = adev_device_cfg_ptr->dev_cfg_params.bit_width;
6826 sample_rate = adev_device_cfg_ptr->dev_cfg_params.sample_rate;
6827 channels = adev_device_cfg_ptr->dev_cfg_params.channels;
6828 format = adev_device_cfg_ptr->dev_cfg_params.format;
6829 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6830
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6831 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d format %d"
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6832 ", backend_idx %d device (%s)", __func__, bit_width,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6833 sample_rate, channels, format, backend_idx,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6834 platform_get_snd_device_name(snd_device));
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]6835
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]6836 if ((my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl) &&
6837 (bit_width != my_data->current_backend_cfg[backend_idx].bit_width)) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]6838
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6839 struct mixer_ctl *ctl = NULL;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6840 ctl = mixer_get_ctl_by_name(adev->mixer,
6841 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6842 if (!ctl) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6843 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
6844 __func__,
6845 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6846 return -EINVAL;
6847 }
6848
6849 if (bit_width == 24) {
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]6850 if (format == AUDIO_FORMAT_PCM_24_BIT_PACKED)
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6851 ret = mixer_ctl_set_enum_by_string(ctl, "S24_3LE");
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]6852 else
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6853 ret = mixer_ctl_set_enum_by_string(ctl, "S24_LE");
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]6854 } else if (bit_width == 32) {
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]6855 ret = mixer_ctl_set_enum_by_string(ctl, "S32_LE");
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6856 } else {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6857 ret = mixer_ctl_set_enum_by_string(ctl, "S16_LE");
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6858 }
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6859 if ( ret < 0) {
6860 ALOGE("%s:becf: afe: fail for %s mixer set to %d bit for %x format", __func__,
6861 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
6862 } else {
6863 my_data->current_backend_cfg[backend_idx].bit_width = bit_width;
6864 ALOGD("%s:becf: afe: %s mixer set to %d bit for %x format", __func__,
6865 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
6866 }
6867 /* set the ret as 0 and not pass back to upper layer */
6868 ret = 0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6869 }
6870
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6871 if ((my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl) &&
6872 (passthrough_enabled || (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate))) {
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6873 char *rate_str = NULL;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6874 struct mixer_ctl *ctl = NULL;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6875
Preetam Singh Ranawat63c02ea2017-08-10 11:53:30 +0530[diff] [blame]6876 if (backend_idx == USB_AUDIO_RX_BACKEND ||
6877 backend_idx == USB_AUDIO_TX_BACKEND) {
6878 switch (sample_rate) {
6879 case 32000:
6880 rate_str = "KHZ_32";
6881 break;
6882 case 8000:
6883 rate_str = "KHZ_8";
6884 break;
6885 case 11025:
Sharad Sangle4cd17e32018-07-16 14:37:42 +0530[diff] [blame]6886 rate_str = "KHZ_11P025";
Preetam Singh Ranawat63c02ea2017-08-10 11:53:30 +0530[diff] [blame]6887 break;
6888 case 16000:
6889 rate_str = "KHZ_16";
6890 break;
6891 case 22050:
6892 rate_str = "KHZ_22P05";
6893 break;
6894 }
6895 }
6896
6897 if (rate_str == NULL) {
6898 switch (sample_rate) {
6899 case 32000:
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]6900 if (passthrough_enabled || (backend_idx == SPDIF_TX_BACKEND ) ||
6901 (backend_idx == HDMI_TX_BACKEND ) ||
6902 (backend_idx == HDMI_ARC_TX_BACKEND )) {
Preetam Singh Ranawat63c02ea2017-08-10 11:53:30 +0530[diff] [blame]6903 rate_str = "KHZ_32";
6904 break;
6905 }
6906 case 48000:
6907 rate_str = "KHZ_48";
6908 break;
6909 case 44100:
6910 rate_str = "KHZ_44P1";
6911 break;
6912 case 64000:
6913 case 96000:
6914 rate_str = "KHZ_96";
6915 break;
6916 case 88200:
6917 rate_str = "KHZ_88P2";
6918 break;
6919 case 176400:
6920 rate_str = "KHZ_176P4";
6921 break;
6922 case 192000:
6923 rate_str = "KHZ_192";
6924 break;
6925 case 352800:
6926 rate_str = "KHZ_352P8";
6927 break;
6928 case 384000:
6929 rate_str = "KHZ_384";
6930 break;
6931 case 144000:
6932 if (passthrough_enabled) {
6933 rate_str = "KHZ_144";
6934 break;
6935 }
6936 default:
6937 rate_str = "KHZ_48";
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +0530[diff] [blame]6938 break;
6939 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6940 }
6941
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6942 ctl = mixer_get_ctl_by_name(adev->mixer,
6943 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6944 if(!ctl) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6945 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
6946 __func__,
6947 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6948 return -EINVAL;
6949 }
6950
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6951 ALOGD("%s:becf: afe: %s set to %s", __func__,
6952 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl, rate_str);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6953 mixer_ctl_set_enum_by_string(ctl, rate_str);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]6954 my_data->current_backend_cfg[backend_idx].sample_rate = sample_rate;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6955 ret = 0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6956 }
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]6957 if ((my_data->current_backend_cfg[backend_idx].channels_mixer_ctl) &&
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6958 (channels != my_data->current_backend_cfg[backend_idx].channels)) {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6959 struct mixer_ctl *ctl = NULL;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6960 char *channel_cnt_str = NULL;
6961
6962 switch (channels) {
6963 case 8:
6964 channel_cnt_str = "Eight"; break;
6965 case 7:
6966 channel_cnt_str = "Seven"; break;
6967 case 6:
6968 channel_cnt_str = "Six"; break;
6969 case 5:
6970 channel_cnt_str = "Five"; break;
6971 case 4:
6972 channel_cnt_str = "Four"; break;
6973 case 3:
6974 channel_cnt_str = "Three"; break;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6975 case 1:
6976 channel_cnt_str = "One"; break;
6977 case 2:
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6978 default:
6979 channel_cnt_str = "Two"; break;
6980 }
6981
6982 ctl = mixer_get_ctl_by_name(adev->mixer,
6983 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
6984 if (!ctl) {
6985 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
6986 __func__,
6987 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
6988 return -EINVAL;
6989 }
6990 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
6991 my_data->current_backend_cfg[backend_idx].channels = channels;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]6992
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]6993 if ((backend_idx == HDMI_RX_BACKEND) ||
6994 (backend_idx == DISP_PORT_RX_BACKEND))
6995 platform_set_edid_channels_configuration(adev->platform, channels, backend_idx);
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]6996
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6997 ALOGD("%s:becf: afe: %s set to %s ", __func__,
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6998 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl,
6999 channel_cnt_str);
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7000 ret = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7001 }
7002
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7003 bool set_ext_disp_format = false, set_mi2s_tx_data_format = false;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7004 char *ext_disp_format = NULL;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7005
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7006 if (backend_idx == HDMI_RX_BACKEND) {
7007 ext_disp_format = "HDMI RX Format";
7008 set_ext_disp_format = true;
7009 } else if (backend_idx == DISP_PORT_RX_BACKEND) {
Garmond Leungade0f6d2017-02-03 15:56:10 -0800[diff] [blame]7010 ext_disp_format = "Display Port RX Format";
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7011 set_ext_disp_format = true;
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]7012 } else if (backend_idx == SPDIF_TX_BACKEND) {
7013 ext_disp_format = "PRI SPDIF TX Format";
7014 set_mi2s_tx_data_format = true;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7015 } else if (backend_idx == HDMI_TX_BACKEND) {
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]7016 if (!strncmp(platform_get_snd_device_backend_interface(snd_device),
7017 "SEC_MI2S_TX", sizeof("SEC_MI2S_TX")))
7018 ext_disp_format = "SEC MI2S TX Format";
7019 else
7020 ext_disp_format = "QUAT MI2S TX Format";
7021 set_mi2s_tx_data_format = true;
7022 } else if (backend_idx == HDMI_ARC_TX_BACKEND) {
7023 ext_disp_format = "SEC SPDIF TX Format";
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7024 set_mi2s_tx_data_format = true;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7025 } else {
7026 ALOGV("%s: Format doesnt have to be set", __func__);
7027 }
7028
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7029 format = format & AUDIO_FORMAT_MAIN_MASK;
7030 /* Set data format only if there is a change from PCM to compressed
7031 and vice versa */
7032 if (set_mi2s_tx_data_format && (format ^ my_data->current_backend_cfg[backend_idx].format)) {
7033 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, ext_disp_format);
7034 if (!ctl) {
7035 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
7036 __func__, ext_disp_format);
7037 return -EINVAL;
7038 }
7039 if (format == AUDIO_FORMAT_PCM) {
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]7040 ALOGE("%s:Set %s to LPCM", __func__, ext_disp_format);
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7041 mixer_ctl_set_enum_by_string(ctl, "LPCM");
7042 } else {
Ralf Herzafb164f2018-07-03 07:08:07 +0200[diff] [blame]7043 ALOGE("%s:Set %s to Compr", __func__, ext_disp_format);
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7044 mixer_ctl_set_enum_by_string(ctl, "Compr");
7045 }
7046 my_data->current_backend_cfg[backend_idx].format = format;
7047 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7048 if (set_ext_disp_format) {
7049 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, ext_disp_format);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7050 if (!ctl) {
7051 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7052 __func__, ext_disp_format);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7053 return -EINVAL;
7054 }
7055
7056 if (passthrough_enabled) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7057 ALOGD("%s:Ext display compress format", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7058 mixer_ctl_set_enum_by_string(ctl, "Compr");
7059 } else {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7060 ALOGD("%s: Ext display PCM format", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7061 mixer_ctl_set_enum_by_string(ctl, "LPCM");
7062 }
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7063 ret = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7064 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7065 return ret;
7066}
7067
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7068/*
Satish Babu Patakokila5933e972017-08-24 12:22:08 +0530[diff] [blame]7069 * Get the backend configuration for current snd device
7070 */
7071int platform_get_codec_backend_cfg(struct audio_device* adev,
7072 snd_device_t snd_device,
7073 struct audio_backend_cfg *backend_cfg)
7074{
7075 int backend_idx = platform_get_backend_index(snd_device);
7076 struct platform_data *my_data = (struct platform_data *)adev->platform;
7077
7078 backend_cfg->bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
7079 backend_cfg->sample_rate =
7080 my_data->current_backend_cfg[backend_idx].sample_rate;
7081 backend_cfg->channels =
7082 my_data->current_backend_cfg[backend_idx].channels;
7083 backend_cfg->format =
7084 my_data->current_backend_cfg[backend_idx].format;
7085
7086 ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d format %d"
7087 ", backend_idx %d device (%s)", __func__, backend_cfg->bit_width,
7088 backend_cfg->sample_rate, backend_cfg->channels, backend_cfg->format,
7089 backend_idx, platform_get_snd_device_name(snd_device));
7090
7091 return 0;
7092}
7093
7094/*
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7095 *Validate the selected bit_width, sample_rate and channels using the edid
7096 *of the connected sink device.
7097 */
7098static void platform_check_hdmi_backend_cfg(struct audio_device* adev,
7099 struct audio_usecase* usecase,
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7100 int backend_idx,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7101 struct audio_backend_cfg *hdmi_backend_cfg)
7102{
7103 unsigned int bit_width;
7104 unsigned int sample_rate;
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]7105 int channels, max_supported_channels = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7106 struct platform_data *my_data = (struct platform_data *)adev->platform;
7107 edid_audio_info *edid_info = (edid_audio_info *)my_data->edid_info;
7108 bool passthrough_enabled = false;
7109
7110 bit_width = hdmi_backend_cfg->bit_width;
7111 sample_rate = hdmi_backend_cfg->sample_rate;
7112 channels = hdmi_backend_cfg->channels;
7113
7114
7115 ALOGI("%s:becf: HDMI: bitwidth %d, samplerate %d, channels %d"
7116 ", usecase = %d", __func__, bit_width,
7117 sample_rate, channels, usecase->id);
7118
7119 if (audio_extn_passthru_is_enabled() && audio_extn_passthru_is_active()
7120 && (usecase->stream.out->compr_config.codec->compr_passthr != 0)) {
7121 passthrough_enabled = true;
7122 ALOGI("passthrough is enabled for this stream");
7123 }
7124
7125 // For voice calls use default configuration i.e. 16b/48K, only applicable to
7126 // default backend
7127 if (!passthrough_enabled) {
7128
7129 max_supported_channels = platform_edid_get_max_channels(my_data);
7130
7131 //Check EDID info for supported samplerate
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]7132 if (!audio_extn_edid_is_supported_sr(edid_info,sample_rate)) {
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]7133 //check to see if current BE sample rate is supported by EDID
7134 //else assign the highest sample rate supported by EDID
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]7135 if (audio_extn_edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]7136 sample_rate = my_data->current_backend_cfg[backend_idx].sample_rate;
7137 else
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]7138 sample_rate = audio_extn_edid_get_highest_supported_sr(edid_info);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7139 }
7140
7141 //Check EDID info for supported bit width
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]7142 if (!audio_extn_edid_is_supported_bps(edid_info,bit_width)) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7143 //reset to current sample rate
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7144 bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7145 }
7146
7147 if (channels > max_supported_channels)
7148 channels = max_supported_channels;
7149
7150 } else {
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]7151 channels = audio_extn_passthru_get_channel_count(usecase->stream.out);
7152 if (channels <= 0) {
7153 ALOGE("%s: becf: afe: HDMI backend using defalut channel %u",
7154 __func__, DEFAULT_HDMI_OUT_CHANNELS);
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]7155 channels = DEFAULT_HDMI_OUT_CHANNELS;
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]7156 }
Harsh Bansal026d97f2017-08-17 17:44:49 +0530[diff] [blame]7157 if (((usecase->stream.out->format == AUDIO_FORMAT_E_AC3) ||
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]7158 (usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC) ||
Harsh Bansal026d97f2017-08-17 17:44:49 +0530[diff] [blame]7159 (usecase->stream.out->format == AUDIO_FORMAT_DOLBY_TRUEHD))
7160 && (usecase->stream.out->compr_config.codec->compr_passthr == PASSTHROUGH)) {
Naresh Tanniru3a406772017-05-10 13:09:05 -0700[diff] [blame]7161 sample_rate = sample_rate * 4;
7162 if (sample_rate > HDMI_PASSTHROUGH_MAX_SAMPLE_RATE)
7163 sample_rate = HDMI_PASSTHROUGH_MAX_SAMPLE_RATE;
7164 }
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]7165
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7166 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
7167 /* We force route so that the BE format can be set to Compr */
7168 }
7169
7170 ALOGI("%s:becf: afe: HDMI backend: passthrough %d updated bit width: %d and sample rate: %d"
7171 "channels %d", __func__, passthrough_enabled , bit_width,
7172 sample_rate, channels);
7173
7174 hdmi_backend_cfg->bit_width = bit_width;
7175 hdmi_backend_cfg->sample_rate = sample_rate;
7176 hdmi_backend_cfg->channels = channels;
7177 hdmi_backend_cfg->passthrough_enabled = passthrough_enabled;
7178}
7179
7180/*
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7181 * goes through all the current usecases and picks the highest
7182 * bitwidth & samplerate
7183 */
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7184static bool platform_check_codec_backend_cfg(struct audio_device* adev,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7185 struct audio_usecase* usecase,
7186 snd_device_t snd_device,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7187 struct audio_backend_cfg *backend_cfg)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7188{
7189 bool backend_change = false;
7190 struct listnode *node;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7191 unsigned int bit_width;
7192 unsigned int sample_rate;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7193 unsigned int channels;
Garmond Leung5fd0b552018-04-17 11:56:12 -0700[diff] [blame]7194 unsigned long service_interval = 0;
7195 bool service_interval_update = false;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7196 bool passthrough_enabled = false;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]7197 bool voice_call_active = false;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7198 int backend_idx = DEFAULT_CODEC_BACKEND;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]7199 struct platform_data *my_data = (struct platform_data *)adev->platform;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7200 int na_mode = platform_get_native_support();
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7201 bool channels_updated = false;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7202 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]7203
Ashish Jainc597d102016-12-12 10:31:34 +0530[diff] [blame]7204 /*BT devices backend is not configured from HAL hence skip*/
7205 if (snd_device == SND_DEVICE_OUT_BT_A2DP ||
7206 snd_device == SND_DEVICE_OUT_BT_SCO ||
Sachin Mohan Gadag2e4dcb12017-05-12 13:05:08 +0530[diff] [blame]7207 snd_device == SND_DEVICE_OUT_BT_SCO_WB ||
Florian Pfister1a84f312018-07-19 14:38:18 +0200[diff] [blame]7208 snd_device == SND_DEVICE_IN_BT_A2DP ||
Sachin Mohan Gadag2e4dcb12017-05-12 13:05:08 +0530[diff] [blame]7209 snd_device == SND_DEVICE_OUT_AFE_PROXY) {
Ashish Jainc597d102016-12-12 10:31:34 +0530[diff] [blame]7210 backend_change = false;
7211 return backend_change;
7212 }
7213
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7214 backend_idx = platform_get_backend_index(snd_device);
7215
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7216 bit_width = backend_cfg->bit_width;
7217 sample_rate = backend_cfg->sample_rate;
7218 channels = backend_cfg->channels;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7219
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7220 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7221 ", backend_idx %d usecase = %d device (%s)", __func__, bit_width,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7222 sample_rate, channels, backend_idx, usecase->id,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7223 platform_get_snd_device_name(snd_device));
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7224
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]7225 // For voice calls use default configuration i.e. 16b/48K, only applicable to
7226 // default backend
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7227 // force routing is not required here, caller will do it anyway
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7228 if (backend_idx == platform_get_voice_call_backend(adev)) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7229 ALOGW("%s:becf: afe:Use default bw and sr for voice/voip calls ",
7230 __func__);
Narsinga Rao Chella44376cc2014-10-24 13:27:14 -0700[diff] [blame]7231 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
7232 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7233 channels = CODEC_BACKEND_DEFAULT_CHANNELS;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]7234 voice_call_active = true;
Narsinga Rao Chella44376cc2014-10-24 13:27:14 -0700[diff] [blame]7235 } else {
7236 /*
7237 * The backend should be configured at highest bit width and/or
7238 * sample rate amongst all playback usecases.
7239 * If the selected sample rate and/or bit width differ with
7240 * current backend sample rate and/or bit width, then, we set the
7241 * backend re-configuration flag.
7242 *
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7243 * Exception: 16 bit playbacks is allowed through 16 bit/48/44.1 khz backend only
Narsinga Rao Chella44376cc2014-10-24 13:27:14 -0700[diff] [blame]7244 */
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7245 int i =0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7246 list_for_each(node, &adev->usecase_list) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7247 struct audio_usecase *uc;
7248 uc = node_to_item(node, struct audio_usecase, list);
7249 struct stream_out *out = (struct stream_out*) uc->stream.out;
7250 if (uc->type == PCM_PLAYBACK && out && usecase != uc) {
Preetam Singh Ranawataa37d3f2016-08-23 12:25:23 +0530[diff] [blame]7251 unsigned int out_channels = audio_channel_count_from_out_mask(out->channel_mask);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7252
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7253 ALOGD("%s:napb: (%d) - (%s)id (%d) sr %d bw "
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7254 "(%d) ch (%d) device %s", __func__, i++, use_case_table[uc->id],
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7255 uc->id, out->sample_rate,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7256 out->bit_width, out_channels,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7257 platform_get_snd_device_name(uc->out_snd_device));
7258
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7259 if (platform_check_backends_match(snd_device, uc->out_snd_device)) {
Amit Shekhar278e3362014-09-08 14:08:19 -0700[diff] [blame]7260 if (bit_width < out->bit_width)
7261 bit_width = out->bit_width;
7262 if (sample_rate < out->sample_rate)
7263 sample_rate = out->sample_rate;
Revathi Uddaraju869ae492018-02-09 16:27:35 +0530[diff] [blame]7264 /*
7265 * TODO: Add Support for Backend configuration for devices which support
7266 * sample rate less than 44.1
7267 */
7268 if (sample_rate < OUTPUT_SAMPLING_RATE_44100)
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7269 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7270 if (channels < out_channels)
7271 channels = out_channels;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7272 }
7273 }
7274 }
7275 }
7276
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7277 /* Native playback is preferred for Headphone/HS device over 192Khz */
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]7278 if (!voice_call_active && codec_device_supports_native_playback(usecase->devices)) {
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7279 if (audio_is_true_native_stream_active(adev)) {
7280 if (check_hdset_combo_device(snd_device)) {
7281 /*
7282 * In true native mode Tasha has a limitation that one port at 44.1 khz
7283 * cannot drive both spkr and hdset, to simiplify the solution lets
7284 * move the AFE to 48khzwhen a ring tone selects combo device.
7285 * or if NATIVE playback is not enabled.
7286 */
7287 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
7288 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]7289 ALOGD("%s:becf: afe: port to run at 48k if combo device or in voice call"
7290 , __func__);
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7291 } else {
7292 /*
7293 * in single BE mode, if native audio playback
7294 * is active then it will take priority
7295 */
7296 sample_rate = OUTPUT_SAMPLING_RATE_44100;
7297 ALOGD("%s:becf: afe: true napb active set rate to 44.1 khz",
7298 __func__);
7299 }
Ashish Jain7f25be32016-10-25 21:44:16 +0530[diff] [blame]7300 } else if (na_mode != NATIVE_AUDIO_MODE_MULTIPLE_44_1) {
7301 /*
7302 * Map native sampling rates to upper limit range
7303 * if multiple of native sampling rates are not supported.
7304 * This check also indicates that this is not tavil codec
7305 * And 32bit/384kHz is only supported on tavil
7306 * Hence reset 32b/384kHz to 24b/192kHz.
7307 */
7308 switch (sample_rate) {
7309 case 44100:
7310 sample_rate = 48000;
7311 break;
7312 case 88200:
7313 sample_rate = 96000;
7314 break;
7315 case 176400:
7316 case 352800:
7317 case 384000:
7318 sample_rate = 192000;
7319 break;
7320 }
7321 if (bit_width > 24)
7322 bit_width = 24;
7323
7324 ALOGD("%s:becf: afe: napb not active - set non fractional rate",
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7325 __func__);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7326 }
kunleiz815b43e2018-08-10 11:08:03 +0800[diff] [blame]7327 /*reset sample rate to 48khz if sample rate less than 44.1khz, or device backend dose not support 44.1 khz*/
kunleiz72e744c2018-09-27 18:09:16 +0800[diff] [blame]7328 if ((sample_rate == OUTPUT_SAMPLING_RATE_44100 &&
7329 backend_idx != HEADPHONE_44_1_BACKEND &&
7330 backend_idx != HEADPHONE_BACKEND &&
7331 backend_idx != USB_AUDIO_RX_BACKEND) ||
7332 sample_rate < OUTPUT_SAMPLING_RATE_44100) {
7333 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
7334 ALOGD("%s:becf: afe: set sample rate to default Sample Rate(48k)",__func__);
kunleiz6ba62d12018-06-20 13:55:46 +0800[diff] [blame]7335 }
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]7336 }
7337
7338 /*
kunleiz0a99fcf2018-06-14 16:41:21 +0800[diff] [blame]7339 * Handset and speaker may have diffrent backend. Check if the device is speaker or handset,
7340 * and these devices are restricited to 48kHz.
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]7341 */
7342 if (platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, snd_device)) {
Ramu Gottipati074fa4d2018-09-11 20:05:51 +0530[diff] [blame]7343 int bw = platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER);
7344 if ((-ENOSYS != bw) && (bit_width > (uint32_t)bw)) {
7345 bit_width = (uint32_t)bw;
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]7346 ALOGD("%s:becf: afe: reset bitwidth to %d (based on supported"
Ramu Gottipati074fa4d2018-09-11 20:05:51 +0530[diff] [blame]7347 " value for this platform)", __func__, bit_width);
7348 } else if (-ENOSYS == bw) {
7349 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
7350 ALOGD("%s:becf: afe: reset to default bitwidth %d", __func__, bit_width);
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]7351 }
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]7352 /*
7353 * In case of CSRA speaker out, all sample rates are supported, so
7354 * check platform here
7355 */
7356 if (platform_spkr_use_default_sample_rate(adev->platform)) {
7357 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
7358 ALOGD("%s:becf: afe: playback on codec device not supporting native playback set "
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7359 "default Sample Rate(48k)", __func__);
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]7360 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7361 }
7362
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]7363 if (backend_idx == USB_AUDIO_RX_BACKEND) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7364 audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, true);
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]7365 ALOGV("%s: USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)",
7366 __func__, bit_width, sample_rate, channels);
Garmond Leung5fd0b552018-04-17 11:56:12 -0700[diff] [blame]7367
7368 if (audio_extn_usb_get_service_interval(true,
7369 &service_interval) == 0) {
7370 /* overwrite with best altset for this service interval */
7371 int ret =
7372 audio_extn_usb_altset_for_service_interval(true /*playback*/,
7373 service_interval,
7374 &bit_width,
7375 &sample_rate,
7376 &channels);
7377 ALOGD("%s: Override USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)SI(%lu)",
7378 __func__, bit_width, sample_rate, channels, service_interval);
7379 if (ret < 0) {
7380 ALOGW("Failed to find altset for service interval %lu, skip reconfig",
7381 service_interval);
7382 return false;
7383 }
7384 service_interval_update = audio_extn_usb_is_reconfig_req();
7385 audio_extn_usb_set_reconfig(false);
7386 }
7387
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]7388 if (channels != my_data->current_backend_cfg[backend_idx].channels)
7389 channels_updated = true;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]7390 }
7391
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7392 if (backend_idx == HDMI_RX_BACKEND || backend_idx == DISP_PORT_RX_BACKEND) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7393 struct audio_backend_cfg hdmi_backend_cfg;
7394 hdmi_backend_cfg.bit_width = bit_width;
7395 hdmi_backend_cfg.sample_rate = sample_rate;
7396 hdmi_backend_cfg.channels = channels;
7397 hdmi_backend_cfg.passthrough_enabled = false;
7398
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]7399 /*
7400 * HDMI does not support 384Khz/32bit playback hence configure BE to 24b/192Khz
7401 * TODO: Instead have the validation against edid return the next best match
7402 */
7403 if (bit_width > 24)
7404 hdmi_backend_cfg.bit_width = 24;
7405 if (sample_rate > 192000)
7406 hdmi_backend_cfg.sample_rate = 192000;
7407
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]7408 platform_check_hdmi_backend_cfg(adev, usecase, backend_idx, &hdmi_backend_cfg);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7409
7410 bit_width = hdmi_backend_cfg.bit_width;
7411 sample_rate = hdmi_backend_cfg.sample_rate;
7412 channels = hdmi_backend_cfg.channels;
7413 passthrough_enabled = hdmi_backend_cfg.passthrough_enabled;
7414
7415 if (channels != my_data->current_backend_cfg[backend_idx].channels)
7416 channels_updated = true;
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]7417 }
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7418
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7419 ALOGI("%s:becf: afe: Codec selected backend: %d updated bit width: %d and sample rate: %d",
7420 __func__, backend_idx , bit_width, sample_rate);
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]7421
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7422 // Force routing if the expected bitwdith or samplerate
7423 // is not same as current backend comfiguration
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7424 if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7425 (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
Garmond Leung5fd0b552018-04-17 11:56:12 -0700[diff] [blame]7426 passthrough_enabled || channels_updated || service_interval_update ) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7427 backend_cfg->bit_width = bit_width;
7428 backend_cfg->sample_rate = sample_rate;
7429 backend_cfg->channels = channels;
7430 backend_cfg->passthrough_enabled = passthrough_enabled;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7431 backend_change = true;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7432 ALOGI("%s:becf: afe: Codec backend needs to be updated. new bit width: %d"
7433 "new sample rate: %d new channels: %d",
7434 __func__, backend_cfg->bit_width, backend_cfg->sample_rate, backend_cfg->channels);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7435 }
7436
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7437 // Force routing if the client sends config params for this backend
7438 adev_device_cfg_ptr += backend_idx;
7439 if (adev_device_cfg_ptr->use_client_dev_cfg) {
7440 ALOGV("%s: Codec backend needs to be updated as Client provided "
7441 "config params", __func__);
7442 backend_change = true;
7443 }
7444
Preetam Singh Ranawatdc1a3952016-11-24 17:35:51 +0530[diff] [blame]7445 if (snd_device == SND_DEVICE_OUT_HEADPHONES || snd_device ==
7446 SND_DEVICE_OUT_HEADPHONES_44_1) {
7447 if (sample_rate > 48000 ||
7448 (bit_width >= 24 && (sample_rate == 48000 || sample_rate == 44100))) {
7449 ALOGI("%s: apply HPH HQ mode\n", __func__);
7450 audio_route_apply_and_update_path(adev->audio_route, "hph-highquality-mode");
7451 } else {
7452 ALOGI("%s: apply HPH LP mode\n", __func__);
7453 audio_route_apply_and_update_path(adev->audio_route, "hph-lowpower-mode");
7454 }
7455 }
7456
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7457 return backend_change;
7458}
7459
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7460bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev,
7461 struct audio_usecase *usecase, snd_device_t snd_device)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7462{
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7463 int backend_idx = DEFAULT_CODEC_BACKEND;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]7464 int new_snd_devices[SND_DEVICE_OUT_END] = {0};
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7465 int i, num_devices = 1;
7466 bool ret = false;
7467 struct platform_data *my_data = (struct platform_data *)adev->platform;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7468 struct audio_backend_cfg backend_cfg;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7469
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]7470 backend_idx = platform_get_backend_index(snd_device);
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]7471
Surendar Karka93cd25a2018-08-28 14:21:37 +0530[diff] [blame]7472 if (usecase->type == TRANSCODE_LOOPBACK_RX) {
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]7473 backend_cfg.bit_width = usecase->stream.inout->out_config.bit_width;
7474 backend_cfg.sample_rate = usecase->stream.inout->out_config.sample_rate;
7475 backend_cfg.format = usecase->stream.inout->out_config.format;
7476 backend_cfg.channels = audio_channel_count_from_out_mask(
7477 usecase->stream.inout->out_config.channel_mask);
7478 } else {
7479 backend_cfg.bit_width = usecase->stream.out->bit_width;
7480 backend_cfg.sample_rate = usecase->stream.out->sample_rate;
7481 backend_cfg.format = usecase->stream.out->format;
Xiaojun Sang841cb5f2018-11-06 19:37:44 +0800[diff] [blame]7482 backend_cfg.channels = audio_channel_count_from_out_mask(usecase->stream.out->channel_mask);
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]7483 }
Xiaojun Sang785b5da2017-08-03 15:52:29 +0800[diff] [blame]7484 if (audio_extn_is_dsp_bit_width_enforce_mode_supported(usecase->stream.out->flags) &&
7485 (adev->dsp_bit_width_enforce_mode > backend_cfg.bit_width))
7486 backend_cfg.bit_width = adev->dsp_bit_width_enforce_mode;
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]7487
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7488 /*this is populated by check_codec_backend_cfg hence set default value to false*/
7489 backend_cfg.passthrough_enabled = false;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7490
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]7491 /* Set Backend sampling rate to 176.4 for DSD64 and
7492 * 352.8Khz for DSD128.
7493 * Set Bit Width to 16
7494 */
7495 if ((backend_idx == DSD_NATIVE_BACKEND) && (backend_cfg.format == AUDIO_FORMAT_DSD)) {
7496 backend_cfg.bit_width = 16;
7497 if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD64)
7498 backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD64;
7499 else if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD128)
7500 backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD128;
7501 }
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7502 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
7503 ", backend_idx %d usecase = %d device (%s)", __func__, backend_cfg.bit_width,
7504 backend_cfg.sample_rate, backend_cfg.channels, backend_idx, usecase->id,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]7505 platform_get_snd_device_name(snd_device));
7506
Surendar Karka45850ae2018-07-02 17:45:27 +0530[diff] [blame]7507 if ((my_data->spkr_ch_map != NULL) &&
7508 (platform_get_backend_index(snd_device) == DEFAULT_CODEC_BACKEND))
7509 platform_set_channel_map(my_data, my_data->spkr_ch_map->num_ch,
7510 my_data->spkr_ch_map->chmap, -1);
7511
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]7512 if (platform_split_snd_device(my_data, snd_device, &num_devices,
7513 new_snd_devices) < 0)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7514 new_snd_devices[0] = snd_device;
7515
7516 for (i = 0; i < num_devices; i++) {
7517 ALOGI("%s: new_snd_devices[%d] is %d", __func__, i, new_snd_devices[i]);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7518 if ((platform_check_codec_backend_cfg(adev, usecase, new_snd_devices[i],
7519 &backend_cfg))) {
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7520 ret = platform_set_codec_backend_cfg(adev, new_snd_devices[i],
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]7521 backend_cfg);
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7522 if (!ret) {
7523 ret = true;
7524 } else {
7525 ret = false;
7526 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7527 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7528 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7529 return ret;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]7530}
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7531
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7532/*
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7533 * goes through all the current usecases and picks the highest
7534 * bitwidth & samplerate
7535 */
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7536static bool platform_check_capture_codec_backend_cfg(struct audio_device* adev,
7537 int backend_idx,
Sachin Mohan Gadag4d7e5b82018-11-02 17:10:58 +0530[diff] [blame]7538 struct audio_backend_cfg *backend_cfg,
7539 snd_device_t snd_device)
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7540{
7541 bool backend_change = false;
7542 unsigned int bit_width;
7543 unsigned int sample_rate;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7544 unsigned int channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7545 unsigned int format;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7546 struct platform_data *my_data = (struct platform_data *)adev->platform;
7547
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7548 bit_width = backend_cfg->bit_width;
7549 sample_rate = backend_cfg->sample_rate;
7550 channels = backend_cfg->channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7551 format = backend_cfg->format;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7552
7553 ALOGI("%s:txbecf: afe: Codec selected backend: %d current bit width: %d and "
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7554 "sample rate: %d, channels %d format %d",__func__,backend_idx, bit_width,
7555 sample_rate, channels,format);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7556
7557 // For voice calls use default configuration i.e. 16b/48K, only applicable to
7558 // default backend
7559 // force routing is not required here, caller will do it anyway
Sachin Mohan Gadag4d7e5b82018-11-02 17:10:58 +0530[diff] [blame]7560 if ((voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION)) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]7561
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7562 ALOGW("%s:txbecf: afe: Use default bw and sr for voice/voip calls and "
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7563 "for unprocessed/camera source", __func__);
7564 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
7565 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]7566 channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
Samyak Jain2ab8c5a2018-11-26 19:57:47 +0530[diff] [blame]7567 } else if (my_data->is_internal_codec && !audio_is_usb_in_device(snd_device)) {
Sachin Mohan Gadag4d7e5b82018-11-02 17:10:58 +0530[diff] [blame]7568 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
7569 channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
7570 if (adev->active_input->bit_width == 24)
7571 bit_width = platform_get_snd_device_bit_width(snd_device);
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]7572 } else {
7573 struct listnode *node;
7574 struct audio_usecase *uc = NULL;
7575 unsigned int uc_channels = 0;
7576 struct stream_in *in = NULL;
7577 /* update cfg against other existing capture usecases on same backend */
7578 list_for_each(node, &adev->usecase_list) {
7579 uc = node_to_item(node, struct audio_usecase, list);
Satya Krishna Pindiproli9f566672017-02-28 11:14:01 +0530[diff] [blame]7580 in = (struct stream_in *) uc->stream.in;
7581 if (in != NULL && uc->type == PCM_CAPTURE &&
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]7582 backend_idx == platform_get_backend_index(uc->in_snd_device)) {
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]7583 uc_channels = audio_channel_count_from_in_mask(in->channel_mask);
7584
7585 ALOGV("%s:txbecf: uc %s, id %d, sr %d, bw %d, ch %d, device %s",
7586 __func__, use_case_table[uc->id], uc->id, in->sample_rate,
7587 in->bit_width, uc_channels,
7588 platform_get_snd_device_name(uc->in_snd_device));
7589
7590 if (sample_rate < in->sample_rate)
7591 sample_rate = in->sample_rate;
7592 if (bit_width < in->bit_width)
7593 bit_width = in->bit_width;
7594 if (channels < uc_channels)
7595 channels = uc_channels;
7596 }
7597 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7598 }
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7599 if (backend_idx == USB_AUDIO_TX_BACKEND) {
7600 audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, false);
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7601 ALOGV("%s:txbecf: afe: USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)",
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7602 __func__, bit_width, sample_rate, channels);
7603 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7604
7605 ALOGI("%s:txbecf: afe: Codec selected backend: %d updated bit width: %d and "
7606 "sample rate: %d", __func__, backend_idx, bit_width, sample_rate);
7607 // Force routing if the expected bitwdith or samplerate
7608 // is not same as current backend comfiguration
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7609 if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
7610 (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7611 (channels != my_data->current_backend_cfg[backend_idx].channels) ||
7612 ((format & AUDIO_FORMAT_MAIN_MASK) != my_data->current_backend_cfg[backend_idx].format)) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7613 backend_cfg->bit_width = bit_width;
7614 backend_cfg->sample_rate= sample_rate;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7615 backend_cfg->channels = channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7616 backend_cfg->format = format & AUDIO_FORMAT_MAIN_MASK;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7617 backend_change = true;
7618 ALOGI("%s:txbecf: afe: Codec backend needs to be updated. new bit width: %d "
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7619 "new sample rate: %d new channel: %d new format: %d",
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7620 __func__, backend_cfg->bit_width,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7621 backend_cfg->sample_rate, backend_cfg->channels, backend_cfg->format);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7622 }
7623
7624 return backend_change;
7625}
7626
7627bool platform_check_and_set_capture_codec_backend_cfg(struct audio_device* adev,
7628 struct audio_usecase *usecase, snd_device_t snd_device)
7629{
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7630 int backend_idx = platform_get_backend_index(snd_device);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7631 int ret = 0;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7632 struct audio_backend_cfg backend_cfg;
7633
7634 backend_cfg.passthrough_enabled = false;
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]7635
Surendar Karka93cd25a2018-08-28 14:21:37 +0530[diff] [blame]7636 if (usecase->type == TRANSCODE_LOOPBACK_TX) {
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]7637 backend_cfg.bit_width = usecase->stream.inout->in_config.bit_width;
7638 backend_cfg.sample_rate = usecase->stream.inout->in_config.sample_rate;
7639 backend_cfg.format = usecase->stream.inout->in_config.format;
7640 backend_cfg.channels = audio_channel_count_from_out_mask(
7641 usecase->stream.inout->in_config.channel_mask);
7642 } else if (usecase->type == PCM_CAPTURE) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7643 backend_cfg.sample_rate= usecase->stream.in->sample_rate;
7644 backend_cfg.bit_width= usecase->stream.in->bit_width;
7645 backend_cfg.format= usecase->stream.in->format;
7646 backend_cfg.channels = audio_channel_count_from_in_mask(usecase->stream.in->channel_mask);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7647 } else {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7648 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
7649 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
7650 backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
7651 backend_cfg.channels = 1;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7652 }
7653
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7654 ALOGI("%s:txbecf: afe: bitwidth %d, samplerate %d, channel %d format %d"
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7655 ", backend_idx %d usecase = %d device (%s)", __func__,
7656 backend_cfg.bit_width,
7657 backend_cfg.sample_rate,
7658 backend_cfg.channels,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]7659 backend_cfg.format,
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7660 backend_idx, usecase->id,
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7661 platform_get_snd_device_name(snd_device));
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]7662 if (platform_check_capture_codec_backend_cfg(adev, backend_idx,
Sachin Mohan Gadag4d7e5b82018-11-02 17:10:58 +0530[diff] [blame]7663 &backend_cfg, snd_device)) {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]7664 ret = platform_set_codec_backend_cfg(adev, snd_device,
7665 backend_cfg);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]7666 if(!ret)
7667 return true;
7668 }
7669
7670 return false;
7671}
7672
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7673int platform_set_snd_device_backend(snd_device_t device, const char *backend_tag,
7674 const char * hw_interface)
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7675{
7676 int ret = 0;
7677
7678 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
7679 ALOGE("%s: Invalid snd_device = %d",
7680 __func__, device);
7681 ret = -EINVAL;
7682 goto done;
7683 }
7684
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7685 ALOGD("%s: backend_tag_table[%s]: old = %s new = %s", __func__,
7686 platform_get_snd_device_name(device),
7687 backend_tag_table[device] != NULL ? backend_tag_table[device]: "null",
7688 backend_tag);
Ashish Jaind150d4c2017-02-03 18:44:34 +0530[diff] [blame]7689
7690 if (backend_tag != NULL ) {
7691 if (backend_tag_table[device]) {
7692 free(backend_tag_table[device]);
7693 }
7694 backend_tag_table[device] = strdup(backend_tag);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7695 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7696
7697 if (hw_interface != NULL) {
7698 if (hw_interface_table[device])
7699 free(hw_interface_table[device]);
7700
7701 ALOGD("%s: hw_interface_table[%d] = %s", __func__, device, hw_interface);
7702 hw_interface_table[device] = strdup(hw_interface);
7703 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7704done:
7705 return ret;
7706}
7707
Naresh Tanniru6160c712017-04-17 15:43:48 +0530[diff] [blame]7708const char *platform_get_snd_device_backend_interface(snd_device_t device)
7709{
7710 const char *hw_interface_name = NULL;
7711
7712 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
7713 ALOGE("%s: Invalid snd_device = %d",
7714 __func__, device);
7715 goto done;
7716 }
7717
7718 /* Get string value of necessary backend for device */
7719 hw_interface_name = hw_interface_table[device];
7720 if (hw_interface_name == NULL)
7721 ALOGE("%s: no hw_interface set for device %d\n", __func__, device);
7722 else
7723 ALOGD("%s: hw_interface set for device %s\n", __func__, hw_interface_name);
7724done:
7725 return hw_interface_name;
7726}
7727
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]7728int platform_get_snd_device_backend_index(snd_device_t device)
7729{
7730 int i, be_dai_id;
7731 const char * hw_interface_name = NULL;
7732
7733 ALOGV("%s: enter with device %d\n", __func__, device);
7734
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]7735 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]7736 ALOGE("%s: Invalid snd_device = %d",
7737 __func__, device);
7738 be_dai_id = -EINVAL;
7739 goto done;
7740 }
7741
7742 /* Get string value of necessary backend for device */
7743 hw_interface_name = hw_interface_table[device];
7744 if (hw_interface_name == NULL) {
7745 ALOGE("%s: no hw_interface set for device %d\n", __func__, device);
7746 be_dai_id = -EINVAL;
7747 goto done;
7748 }
7749
7750 /* Check if be dai name table was retrieved successfully */
7751 if (be_dai_name_table == NULL) {
7752 ALOGE("%s: BE DAI Name Table is not present\n", __func__);
7753 be_dai_id = -EFAULT;
7754 goto done;
7755 }
7756
7757 /* Get backend ID for device specified */
7758 for (i = 0; i < max_be_dai_names; i++) {
7759 if (strcmp(hw_interface_name, be_dai_name_table[i].be_name) == 0) {
7760 be_dai_id = be_dai_name_table[i].be_id;
7761 goto done;
7762 }
7763 }
7764 ALOGE("%s: no interface matching name %s\n", __func__, hw_interface_name);
7765 be_dai_id = -EINVAL;
7766 goto done;
7767
7768done:
7769 return be_dai_id;
7770}
7771
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7772int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id)
7773{
7774 int ret = 0;
7775 if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {
7776 ALOGE("%s: invalid usecase case idx %d", __func__, usecase);
7777 ret = -EINVAL;
7778 goto done;
7779 }
7780
7781 if ((type != 0) && (type != 1)) {
7782 ALOGE("%s: invalid usecase type", __func__);
7783 ret = -EINVAL;
7784 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]7785 ALOGV("%s: pcm_device_table[%d][%d] = %d", __func__, usecase, type, pcm_id);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]7786 pcm_device_table[usecase][type] = pcm_id;
7787done:
7788 return ret;
7789}
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]7790
7791void platform_get_device_to_be_id_map(int **device_to_be_id, int *length)
7792{
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]7793 *device_to_be_id = (int*) msm_device_to_be_id;
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]7794 *length = msm_be_id_array_len;
7795}
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7796
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7797int platform_set_stream_pan_scale_params(void *platform,
7798 int snd_id,
7799 struct mix_matrix_params mm_params)
7800{
7801 struct platform_data *my_data = (struct platform_data *)platform;
7802 struct audio_device *adev = my_data->adev;
7803 struct mixer_ctl *ctl = NULL;
7804 char mixer_ctl_name[MIXER_PATH_MAX_LENGTH] = {0};
7805 int ret = 0;
7806 int iter_i = 0;
7807 int iter_j = 0;
7808 int length = 0;
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7809 char *pan_scale_data = NULL;
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7810
7811 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
7812 "Audio Stream %d Pan Scale Control", snd_id);
7813 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
7814
7815 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
7816 if (!ctl) {
7817 ALOGE("%s: Could not get ctl for mixer cmd - %s",
7818 __func__, mixer_ctl_name);
7819 ret = -EINVAL;
7820 goto end;
7821 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7822 pan_scale_data = (char *) calloc(1, sizeof(mm_params));
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]7823 if (!pan_scale_data) {
7824 ret = -ENOMEM;
7825 goto end;
7826 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7827 memcpy(&pan_scale_data[length], &mm_params.num_output_channels,
7828 sizeof(mm_params.num_output_channels));
7829 length += sizeof(mm_params.num_output_channels);
7830 memcpy(&pan_scale_data[length], &mm_params.num_input_channels,
7831 sizeof(mm_params.num_input_channels));
7832 length += sizeof(mm_params.num_input_channels);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7833
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7834 memcpy(&pan_scale_data[length], &mm_params.has_output_channel_map,
7835 sizeof(mm_params.has_output_channel_map));
7836 length += sizeof(mm_params.has_output_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7837 if (mm_params.has_output_channel_map &&
7838 mm_params.num_output_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7839 mm_params.num_output_channels > 0) {
7840 memcpy(&pan_scale_data[length], mm_params.output_channel_map,
7841 (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0])));
7842 length += (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0]));
7843 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7844 ret = -EINVAL;
7845 goto end;
7846 }
7847
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7848 memcpy(&pan_scale_data[length], &mm_params.has_input_channel_map,
7849 sizeof(mm_params.has_input_channel_map));
7850 length += sizeof(mm_params.has_input_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7851 if (mm_params.has_input_channel_map &&
7852 mm_params.num_input_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7853 mm_params.num_input_channels > 0) {
7854 memcpy(&pan_scale_data[length], mm_params.input_channel_map,
7855 (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0])));
7856 length += (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0]));
7857 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7858 ret = -EINVAL;
7859 goto end;
7860 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7861 pan_scale_data[length] = mm_params.has_mixer_coeffs;
7862 length += sizeof(mm_params.has_mixer_coeffs);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7863 if (mm_params.has_mixer_coeffs)
7864 for (iter_i = 0; iter_i < mm_params.num_output_channels; iter_i++)
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7865 for (iter_j = 0; iter_j < mm_params.num_input_channels; iter_j++) {
7866 memcpy(&pan_scale_data[length],
7867 &mm_params.mixer_coeffs[iter_i][iter_j],
7868 (sizeof(mm_params.mixer_coeffs[0][0])));
7869 length += (sizeof(mm_params.mixer_coeffs[0][0]));
7870 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7871
7872 ret = mixer_ctl_set_array(ctl, pan_scale_data, length);
7873end:
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]7874 if (pan_scale_data)
7875 free(pan_scale_data);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7876 return ret;
7877}
7878
7879int platform_set_stream_downmix_params(void *platform,
7880 int snd_id,
7881 snd_device_t snd_device,
7882 struct mix_matrix_params mm_params)
7883{
7884 struct platform_data *my_data = (struct platform_data *)platform;
7885 struct audio_device *adev = my_data->adev;
7886 struct mixer_ctl *ctl;
7887 char mixer_ctl_name[MIXER_PATH_MAX_LENGTH] = {0};
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7888 char *downmix_param_data = NULL;
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7889 int ret = 0;
7890 int iter_i = 0;
7891 int iter_j = 0;
7892 int length = 0;
7893 int be_idx = 0;
7894
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7895 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
7896 "Audio Device %d Downmix Control", snd_id);
7897 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
7898
7899 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
7900 if (!ctl) {
7901 ALOGE("%s: Could not get ctl for mixer cmd - %s",
7902 __func__, mixer_ctl_name);
7903 ret = -EINVAL;
7904 }
7905
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7906 downmix_param_data = (char *) calloc(1, sizeof(mm_params) + sizeof(be_idx));
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]7907 if (!downmix_param_data) {
7908 ret = -ENOMEM;
7909 goto end;
7910 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7911 be_idx = platform_get_snd_device_backend_index(snd_device);
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7912 memcpy(&downmix_param_data[length], &be_idx, sizeof(be_idx));
7913 length += sizeof(be_idx);
7914 memcpy(&downmix_param_data[length], &mm_params.num_output_channels,
7915 sizeof(mm_params.num_output_channels));
7916 length += sizeof(mm_params.num_output_channels);
7917 memcpy(&downmix_param_data[length], &mm_params.num_input_channels,
7918 sizeof(mm_params.num_input_channels));
7919 length += sizeof(mm_params.num_input_channels);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7920
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7921 memcpy(&downmix_param_data[length], &mm_params.has_output_channel_map,
7922 sizeof(mm_params.has_output_channel_map));
7923 length += sizeof(mm_params.has_output_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7924 if (mm_params.has_output_channel_map &&
7925 mm_params.num_output_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7926 mm_params.num_output_channels > 0) {
7927 memcpy(&downmix_param_data[length], mm_params.output_channel_map,
7928 (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0])));
7929 length += (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0]));
7930 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7931 ret = -EINVAL;
7932 goto end;
7933 }
7934
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7935 memcpy(&downmix_param_data[length], &mm_params.has_input_channel_map,
7936 sizeof(mm_params.has_input_channel_map));
7937 length += sizeof(mm_params.has_input_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7938 if (mm_params.has_input_channel_map &&
7939 mm_params.num_input_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7940 mm_params.num_input_channels > 0) {
7941 memcpy(&downmix_param_data[length], mm_params.input_channel_map,
7942 (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0])));
7943 length += (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0]));
7944 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7945 ret = -EINVAL;
7946 goto end;
7947 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7948 memcpy(&downmix_param_data[length], &mm_params.has_mixer_coeffs,
7949 sizeof(mm_params.has_mixer_coeffs));
7950 length += sizeof(mm_params.has_mixer_coeffs);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7951 if (mm_params.has_mixer_coeffs)
7952 for (iter_i = 0; iter_i < mm_params.num_output_channels; iter_i++)
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]7953 for (iter_j = 0; iter_j < mm_params.num_input_channels; iter_j++) {
7954 memcpy((uint32_t *) &downmix_param_data[length],
7955 &mm_params.mixer_coeffs[iter_i][iter_j],
7956 (sizeof(mm_params.mixer_coeffs[0][0])));
7957 length += (sizeof(mm_params.mixer_coeffs[0][0]));
7958 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7959
7960 ret = mixer_ctl_set_array(ctl, downmix_param_data, length);
7961end:
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]7962 if (downmix_param_data)
7963 free(downmix_param_data);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]7964 return ret;
7965}
7966
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7967int platform_set_stream_channel_map(void *platform, audio_channel_mask_t channel_mask,
7968 int snd_id, uint8_t *input_channel_map)
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]7969{
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7970 int ret = 0, i = 0;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]7971 int channels = audio_channel_count_from_out_mask(channel_mask);
7972
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7973 char channel_map[AUDIO_CHANNEL_COUNT_MAX];
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]7974 memset(channel_map, 0, sizeof(channel_map));
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7975 if (*input_channel_map) {
7976 for (i = 0; i < channels; i++) {
7977 ALOGV("%s:: Channel Map channel_map[%d] - %d", __func__, i, *input_channel_map);
7978 channel_map[i] = *input_channel_map;
7979 input_channel_map++;
7980 }
7981 } else {
7982 /* Following are all most common standard WAV channel layouts
7983 overridden by channel mask if its allowed and different */
7984 switch (channels) {
7985 case 1:
7986 /* AUDIO_CHANNEL_OUT_MONO */
7987 channel_map[0] = PCM_CHANNEL_FC;
7988 break;
7989 case 2:
7990 /* AUDIO_CHANNEL_OUT_STEREO */
7991 channel_map[0] = PCM_CHANNEL_FL;
7992 channel_map[1] = PCM_CHANNEL_FR;
7993 break;
7994 case 3:
7995 /* AUDIO_CHANNEL_OUT_2POINT1 */
7996 channel_map[0] = PCM_CHANNEL_FL;
7997 channel_map[1] = PCM_CHANNEL_FR;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]7998 channel_map[2] = PCM_CHANNEL_FC;
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]7999 break;
8000 case 4:
8001 /* AUDIO_CHANNEL_OUT_QUAD_SIDE */
8002 channel_map[0] = PCM_CHANNEL_FL;
8003 channel_map[1] = PCM_CHANNEL_FR;
8004 channel_map[2] = PCM_CHANNEL_LS;
8005 channel_map[3] = PCM_CHANNEL_RS;
8006 if (channel_mask == AUDIO_CHANNEL_OUT_QUAD_BACK) {
8007 channel_map[2] = PCM_CHANNEL_LB;
8008 channel_map[3] = PCM_CHANNEL_RB;
8009 }
8010 if (channel_mask == AUDIO_CHANNEL_OUT_SURROUND) {
8011 channel_map[2] = PCM_CHANNEL_FC;
8012 channel_map[3] = PCM_CHANNEL_CS;
8013 }
8014 break;
8015 case 5:
8016 /* AUDIO_CHANNEL_OUT_PENTA */
8017 channel_map[0] = PCM_CHANNEL_FL;
8018 channel_map[1] = PCM_CHANNEL_FR;
8019 channel_map[2] = PCM_CHANNEL_FC;
8020 channel_map[3] = PCM_CHANNEL_LB;
8021 channel_map[4] = PCM_CHANNEL_RB;
8022 break;
8023 case 6:
8024 /* AUDIO_CHANNEL_OUT_5POINT1 */
8025 channel_map[0] = PCM_CHANNEL_FL;
8026 channel_map[1] = PCM_CHANNEL_FR;
8027 channel_map[2] = PCM_CHANNEL_FC;
8028 channel_map[3] = PCM_CHANNEL_LFE;
8029 channel_map[4] = PCM_CHANNEL_LB;
8030 channel_map[5] = PCM_CHANNEL_RB;
8031 if (channel_mask == AUDIO_CHANNEL_OUT_5POINT1_SIDE) {
8032 channel_map[4] = PCM_CHANNEL_LS;
8033 channel_map[5] = PCM_CHANNEL_RS;
8034 }
8035 break;
8036 case 7:
8037 /* AUDIO_CHANNEL_OUT_6POINT1 */
8038 channel_map[0] = PCM_CHANNEL_FL;
8039 channel_map[1] = PCM_CHANNEL_FR;
8040 channel_map[2] = PCM_CHANNEL_FC;
8041 channel_map[3] = PCM_CHANNEL_LFE;
8042 channel_map[4] = PCM_CHANNEL_LB;
8043 channel_map[5] = PCM_CHANNEL_RB;
8044 channel_map[6] = PCM_CHANNEL_CS;
8045 break;
8046 case 8:
8047 /* AUDIO_CHANNEL_OUT_7POINT1 */
8048 channel_map[0] = PCM_CHANNEL_FL;
8049 channel_map[1] = PCM_CHANNEL_FR;
8050 channel_map[2] = PCM_CHANNEL_FC;
8051 channel_map[3] = PCM_CHANNEL_LFE;
8052 channel_map[4] = PCM_CHANNEL_LB;
8053 channel_map[5] = PCM_CHANNEL_RB;
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]8054 if (channel_mask == AUDIO_CHANNEL_OUT_5POINT1POINT2) {
8055 channel_map[6] = PCM_CHANNEL_TFL;
8056 channel_map[7] = PCM_CHANNEL_TFR;
8057 } else {
8058 channel_map[6] = PCM_CHANNEL_LS;
8059 channel_map[7] = PCM_CHANNEL_RS;
8060 }
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]8061 break;
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8062 case 12:
8063 /* AUDIO_CHANNEL_OUT_7POINT1POINT4 */
8064 channel_map[0] = PCM_CHANNEL_FL;
8065 channel_map[1] = PCM_CHANNEL_FR;
8066 channel_map[2] = PCM_CHANNEL_FC;
8067 channel_map[3] = PCM_CHANNEL_LFE;
8068 channel_map[4] = PCM_CHANNEL_LB;
8069 channel_map[5] = PCM_CHANNEL_RB;
8070 channel_map[6] = PCM_CHANNEL_LS;
8071 channel_map[7] = PCM_CHANNEL_RS;
8072 channel_map[8] = PCM_CHANNEL_TFL;
8073 channel_map[9] = PCM_CHANNEL_TFR;
8074 channel_map[10] = PCM_CHANNEL_TSL;
8075 channel_map[11] = PCM_CHANNEL_TSR;
8076 break;
8077 case 16:
8078 /* 16 channels */
8079 channel_map[0] = PCM_CHANNEL_FL;
8080 channel_map[1] = PCM_CHANNEL_FR;
8081 channel_map[2] = PCM_CHANNEL_FC;
8082 channel_map[3] = PCM_CHANNEL_LFE;
8083 channel_map[4] = PCM_CHANNEL_LB;
8084 channel_map[5] = PCM_CHANNEL_RB;
8085 channel_map[6] = PCM_CHANNEL_LS;
8086 channel_map[7] = PCM_CHANNEL_RS;
8087 channel_map[8] = PCM_CHANNEL_TFL;
8088 channel_map[9] = PCM_CHANNEL_TFR;
8089 channel_map[10] = PCM_CHANNEL_TSL;
8090 channel_map[11] = PCM_CHANNEL_TSR;
8091 channel_map[12] = PCM_CHANNEL_FLC;
8092 channel_map[13] = PCM_CHANNEL_FRC;
8093 channel_map[14] = PCM_CHANNEL_RLC;
8094 channel_map[15] = PCM_CHANNEL_RRC;
8095 break;
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]8096 default:
8097 ALOGE("unsupported channels %d for setting channel map", channels);
8098 return -1;
8099 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8100 }
8101 ret = platform_set_channel_map(platform, channels, channel_map, snd_id);
8102 return ret;
8103}
8104
8105int platform_get_edid_info(void *platform)
8106{
8107 struct platform_data *my_data = (struct platform_data *)platform;
8108 struct audio_device *adev = my_data->adev;
8109 char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE];
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]8110 int ret, count;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8111 char *mix_ctl_name;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8112 struct mixer_ctl *ctl;
8113 char edid_data[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE + 1] = {0};
8114 edid_audio_info *info;
8115
8116 if (my_data->edid_valid) {
8117 /* use cached edid */
8118 return 0;
8119 }
8120
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8121 switch(my_data->ext_disp_type) {
8122 case EXT_DISPLAY_TYPE_HDMI:
8123 mix_ctl_name = "HDMI EDID";
8124 break;
8125 case EXT_DISPLAY_TYPE_DP:
8126 mix_ctl_name = "Display Port EDID";
8127 break;
8128 default:
8129 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
8130 return -EINVAL;
8131 }
8132
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8133 if (my_data->edid_info == NULL) {
8134 my_data->edid_info =
8135 (struct edid_audio_info *)calloc(1, sizeof(struct edid_audio_info));
8136 }
8137
8138 info = my_data->edid_info;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8139 ctl = mixer_get_ctl_by_name(adev->mixer, mix_ctl_name);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8140 if (!ctl) {
8141 ALOGE("%s: Could not get ctl for mixer cmd - %s",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8142 __func__, mix_ctl_name);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8143 goto fail;
8144 }
8145
8146 mixer_ctl_update(ctl);
8147
8148 count = mixer_ctl_get_num_values(ctl);
8149
8150 /* Read SAD blocks, clamping the maximum size for safety */
8151 if (count > (int)sizeof(block))
8152 count = (int)sizeof(block);
8153
8154 ret = mixer_ctl_get_array(ctl, block, count);
8155 if (ret != 0) {
8156 ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__);
8157 goto fail;
8158 }
8159 edid_data[0] = count;
8160 memcpy(&edid_data[1], block, count);
8161
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]8162 if (!audio_extn_edid_get_sink_caps(info, edid_data)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8163 ALOGE("%s: Failed to get extn disp sink capabilities", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8164 goto fail;
8165 }
8166 my_data->edid_valid = true;
8167 return 0;
8168fail:
8169 if (my_data->edid_info) {
8170 free(my_data->edid_info);
8171 my_data->edid_info = NULL;
8172 my_data->edid_valid = false;
8173 }
8174 ALOGE("%s: return -EINVAL", __func__);
8175 return -EINVAL;
8176}
8177
8178
8179int platform_set_channel_allocation(void *platform, int channel_alloc)
8180{
8181 struct mixer_ctl *ctl;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8182 char *mixer_ctl_name;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8183 int ret;
8184 struct platform_data *my_data = (struct platform_data *)platform;
8185 struct audio_device *adev = my_data->adev;
8186
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8187 switch(my_data->ext_disp_type) {
8188 case EXT_DISPLAY_TYPE_HDMI:
8189 mixer_ctl_name = "HDMI RX CA";
8190 break;
8191 case EXT_DISPLAY_TYPE_DP:
8192 mixer_ctl_name = "Display Port RX CA";
8193 break;
8194 default:
8195 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
8196 return -EINVAL;
8197 }
8198
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8199 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
8200 if (!ctl) {
8201 ALOGE("%s: Could not get ctl for mixer cmd - %s",
8202 __func__, mixer_ctl_name);
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8203 return -EINVAL;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8204 }
8205 ALOGD(":%s channel allocation = 0x%x", __func__, channel_alloc);
8206 ret = mixer_ctl_set_value(ctl, 0, channel_alloc);
8207
8208 if (ret < 0) {
8209 ALOGE("%s: Could not set ctl, error:%d ", __func__, ret);
8210 }
8211
8212 return ret;
8213}
8214
8215int platform_set_channel_map(void *platform, int ch_count, char *ch_map, int snd_id)
8216{
8217 struct mixer_ctl *ctl;
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -0800[diff] [blame]8218 char mixer_ctl_name[44] = {0}; // max length of name is 44 as defined
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8219 int ret;
Ramu Gottipati02809682018-12-19 16:46:12 +0530[diff] [blame]8220 int i=0, n=0;
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8221 long set_values[AUDIO_MAX_DSP_CHANNELS];
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8222 struct platform_data *my_data = (struct platform_data *)platform;
8223 struct audio_device *adev = my_data->adev;
8224 ALOGV("%s channel_count:%d",__func__, ch_count);
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8225
8226 /*
8227 * FIXME:
8228 * Currently the channel mask in audio.h is limited to 30 channels,
8229 * (=AUDIO_CHANNEL_COUNT_MAX), whereas the mixer controls already
8230 * allow up to AUDIO_MAX_DSP_CHANNELS channels as per final requirement.
8231 * Until channel mask definition is not changed from a uint32_t value
8232 * to something else, a sanity check is needed here.
8233 */
8234 if (NULL == ch_map || (ch_count < 1) || (ch_count > AUDIO_CHANNEL_COUNT_MAX)) {
Divya Narayanan Poojary21de6aa2017-01-06 12:07:19 +0530[diff] [blame]8235 ALOGE("%s: Invalid channel mapping or channel count value", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8236 return -EINVAL;
8237 }
Fred Ohe0479682015-03-25 16:30:26 -0700[diff] [blame]8238
8239 /*
8240 * If snd_id is greater than 0, stream channel mapping
8241 * If snd_id is below 0, typically -1, device channel mapping
8242 */
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8243 if (snd_id >= 0) {
Fred Ohe0479682015-03-25 16:30:26 -0700[diff] [blame]8244 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Playback Channel Map%d", snd_id);
8245 } else {
8246 strlcpy(mixer_ctl_name, "Playback Device Channel Map", sizeof(mixer_ctl_name));
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8247 }
8248
8249 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
8250
8251 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8252
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8253 if (!ctl) {
8254 ALOGE("%s: Could not get ctl for mixer cmd - %s",
8255 __func__, mixer_ctl_name);
8256 return -EINVAL;
8257 }
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8258
8259 /* find out how many values the control can set */
8260 n = mixer_ctl_get_num_values(ctl);
8261
8262 if (n != ch_count)
8263 ALOGV("%s chcnt %d != mixerctl elem size %d",__func__, ch_count, n);
8264
8265 if (n < ch_count) {
8266 ALOGE("%s chcnt %d > mixerctl elem size %d",__func__, ch_count, n);
8267 return -EINVAL;
8268 }
8269
8270 if (n > AUDIO_MAX_DSP_CHANNELS) {
8271 ALOGE("%s mixerctl elem size %d > AUDIO_MAX_DSP_CHANNELS %d",__func__, n, AUDIO_MAX_DSP_CHANNELS);
8272 return -EINVAL;
8273 }
8274
8275 /* initialize all set_values to zero */
8276 memset (set_values, 0, sizeof(set_values));
8277
8278 /* copy only as many values as corresponding mixer_ctrl allows */
8279 for (i = 0; i < ch_count; i++) {
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8280 set_values[i] = ch_map[i];
8281 }
8282
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]8283 ALOGD("%s: set mapping(%ld %ld %ld %ld %ld %ld %ld %ld) for channel:%d", __func__,
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8284 set_values[0], set_values[1], set_values[2], set_values[3], set_values[4],
8285 set_values[5], set_values[6], set_values[7], ch_count);
8286
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8287 ret = mixer_ctl_set_array(ctl, set_values, n);
8288
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8289 if (ret < 0) {
8290 ALOGE("%s: Could not set ctl, error:%d ch_count:%d",
8291 __func__, ret, ch_count);
8292 }
8293 return ret;
8294}
8295
8296unsigned char platform_map_to_edid_format(int audio_format)
8297{
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8298 unsigned char format;
8299 switch (audio_format & AUDIO_FORMAT_MAIN_MASK) {
8300 case AUDIO_FORMAT_AC3:
8301 ALOGV("%s: AC3", __func__);
8302 format = AC3;
8303 break;
8304 case AUDIO_FORMAT_AAC:
8305 ALOGV("%s:AAC", __func__);
8306 format = AAC;
8307 break;
Manish Dewangana6fc5442015-08-24 20:30:31 +0530[diff] [blame]8308 case AUDIO_FORMAT_AAC_ADTS:
8309 ALOGV("%s:AAC_ADTS", __func__);
8310 format = AAC;
8311 break;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8312 case AUDIO_FORMAT_E_AC3:
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +0530[diff] [blame]8313 case AUDIO_FORMAT_E_AC3_JOC:
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8314 ALOGV("%s:E_AC3", __func__);
8315 format = DOLBY_DIGITAL_PLUS;
8316 break;
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]8317 case AUDIO_FORMAT_DOLBY_TRUEHD:
8318 ALOGV("%s:MAT", __func__);
8319 format = MAT;
8320 break;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8321 case AUDIO_FORMAT_DTS:
8322 ALOGV("%s:DTS", __func__);
8323 format = DTS;
8324 break;
8325 case AUDIO_FORMAT_DTS_HD:
8326 ALOGV("%s:DTS_HD", __func__);
8327 format = DTS_HD;
8328 break;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8329 case AUDIO_FORMAT_PCM_16_BIT:
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]8330 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
8331 case AUDIO_FORMAT_PCM_8_24_BIT:
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8332 ALOGV("%s:PCM", __func__);
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8333 format = LPCM;
8334 break;
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]8335 case AUDIO_FORMAT_IEC61937:
8336 ALOGV("%s:IEC61937", __func__);
8337 format = 0;
8338 break;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8339 default:
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8340 format = -1;
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]8341 ALOGE("%s:invalid format: 0x%x", __func__, audio_format);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8342 break;
8343 }
8344 return format;
8345}
8346
Ashish Jaina052e572016-11-07 16:41:07 +0530[diff] [blame]8347void platform_check_and_update_copp_sample_rate(void* platform, snd_device_t snd_device,
8348 unsigned int stream_sr, int* sample_rate)
8349{
8350 struct platform_data* my_data = (struct platform_data *)platform;
8351 int backend_idx = platform_get_backend_index(snd_device);
8352 int device_sr = my_data->current_backend_cfg[backend_idx].sample_rate;
8353 /*
8354 *Check if device SR is multiple of 8K or 11.025 Khz
8355 *check if the stream SR is multiple of same base, if yes
8356 *then have copp SR equal to stream SR, this ensures that
8357 *post processing happens at stream SR, else have
8358 *copp SR equal to device SR.
8359 */
8360 if (!(((sample_rate_multiple(device_sr, SAMPLE_RATE_8000)) &&
8361 (sample_rate_multiple(stream_sr, SAMPLE_RATE_8000))) ||
8362 ((sample_rate_multiple(device_sr, SAMPLE_RATE_11025)) &&
8363 (sample_rate_multiple(stream_sr, SAMPLE_RATE_11025))))) {
8364 *sample_rate = device_sr;
8365 } else
8366 *sample_rate = stream_sr;
8367
Revathi Uddaraju0553e8f2017-11-30 14:56:11 +0530[diff] [blame]8368 if ((snd_device == SND_DEVICE_OUT_HDMI) || (snd_device == SND_DEVICE_OUT_DISPLAY_PORT) ||
8369 (snd_device == SND_DEVICE_OUT_USB_HEADSET))
8370 *sample_rate = platform_get_supported_copp_sampling_rate(stream_sr);
Venugopal Nadipalli83134582017-09-21 22:34:50 +0530[diff] [blame]8371
8372 ALOGI("sn_device %d device sr %d stream sr %d copp sr %d", snd_device, device_sr, stream_sr, *sample_rate);
Ashish Jaina052e572016-11-07 16:41:07 +0530[diff] [blame]8373
8374}
8375
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]8376// called from info parser
8377void platform_add_app_type(const char *uc_type,
8378 const char *mode,
8379 int bw,
8380 int app_type, int max_rate) {
8381 struct app_type_entry *ap =
8382 (struct app_type_entry *)calloc(1, sizeof(struct app_type_entry));
8383
8384 if (!ap) {
8385 ALOGE("%s failed to allocate mem for app type", __func__);
8386 return;
8387 }
8388
8389 ap->uc_type = -1;
8390 for (int i=0; i<USECASE_TYPE_MAX; i++) {
8391 if (!strcmp(uc_type, usecase_type_index[i].name)) {
8392 ap->uc_type = usecase_type_index[i].index;
8393 break;
8394 }
8395 }
8396
8397 if (ap->uc_type == -1) {
8398 free(ap);
8399 return;
8400 }
8401
8402 ALOGI("%s uc %s mode %s bw %d app_type %d max_rate %d",
8403 __func__, uc_type, mode, bw, app_type, max_rate);
8404 ap->bit_width = bw;
8405 ap->app_type = app_type;
8406 ap->max_rate = max_rate;
8407 ap->mode = strdup(mode);
8408 list_add_tail(&app_type_entry_list, &ap->node);
8409}
8410
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8411void platform_reset_edid_info(void *platform) {
8412
8413 ALOGV("%s:", __func__);
8414 struct platform_data *my_data = (struct platform_data *)platform;
8415 if (my_data->edid_info) {
8416 ALOGV("%s :free edid", __func__);
8417 free(my_data->edid_info);
8418 my_data->edid_info = NULL;
8419 }
8420}
8421
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8422bool platform_is_edid_supported_format(void *platform, int format)
8423{
8424 struct platform_data *my_data = (struct platform_data *)platform;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8425 edid_audio_info *info = NULL;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]8426 int i, ret;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8427 unsigned char format_id = platform_map_to_edid_format(format);
8428
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]8429 if (format == AUDIO_FORMAT_IEC61937)
8430 return true;
8431
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8432 if (format_id <= 0) {
8433 ALOGE("%s invalid edid format mappting for :%x" ,__func__, format);
8434 return false;
8435 }
8436
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8437 ret = platform_get_edid_info(platform);
8438 info = (edid_audio_info *)my_data->edid_info;
8439 if (ret == 0 && info != NULL) {
8440 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8441 /*
8442 * To check
8443 * is there any special for CONFIG_HDMI_PASSTHROUGH_CONVERT
8444 * & DOLBY_DIGITAL_PLUS
8445 */
8446 if (info->audio_blocks_array[i].format_id == format_id) {
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8447 ALOGV("%s:returns true %x",
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8448 __func__, format);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8449 return true;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8450 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8451 }
8452 }
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8453 ALOGV("%s:returns false %x",
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8454 __func__, format);
8455 return false;
8456}
8457
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8458bool platform_is_edid_supported_sample_rate(void *platform, int sample_rate)
8459{
8460 struct platform_data *my_data = (struct platform_data *)platform;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8461 edid_audio_info *info = NULL;
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]8462 int ret = 0;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8463
8464 ret = platform_get_edid_info(platform);
8465 info = (edid_audio_info *)my_data->edid_info;
8466 if (ret == 0 && info != NULL) {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]8467 return audio_extn_edid_is_supported_sr(info, sample_rate);
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8468 }
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8469
8470 return false;
8471}
8472
Naresh Tanniru3a406772017-05-10 13:09:05 -0700[diff] [blame]8473int platform_edid_get_highest_supported_sr(void *platform)
8474{
8475 struct platform_data *my_data = (struct platform_data *)platform;
8476 edid_audio_info *info = NULL;
8477 int ret = 0;
8478
8479 ret = platform_get_edid_info(platform);
8480 info = (edid_audio_info *)my_data->edid_info;
8481 if (ret == 0 && info != NULL) {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]8482 return audio_extn_edid_get_highest_supported_sr(info);
Naresh Tanniru3a406772017-05-10 13:09:05 -0700[diff] [blame]8483 }
8484
8485 return 0;
8486}
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]8487
Dieter Luecking5d57def2018-09-07 14:23:37 +0200[diff] [blame]8488bool platform_spkr_use_default_sample_rate(void *platform) {
8489 struct platform_data *my_data = (struct platform_data *)platform;
8490 return my_data->use_sprk_default_sample_rate;
8491}
8492
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]8493int platform_set_edid_channels_configuration(void *platform, int channels, int backend_idx) {
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8494
8495 struct platform_data *my_data = (struct platform_data *)platform;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]8496 struct audio_device *adev = my_data->adev;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8497 edid_audio_info *info = NULL;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8498 int channel_count = 2;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]8499 int i, ret;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8500 char default_channelMap[MAX_CHANNELS_SUPPORTED] = {0};
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]8501 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8502
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]8503 if ((backend_idx != HDMI_RX_BACKEND) &&
8504 (backend_idx != DISP_PORT_RX_BACKEND)) {
8505 ALOGE("%s: Invalid backend idx %d", __func__, backend_idx);
8506 return -EINVAL;
8507 }
8508
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8509 ret = platform_get_edid_info(platform);
8510 info = (edid_audio_info *)my_data->edid_info;
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]8511 adev_device_cfg_ptr += backend_idx;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8512 if(ret == 0 && info != NULL) {
8513 if (channels > 2) {
Weiyin Jiangff72f812018-04-13 15:02:33 +0800[diff] [blame]8514 ALOGV("%s:able to get HDMI/DP sink capabilities multi channel playback",
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8515 __func__);
8516 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
8517 if (info->audio_blocks_array[i].format_id == LPCM &&
8518 info->audio_blocks_array[i].channels > channel_count &&
8519 info->audio_blocks_array[i].channels <= MAX_HDMI_CHANNEL_CNT) {
8520 channel_count = info->audio_blocks_array[i].channels;
8521 }
8522 }
8523 ALOGVV("%s:channel_count:%d", __func__, channel_count);
8524 /*
8525 * Channel map is set for supported hdmi max channel count even
8526 * though the input channel count set on adm is less than or equal to
8527 * max supported channel count
8528 */
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]8529 if (adev_device_cfg_ptr->use_client_dev_cfg) {
8530 platform_set_channel_map(platform, adev_device_cfg_ptr->dev_cfg_params.channels,
8531 (char *)adev_device_cfg_ptr->dev_cfg_params.channel_map, -1);
8532 } else {
8533 platform_set_channel_map(platform, channel_count, info->channel_map, -1);
8534 }
8535
8536 if (adev_device_cfg_ptr->use_client_dev_cfg) {
8537 ALOGV("%s:: Setting client selected CA %d", __func__,
8538 adev_device_cfg_ptr->dev_cfg_params.channel_allocation);
8539 platform_set_channel_allocation(platform,
8540 adev_device_cfg_ptr->dev_cfg_params.channel_allocation);
8541 } else {
8542 platform_set_channel_allocation(platform, info->channel_allocation);
8543 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8544 } else {
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]8545 if (adev_device_cfg_ptr->use_client_dev_cfg) {
8546 default_channelMap[0] = adev_device_cfg_ptr->dev_cfg_params.channel_map[0];
8547 default_channelMap[1] = adev_device_cfg_ptr->dev_cfg_params.channel_map[1];
8548 } else {
8549 default_channelMap[0] = PCM_CHANNEL_FL;
8550 default_channelMap[1] = PCM_CHANNEL_FR;
8551 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8552 platform_set_channel_map(platform,2,default_channelMap,-1);
8553 platform_set_channel_allocation(platform,0);
8554 }
8555 }
8556
8557 return 0;
8558}
8559
8560void platform_cache_edid(void * platform)
8561{
8562 platform_get_edid_info(platform);
8563}
8564
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]8565void platform_invalidate_backend_config(void * platform,snd_device_t snd_device)
8566{
8567 struct platform_data *my_data = (struct platform_data *)platform;
8568 struct audio_device *adev = my_data->adev;
8569 struct audio_backend_cfg backend_cfg;
8570 int backend_idx;
8571
8572 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
8573 backend_cfg.channels = CODEC_BACKEND_DEFAULT_CHANNELS;
8574 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
8575 backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
8576 backend_cfg.passthrough_enabled = false;
8577
8578 backend_idx = platform_get_backend_index(snd_device);
8579 platform_set_codec_backend_cfg(adev, snd_device, backend_cfg);
8580 my_data->current_backend_cfg[backend_idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
8581 my_data->current_backend_cfg[backend_idx].channels = CODEC_BACKEND_DEFAULT_CHANNELS;
8582 my_data->current_backend_cfg[backend_idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
8583 my_data->current_backend_cfg[backend_idx].format = AUDIO_FORMAT_PCM_16_BIT;
8584}
8585
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]8586void platform_invalidate_hdmi_config(void * platform)
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8587{
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8588 //reset ext display EDID info
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8589 struct platform_data *my_data = (struct platform_data *)platform;
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]8590 struct audio_device *adev = my_data->adev;
8591 struct audio_backend_cfg backend_cfg;
8592 int backend_idx;
8593 snd_device_t snd_device;
8594
8595 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
8596 backend_cfg.channels = DEFAULT_HDMI_OUT_CHANNELS;
8597 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
8598 backend_cfg.format = 0;
8599 backend_cfg.passthrough_enabled = false;
8600
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8601 my_data->edid_valid = false;
8602 if (my_data->edid_info) {
8603 memset(my_data->edid_info, 0, sizeof(struct edid_audio_info));
8604 }
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]8605
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8606 if (my_data->ext_disp_type == EXT_DISPLAY_TYPE_HDMI) {
8607 //reset HDMI_RX_BACKEND to default values
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]8608 backend_idx = HDMI_RX_BACKEND;
8609 snd_device = SND_DEVICE_OUT_HDMI;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8610 } else {
8611 //reset Display port BACKEND to default values
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]8612 backend_idx = DISP_PORT_RX_BACKEND;
8613 snd_device = SND_DEVICE_OUT_DISPLAY_PORT;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8614 }
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]8615 platform_set_codec_backend_cfg(adev, snd_device, backend_cfg);
8616 my_data->current_backend_cfg[backend_idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
8617 my_data->current_backend_cfg[backend_idx].channels = DEFAULT_HDMI_OUT_CHANNELS;
8618 my_data->current_backend_cfg[backend_idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]8619 my_data->ext_disp_type = EXT_DISPLAY_TYPE_NONE;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]8620}
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8621
8622int platform_set_mixer_control(struct stream_out *out, const char * mixer_ctl_name,
8623 const char *mixer_val)
8624{
8625 struct audio_device *adev = out->dev;
8626 struct mixer_ctl *ctl = NULL;
8627 ALOGD("setting mixer ctl %s with value %s", mixer_ctl_name, mixer_val);
8628 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
8629 if (!ctl) {
8630 ALOGE("%s: could not get ctl for mixer cmd - %s",
8631 __func__, mixer_ctl_name);
8632 return -EINVAL;
8633 }
8634
8635 return mixer_ctl_set_enum_by_string(ctl, mixer_val);
8636}
8637
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8638int platform_set_device_params(struct stream_out *out, int param, int value)
8639{
8640 struct audio_device *adev = out->dev;
8641 struct mixer_ctl *ctl;
8642 char *mixer_ctl_name = "Device PP Params";
8643 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]8644 long set_values[] = {0,0};
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]8645
8646 set_values[0] = param;
8647 set_values[1] = value;
8648
8649 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
8650 if (!ctl) {
8651 ALOGE("%s: Could not get ctl for mixer cmd - %s",
8652 __func__, mixer_ctl_name);
8653 ret = -EINVAL;
8654 goto end;
8655 }
8656
8657 ALOGV("%s: Setting device pp params param: %d, value %d mixer ctrl:%s",
8658 __func__,param, value, mixer_ctl_name);
8659 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
8660
8661end:
8662 return ret;
8663}
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]8664
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8665bool platform_can_enable_spkr_prot_on_device(snd_device_t snd_device)
8666{
8667 bool ret = false;
8668
8669 if (snd_device == SND_DEVICE_OUT_SPEAKER ||
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]8670 snd_device == SND_DEVICE_OUT_SPEAKER_REVERSE ||
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8671 snd_device == SND_DEVICE_OUT_SPEAKER_VBAT ||
8672 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8673 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT ||
8674 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
8675 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2) {
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8676 ret = true;
8677 }
8678
8679 return ret;
8680}
8681
8682int platform_get_spkr_prot_acdb_id(snd_device_t snd_device)
8683{
8684 int acdb_id;
8685
8686 switch(snd_device) {
8687 case SND_DEVICE_OUT_SPEAKER:
8688 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED);
8689 break;
8690 case SND_DEVICE_OUT_VOICE_SPEAKER:
8691 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED);
8692 break;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8693 case SND_DEVICE_OUT_VOICE_SPEAKER_2:
8694 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED);
8695 break;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]8696 case SND_DEVICE_OUT_VOICE_SPEAKER_STEREO:
8697 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED);
8698 break;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8699 case SND_DEVICE_OUT_SPEAKER_VBAT:
8700 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
8701 break;
8702 case SND_DEVICE_OUT_VOICE_SPEAKER_VBAT:
8703 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT);
8704 break;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8705 case SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT:
8706 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT);
8707 break;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8708 default:
8709 acdb_id = -EINVAL;
8710 break;
8711 }
8712 return acdb_id;
8713}
8714
8715int platform_get_spkr_prot_snd_device(snd_device_t snd_device)
8716{
8717 if (!audio_extn_spkr_prot_is_enabled())
8718 return snd_device;
8719
8720 switch(snd_device) {
8721 case SND_DEVICE_OUT_SPEAKER:
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]8722 case SND_DEVICE_OUT_SPEAKER_REVERSE:
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8723 return SND_DEVICE_OUT_SPEAKER_PROTECTED;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]8724 case SND_DEVICE_OUT_SPEAKER_SAFE:
8725 return SND_DEVICE_OUT_SPEAKER_SAFE;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8726 case SND_DEVICE_OUT_VOICE_SPEAKER:
8727 return SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8728 case SND_DEVICE_OUT_VOICE_SPEAKER_2:
8729 return SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED;
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]8730 case SND_DEVICE_OUT_VOICE_SPEAKER_STEREO:
8731 return SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8732 case SND_DEVICE_OUT_SPEAKER_VBAT:
8733 return SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT;
8734 case SND_DEVICE_OUT_VOICE_SPEAKER_VBAT:
8735 return SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8736 case SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT:
8737 return SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8738 default:
8739 return snd_device;
8740 }
8741}
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8742int platform_get_vi_feedback_snd_device(snd_device_t snd_device)
8743{
8744 switch(snd_device) {
8745 case SND_DEVICE_OUT_SPEAKER_PROTECTED:
8746 case SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT:
Vikram Panduranga8c68e862018-04-27 12:59:42 -0700[diff] [blame]8747 case SND_DEVICE_OUT_VOICE_SPEAKER_STEREO_PROTECTED:
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]8748 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK;
8749 case SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED:
8750 case SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT:
8751 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1;
8752 case SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED:
8753 case SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT:
8754 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2;
8755 default:
8756 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK;
8757 }
8758}
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]8759
Venkata Narendra Kumar Gutta7f4817f2016-01-29 14:15:53 +0530[diff] [blame]8760int platform_spkr_prot_is_wsa_analog_mode(void *adev __unused)
8761{
8762 return 0;
8763}
8764
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]8765/*
8766 * This is a lookup table to map android audio input device to audio h/w interface (backend).
8767 * The table can be extended for other input devices by adding appropriate entries.
8768 * Also the audio interface for a particular input device can be overriden by adding
8769 * corresponding entry in audio_platform_info.xml file.
8770 */
8771struct audio_device_to_audio_interface audio_device_to_interface_table[] = {
8772 {AUDIO_DEVICE_IN_BUILTIN_MIC, ENUM_TO_STRING(AUDIO_DEVICE_IN_BUILTIN_MIC), "SLIMBUS_0"},
8773 {AUDIO_DEVICE_IN_BACK_MIC, ENUM_TO_STRING(AUDIO_DEVICE_IN_BACK_MIC), "SLIMBUS_0"},
8774};
8775
8776int audio_device_to_interface_table_len =
8777 sizeof(audio_device_to_interface_table) / sizeof(audio_device_to_interface_table[0]);
8778
Karthik Reddy Katta508eca42015-05-11 13:43:18 +0530[diff] [blame]8779int platform_set_audio_device_interface(const char *device_name, const char *intf_name,
8780 const char *codec_type __unused)
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]8781{
8782 int ret = 0;
8783 int i;
8784
8785 if (device_name == NULL || intf_name == NULL) {
8786 ALOGE("%s: Invalid input", __func__);
8787
8788 ret = -EINVAL;
8789 goto done;
8790 }
8791
8792 ALOGD("%s: Enter, device name:%s, intf name:%s", __func__, device_name, intf_name);
8793
8794 size_t device_name_len = strlen(device_name);
8795 for (i = 0; i < audio_device_to_interface_table_len; i++) {
8796 char* name = audio_device_to_interface_table[i].device_name;
8797 size_t name_len = strlen(name);
8798 if ((name_len == device_name_len) &&
8799 (strncmp(device_name, name, name_len) == 0)) {
8800 ALOGD("%s: Matched device name:%s, overwrite intf name with %s",
8801 __func__, device_name, intf_name);
8802
8803 strlcpy(audio_device_to_interface_table[i].interface_name, intf_name,
8804 sizeof(audio_device_to_interface_table[i].interface_name));
8805 goto done;
8806 }
8807 }
8808 ALOGE("%s: Could not find matching device name %s",
8809 __func__, device_name);
8810
8811 ret = -EINVAL;
8812
8813done:
8814 return ret;
8815}
Laxminath Kasam44f49402015-05-29 18:37:11 +0530[diff] [blame]8816
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]8817int platform_set_sidetone(struct audio_device *adev,
8818 snd_device_t out_snd_device,
8819 bool enable,
8820 char *str)
8821{
8822 int ret;
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]8823 if ((out_snd_device == SND_DEVICE_OUT_USB_HEADSET) ||
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]8824 (out_snd_device == SND_DEVICE_OUT_USB_HEADPHONES) ||
8825 (out_snd_device == SND_DEVICE_OUT_VOICE_USB_HEADSET)) {
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]8826 if (property_get_bool("vendor.audio.usb.disable.sidetone", 0)) {
Haynes Mathew George492a6c42016-10-28 11:41:43 -0700[diff] [blame]8827 ALOGI("Debug: Disable sidetone");
8828 } else {
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]8829 ret = audio_extn_usb_enable_sidetone(out_snd_device, enable);
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]8830 if (ret) {
8831 /*fall back to AFE sidetone*/
8832 ALOGV("%s: No USB sidetone supported, switching to AFE sidetone",
8833 __func__);
8834
8835 if (enable)
8836 audio_route_apply_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
8837 else
8838 audio_route_reset_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
8839 }
Haynes Mathew George492a6c42016-10-28 11:41:43 -0700[diff] [blame]8840 }
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]8841 } else {
8842 ALOGV("%s: sidetone out device(%d) mixer cmd = %s\n",
8843 __func__, out_snd_device, str);
Laxminath Kasam44f49402015-05-29 18:37:11 +0530[diff] [blame]8844
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]8845 if (enable) {
8846 ret = audio_route_apply_and_update_path(adev->audio_route, str);
8847 if (ret) {
8848 ALOGV("%s: No device sidetone supported, switching to AFE sidetone",
8849 __func__);
8850 audio_route_apply_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
8851 }
8852 }
8853 else {
8854 ret = audio_route_reset_and_update_path(adev->audio_route, str);
8855 if (ret) {
8856 ALOGV("%s: No device sidetone supported, switching to AFE sidetone",
8857 __func__);
8858 audio_route_reset_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
8859 }
8860 }
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]8861 }
8862 return 0;
8863}
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8864
Vidyakumar Athotaea269c62016-10-31 09:05:59 -0700[diff] [blame]8865void platform_update_aanc_path(struct audio_device *adev,
8866 snd_device_t out_snd_device,
8867 bool enable,
8868 char *str)
8869{
8870 ALOGD("%s: aanc out device(%d) mixer cmd = %s, enable = %d\n",
8871 __func__, out_snd_device, str, enable);
8872
8873 if (enable)
8874 audio_route_apply_and_update_path(adev->audio_route, str);
8875 else
8876 audio_route_reset_and_update_path(adev->audio_route, str);
8877
8878 return;
8879}
8880
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8881#ifdef INSTANCE_ID_ENABLED
8882void platform_make_cal_cfg(acdb_audio_cal_cfg_t* cal, int acdb_dev_id,
8883 int acdb_device_type, int app_type, int topology_id,
8884 int sample_rate, uint32_t module_id, uint16_t instance_id,
8885 uint32_t param_id, bool persist)
8886{
8887 int persist_send_flags = 1;
8888
8889 if (!cal) {
8890 return;
8891 }
8892
8893 if (persist)
8894 persist_send_flags |= 0x2;
8895
8896 memset(cal, 0, sizeof(acdb_audio_cal_cfg_t));
8897
8898 cal->persist = persist;
8899 cal->app_type = app_type;
8900 cal->acdb_dev_id = acdb_dev_id;
8901 cal->sampling_rate = sample_rate;
8902 cal->topo_id = topology_id;
8903 //if module and param id is set to 0, the whole blob will be stored
8904 //or sent to the DSP
8905 cal->module_id = module_id;
8906 cal->instance_id = instance_id;
8907 cal->param_id = param_id;
8908 cal->cal_type = acdb_device_type;
8909}
8910#else
8911void platform_make_cal_cfg(acdb_audio_cal_cfg_t* cal, int acdb_dev_id,
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8912 int acdb_device_type, int app_type, int topology_id,
8913 int sample_rate, uint32_t module_id, uint32_t param_id, bool persist)
8914{
8915 int persist_send_flags = 1;
8916
8917 if (!cal) {
8918 return;
8919 }
8920
8921 if (persist)
8922 persist_send_flags |= 0x2;
8923
8924 memset(cal, 0, sizeof(acdb_audio_cal_cfg_t));
8925
8926 cal->persist = persist;
8927 cal->app_type = app_type;
8928 cal->acdb_dev_id = acdb_dev_id;
8929 cal->sampling_rate = sample_rate;
8930 cal->topo_id = topology_id;
8931 //if module and param id is set to 0, the whole blob will be stored
8932 //or sent to the DSP
8933 cal->module_id = module_id;
8934 cal->param_id = param_id;
8935 cal->cal_type = acdb_device_type;
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8936}
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8937#endif
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8938
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8939int platform_send_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal,
8940 void* data, int length, bool persist)
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8941{
8942 int ret = 0;
8943 struct platform_data *my_data = (struct platform_data *)platform;
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8944
8945 if (!my_data) {
8946 ret = -EINVAL;
8947 goto ERROR_RETURN;
8948 }
8949
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8950 if (my_data->acdb_set_audio_cal) {
8951 // persist audio cal in local cache
8952 if (persist) {
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]8953 ret = my_data->acdb_set_audio_cal((void*)cal, data, (uint32_t)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8954 }
8955 // send audio cal to dsp
8956 if (ret == 0) {
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8957 cal->persist = false;
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]8958 ret = my_data->acdb_set_audio_cal((void*)cal, data, (uint32_t)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8959 if (persist && (ret != 0)) {
8960 ALOGV("[%s] audio cal stored with success, ignore set cal failure", __func__);
8961 ret = 0;
8962 }
8963 }
8964 }
8965
8966ERROR_RETURN:
8967 return ret;
8968}
8969
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8970int platform_get_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal,
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8971 void* data, int* length, bool persist)
8972{
8973 int ret = 0;
8974 struct platform_data *my_data = (struct platform_data *)platform;
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8975
8976 if (!my_data) {
8977 ret = -EINVAL;
8978 goto ERROR_RETURN;
8979 }
8980
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8981 if (my_data->acdb_get_audio_cal) {
8982 // get cal from dsp
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]8983 ret = my_data->acdb_get_audio_cal((void*)cal, data, (uint32_t*)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8984 // get cached cal if prevoius attempt fails and persist flag is set
8985 if ((ret != 0) && persist) {
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8986 cal->persist = true;
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]8987 ret = my_data->acdb_get_audio_cal((void*)cal, data, (uint32_t*)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8988 }
8989 }
8990
8991ERROR_RETURN:
8992 return ret;
8993}
8994
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]8995int platform_store_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal,
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]8996 void* data, int length)
8997{
8998 int ret = 0;
8999 struct platform_data *my_data = (struct platform_data *)platform;
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9000
9001 if (!my_data) {
9002 ret = -EINVAL;
9003 goto ERROR_RETURN;
9004 }
9005
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9006 if (my_data->acdb_set_audio_cal) {
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]9007 ret = my_data->acdb_set_audio_cal((void*)cal, data, (uint32_t)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9008 }
9009
9010ERROR_RETURN:
9011 return ret;
9012}
9013
Aditya Bavanari29bcea22017-10-03 20:10:35 +0530[diff] [blame]9014int platform_retrieve_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal,
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9015 void* data, int* length)
9016{
9017 int ret = 0;
9018 struct platform_data *my_data = (struct platform_data *)platform;
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9019
9020 if (!my_data) {
9021 ret = -EINVAL;
9022 goto ERROR_RETURN;
9023 }
9024
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9025 if (my_data->acdb_get_audio_cal) {
Vignesh Kulothungand477f692018-05-29 14:33:24 -0700[diff] [blame]9026 ret = my_data->acdb_get_audio_cal((void*)cal, data, (uint32_t*)length);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]9027 }
9028
9029ERROR_RETURN:
9030 return ret;
9031}
Divya Narayanan Poojary45f19192016-09-30 18:52:13 +0530[diff] [blame]9032
9033int platform_get_max_mic_count(void *platform) {
9034 struct platform_data *my_data = (struct platform_data *)platform;
9035 return my_data->max_mic_count;
9036}
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700[diff] [blame]9037
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]9038#define DEFAULT_NOMINAL_SPEAKER_GAIN 20
9039int ramp_speaker_gain(struct audio_device *adev, bool ramp_up, int target_ramp_up_gain) {
9040 // backup_gain: gain to try to set in case of an error during ramp
9041 int start_gain, end_gain, step, backup_gain, i;
9042 bool error = false;
9043 const char *mixer_ctl_name_gain_left = "Left Speaker Gain";
9044 const char *mixer_ctl_name_gain_right = "Right Speaker Gain";
9045 struct mixer_ctl *ctl_left = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_left);
9046 struct mixer_ctl *ctl_right = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_right);
9047 if (!ctl_left || !ctl_right) {
9048 ALOGE("%s: Could not get ctl for mixer cmd - %s or %s, not applying speaker gain ramp",
9049 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
9050 return -EINVAL;
9051 } else if ((mixer_ctl_get_num_values(ctl_left) != 1)
9052 || (mixer_ctl_get_num_values(ctl_right) != 1)) {
9053 ALOGE("%s: Unexpected num values for mixer cmd - %s or %s, not applying speaker gain ramp",
9054 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
9055 return -EINVAL;
9056 }
9057 if (ramp_up) {
9058 start_gain = 0;
9059 end_gain = target_ramp_up_gain > 0 ? target_ramp_up_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
9060 step = +1;
9061 backup_gain = end_gain;
9062 } else {
9063 // using same gain on left and right
9064 const int left_gain = mixer_ctl_get_value(ctl_left, 0);
9065 start_gain = left_gain > 0 ? left_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
9066 end_gain = 0;
9067 step = -1;
9068 backup_gain = start_gain;
9069 }
9070 for (i = start_gain ; i != (end_gain + step) ; i += step) {
9071 if (mixer_ctl_set_value(ctl_left, 0, i)) {
9072 ALOGE("%s: error setting %s to %d during gain ramp",
9073 __func__, mixer_ctl_name_gain_left, i);
9074 error = true;
9075 break;
9076 }
9077 if (mixer_ctl_set_value(ctl_right, 0, i)) {
9078 ALOGE("%s: error setting %s to %d during gain ramp",
9079 __func__, mixer_ctl_name_gain_right, i);
9080 error = true;
9081 break;
9082 }
9083 usleep(1000);
9084 }
9085 if (error) {
9086 // an error occured during the ramp, let's still try to go back to a safe volume
9087 if (mixer_ctl_set_value(ctl_left, 0, backup_gain)) {
9088 ALOGE("%s: error restoring left gain to %d", __func__, backup_gain);
9089 }
9090 if (mixer_ctl_set_value(ctl_right, 0, backup_gain)) {
9091 ALOGE("%s: error restoring right gain to %d", __func__, backup_gain);
9092 }
9093 }
9094 return start_gain;
9095}
9096
9097int platform_set_swap_mixer(struct audio_device *adev, bool swap_channels)
9098{
9099 const char *mixer_ctl_name = "Swap channel";
9100 struct mixer_ctl *ctl;
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]9101 const char *mixer_path;
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]9102 struct platform_data *my_data = (struct platform_data *)adev->platform;
9103
9104 // forced to set to swap, but device not rotated ... ignore set
9105 if (swap_channels && !my_data->speaker_lr_swap)
9106 return 0;
9107
9108 ALOGV("%s:", __func__);
9109
Aalique Grahame22e49102018-12-18 14:23:57 -0800[diff] [blame]9110 if (swap_channels) {
9111 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_REVERSE);
9112 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
9113 } else {
9114 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER);
9115 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
9116 }
9117
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]9118 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
9119 if (!ctl) {
9120 ALOGE("%s: Could not get ctl for mixer cmd - %s",__func__, mixer_ctl_name);
9121 return -EINVAL;
9122 }
9123
9124 if (mixer_ctl_set_value(ctl, 0, swap_channels) < 0) {
9125 ALOGE("%s: Could not set reverse cotrol %d",__func__, swap_channels);
9126 return -EINVAL;
9127 }
9128
9129 ALOGV("platfor_force_swap_channel :: Channel orientation ( %s ) ",
9130 swap_channels?"R --> L":"L --> R");
9131
9132 return 0;
9133}
9134
9135int platform_check_and_set_swap_lr_channels(struct audio_device *adev, bool swap_channels)
9136{
9137 // only update if there is active pcm playback on speaker
9138 struct platform_data *my_data = (struct platform_data *)adev->platform;
9139
9140 my_data->speaker_lr_swap = swap_channels;
9141
9142 return platform_set_swap_channels(adev, swap_channels);
9143}
9144
9145int platform_set_swap_channels(struct audio_device *adev, bool swap_channels)
9146{
9147 // only update if there is active pcm playback on speaker
9148 struct audio_usecase *usecase;
9149 struct listnode *node;
9150
kunleiz43c4a6a2018-05-17 18:01:24 +0800[diff] [blame]9151 //swap channels only for stereo spkr
9152 struct platform_data *my_data = (struct platform_data *)adev->platform;
9153 if (my_data) {
9154 if (!hw_info_is_stereo_spkr(my_data->hw_info)) {
9155 ALOGV("%s: will not swap due to it is not stereo spkr", __func__);
9156 return 0;
9157 }
9158 } else {
9159 ALOGE("%s: failed to allocate platform data", __func__);
9160 return -EINVAL;
9161 }
9162
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]9163 // do not swap channels in audio modes with concurrent capture and playback
9164 // as this may break the echo reference
9165 if ((adev->mode == AUDIO_MODE_IN_COMMUNICATION) || (adev->mode == AUDIO_MODE_IN_CALL)) {
9166 ALOGV("%s: will not swap due to audio mode %d", __func__, adev->mode);
9167 return 0;
9168 }
9169
9170 list_for_each(node, &adev->usecase_list) {
9171 usecase = node_to_item(node, struct audio_usecase, list);
9172 if (usecase->type == PCM_PLAYBACK &&
9173 usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
9174 /*
9175 * If acdb tuning is different for SPEAKER_REVERSE, it is must
9176 * to perform device switch to disable the current backend to
9177 * enable it with new acdb data.
9178 */
kunleiz43c4a6a2018-05-17 18:01:24 +0800[diff] [blame]9179 if (my_data->speaker_lr_swap &&
9180 (acdb_device_table[SND_DEVICE_OUT_SPEAKER] !=
9181 acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE])) {
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]9182 const int initial_skpr_gain = ramp_speaker_gain(adev, false /*ramp_up*/, -1);
9183 select_devices(adev, usecase->id);
9184 if (initial_skpr_gain != -EINVAL)
9185 ramp_speaker_gain(adev, true /*ramp_up*/, initial_skpr_gain);
9186
9187 } else {
9188 platform_set_swap_mixer(adev, swap_channels);
9189 }
9190 break;
9191 }
9192 }
9193
9194 return 0;
9195}
9196
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700[diff] [blame]9197static struct amp_db_and_gain_table tbl_mapping[MAX_VOLUME_CAL_STEPS];
9198static int num_gain_tbl_entry = 0;
9199
9200bool platform_add_gain_level_mapping(struct amp_db_and_gain_table *tbl_entry) {
9201
9202 ALOGV("%s: enter .. add %f %f %d", __func__, tbl_entry->amp, tbl_entry->db, tbl_entry->level);
9203 if (num_gain_tbl_entry == -1) {
9204 ALOGE("%s: num entry beyond valid step levels or corrupted..rejecting custom mapping",
9205 __func__);
9206 return false;
9207 }
9208
9209 if (num_gain_tbl_entry >= MAX_VOLUME_CAL_STEPS) {
9210 ALOGE("%s: max entry reached max[%d] current index[%d] .. rejecting", __func__,
9211 MAX_VOLUME_CAL_STEPS, num_gain_tbl_entry);
9212 num_gain_tbl_entry = -1; // indicates error and no more info will be cached
9213 return false;
9214 }
9215
9216 if (num_gain_tbl_entry > 0 && tbl_mapping[num_gain_tbl_entry - 1].amp >= tbl_entry->amp) {
9217 ALOGE("%s: value not in ascending order .. rejecting custom mapping", __func__);
9218 num_gain_tbl_entry = -1; // indicates error and no more info will be cached
9219 return false;
9220 }
9221
9222 tbl_mapping[num_gain_tbl_entry] = *tbl_entry;
9223 ++num_gain_tbl_entry;
9224
9225 return true;
9226}
9227
9228int platform_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl,
9229 int table_size) {
9230 int itt = 0;
9231 ALOGV("platform_get_gain_level_mapping called ");
9232
9233 if (num_gain_tbl_entry <= 0 || num_gain_tbl_entry > MAX_VOLUME_CAL_STEPS) {
9234 ALOGD("%s: empty or currupted gain_mapping_table", __func__);
9235 return 0;
9236 }
9237
9238 for (; itt < num_gain_tbl_entry && itt <= table_size; itt++) {
9239 mapping_tbl[itt] = tbl_mapping[itt];
9240 ALOGV("%s: added amp[%f] db[%f] level[%d]", __func__,
9241 mapping_tbl[itt].amp, mapping_tbl[itt].db, mapping_tbl[itt].level);
9242 }
9243
9244 return num_gain_tbl_entry;
9245}
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]9246
9247int platform_get_max_codec_backend() {
9248
9249 return MAX_CODEC_BACKENDS;
9250}
Revathi Uddaraju0553e8f2017-11-30 14:56:11 +0530[diff] [blame]9251int platform_get_supported_copp_sampling_rate(uint32_t stream_sr)
Venugopal Nadipalli83134582017-09-21 22:34:50 +0530[diff] [blame]9252{
9253 int sample_rate;
9254 switch (stream_sr){
9255 case 8000:
9256 case 11025:
9257 case 16000:
9258 case 22050:
9259 case 32000:
9260 case 48000:
9261 sample_rate = 48000;
9262 break;
9263 case 44100:
9264 sample_rate = 44100;
9265 break;
9266 case 64000:
9267 case 96000:
9268 sample_rate = 96000;
9269 break;
9270 case 88200:
9271 sample_rate = 88200;
9272 break;
9273 case 176400:
9274 sample_rate = 176400;
9275 break;
9276 case 192000:
9277 sample_rate = 192000;
9278 break;
9279 case 352800:
9280 sample_rate = 352800;
9281 break;
9282 case 384000:
9283 sample_rate = 384000;
9284 break;
9285 case 144000:
9286 default:
9287 sample_rate = 48000;
9288 break;
9289 }
9290 return sample_rate;
9291}
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]9292
Meng Wangef2f6e12018-10-08 13:06:05 +0800[diff] [blame]9293#if defined (PLATFORM_MSM8998) || (PLATFORM_SDM845) || (PLATFORM_SDM710) || \
9294 defined (PLATFORM_QCS605) || defined (PLATFORM_MSMNILE) || \
9295 defined (PLATFORM_KONA) || defined (PLATFORM_MSMSTEPPE) || \
9296 defined (PLATFORM_QCS405)
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]9297
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]9298int platform_get_mmap_data_fd(void *platform, int fe_dev, int dir, int *fd,
9299 uint32_t *size)
9300{
9301 struct platform_data *my_data = (struct platform_data *)platform;
9302 struct audio_device *adev = my_data->adev;
9303 int hw_fd = -1;
9304 char dev_name[128];
9305 struct snd_pcm_mmap_fd mmap_fd;
9306 memset(&mmap_fd, 0, sizeof(mmap_fd));
9307 mmap_fd.dir = dir;
9308 snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
9309 adev->snd_card, HWDEP_FE_BASE+fe_dev);
9310 hw_fd = open(dev_name, O_RDONLY);
9311 if (hw_fd < 0) {
9312 ALOGE("fe hw dep node open %d/%d failed", adev->snd_card, fe_dev);
9313 return -1;
9314 }
9315 if (ioctl(hw_fd, SNDRV_PCM_IOCTL_MMAP_DATA_FD, &mmap_fd) < 0) {
9316 ALOGE("fe hw dep node ioctl failed");
9317 close(hw_fd);
9318 return -1;
9319 }
9320 *fd = mmap_fd.fd;
9321 *size = mmap_fd.size;
9322 close(hw_fd); // mmap_fd should still be valid
9323 return 0;
9324}
9325#else
9326int platform_get_mmap_data_fd(void *platform __unused, int fe_dev __unused,
9327 int dir __unused, int *fd __unused,
9328 uint32_t *size __unused)
9329{
9330 return -1;
9331}
9332#endif
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]9333
9334static const char *platform_get_mixer_control(struct mixer_ctl *ctl)
9335{
9336 int id = -1;
9337 const char *id_string = NULL;
9338
9339 if (!ctl) {
9340 ALOGD("%s: mixer ctl not obtained", __func__);
9341 } else {
9342 id = mixer_ctl_get_value(ctl, 0);
9343 if (id >= 0) {
9344 id_string = mixer_ctl_get_enum_string(ctl, id);
9345 }
9346 }
9347
9348 return id_string;
9349}
Naresh Tannirudcb47c52018-06-25 16:23:32 +0530[diff] [blame]9350
9351bool platform_set_microphone_characteristic(void *platform,
9352 struct audio_microphone_characteristic_t mic) {
9353 struct platform_data *my_data = (struct platform_data *)platform;
9354 if (my_data->declared_mic_count >= AUDIO_MICROPHONE_MAX_COUNT) {
9355 ALOGE("mic number is more than maximum number");
9356 return false;
9357 }
9358 for (size_t ch = 0; ch < AUDIO_CHANNEL_COUNT_MAX; ch++) {
9359 mic.channel_mapping[ch] = AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
9360 }
9361 my_data->microphones[my_data->declared_mic_count++] = mic;
9362 return true;
9363}
9364
9365int platform_get_microphones(void *platform,
9366 struct audio_microphone_characteristic_t *mic_array,
9367 size_t *mic_count) {
9368 struct platform_data *my_data = (struct platform_data *)platform;
9369 if (mic_count == NULL) {
9370 return -EINVAL;
9371 }
9372 if (mic_array == NULL) {
9373 return -EINVAL;
9374 }
9375
9376 if (*mic_count == 0) {
9377 *mic_count = my_data->declared_mic_count;
9378 return 0;
9379 }
9380
9381 size_t max_mic_count = *mic_count;
9382 size_t actual_mic_count = 0;
9383 for (size_t i = 0; i < max_mic_count && i < my_data->declared_mic_count; i++) {
9384 mic_array[i] = my_data->microphones[i];
9385 actual_mic_count++;
9386 }
9387 *mic_count = actual_mic_count;
9388 return 0;
9389}
9390
9391bool platform_set_microphone_map(void *platform, snd_device_t in_snd_device,
9392 const struct mic_info *info) {
9393 struct platform_data *my_data = (struct platform_data *)platform;
9394 if (in_snd_device < SND_DEVICE_IN_BEGIN || in_snd_device >= SND_DEVICE_IN_END) {
9395 ALOGE("%s: Sound device not valid", __func__);
9396 return false;
9397 }
9398 size_t m_count = my_data->mic_map[in_snd_device].mic_count++;
9399 if (m_count >= AUDIO_MICROPHONE_MAX_COUNT) {
9400 ALOGE("%s: Microphone count is greater than max allowed value", __func__);
9401 my_data->mic_map[in_snd_device].mic_count--;
9402 return false;
9403 }
9404 my_data->mic_map[in_snd_device].microphones[m_count] = *info;
9405 return true;
9406}
9407
9408int platform_get_active_microphones(void *platform, unsigned int channels,
9409 audio_usecase_t uc_id,
9410 struct audio_microphone_characteristic_t *mic_array,
9411 size_t *mic_count) {
9412 struct platform_data *my_data = (struct platform_data *)platform;
9413 struct audio_usecase *usecase = get_usecase_from_list(my_data->adev, uc_id);
9414 if (mic_count == NULL || mic_array == NULL || usecase == NULL) {
9415 return -EINVAL;
9416 }
9417 size_t max_mic_count = my_data->declared_mic_count;
9418 size_t actual_mic_count = 0;
9419
9420 snd_device_t active_input_snd_device =
9421 platform_get_input_snd_device(platform, usecase->stream.in->device);
9422 if (active_input_snd_device == SND_DEVICE_NONE) {
9423 ALOGI("%s: No active microphones found", __func__);
9424 goto end;
9425 }
9426
9427 size_t active_mic_count = my_data->mic_map[active_input_snd_device].mic_count;
9428 struct mic_info *m_info = my_data->mic_map[active_input_snd_device].microphones;
9429
9430 for (size_t i = 0; i < active_mic_count; i++) {
9431 unsigned int channels_for_active_mic = channels;
9432 if (channels_for_active_mic > m_info[i].channel_count) {
9433 channels_for_active_mic = m_info[i].channel_count;
9434 }
9435 for (size_t j = 0; j < max_mic_count; j++) {
9436 if (strcmp(my_data->microphones[j].device_id,
9437 m_info[i].device_id) == 0) {
9438 mic_array[actual_mic_count] = my_data->microphones[j];
9439 for (size_t ch = 0; ch < channels_for_active_mic; ch++) {
9440 mic_array[actual_mic_count].channel_mapping[ch] =
9441 m_info[i].channel_mapping[ch];
9442 }
9443 actual_mic_count++;
9444 break;
9445 }
9446 }
9447 }
9448end:
9449 *mic_count = actual_mic_count;
9450 return 0;
9451}
Naresh Tannirucb5b5782018-10-12 20:42:07 +0530[diff] [blame]9452
9453int platform_get_license_by_product(void *platform __unused,
9454 const char* product_name __unused,
9455 int *product_id __unused,
9456 char* product_license __unused)
Surendar karka30569792018-05-08 12:02:21 +0530[diff] [blame]9457{
9458 return -ENOSYS;
9459}
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800[diff] [blame]9460