Gitiles
Code Review Sign In
review.blissroms.org / platform_hardware_qcom_audio / 7584311f4e682192549f78b6da1676da52bab3e4 / . / hal / msm8974 / platform.c
blob: b575063cd41ba8e08ff50e0909d3c2fc2ea2a383 [file] [log] [blame]
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1/*
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]2 * Copyright (c) 2013-2017, 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>
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]34#include <cutils/log.h>
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>
39#include "platform.h"
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]40#include "audio_extn.h"
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]41#include "acdb.h"
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]42#include "voice_extn.h"
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]43#include "edid.h"
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]44#include "sound/compress_params.h"
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]45#include "sound/msmcal-hwdep.h"
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]46
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]47#ifdef DYNAMIC_LOG_ENABLED
48#include <log_xml_parser.h>
49#define LOG_MASK HAL_MOD_FILE_PLATFORM
50#include <log_utils.h>
51#endif
52
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]53#define SOUND_TRIGGER_DEVICE_HANDSET_MONO_LOW_POWER_ACDB_ID (100)
Apoorv Raghuvanshia433fb52015-03-16 15:22:30 -0700[diff] [blame]54#define MIXER_FILE_DELIMITER "_"
55#define MIXER_FILE_EXT ".xml"
56
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]57#ifdef LINUX_ENABLED
58#define MIXER_XML_BASE_STRING "/etc/mixer_paths"
59#define MIXER_XML_DEFAULT_PATH "/etc/mixer_paths.xml"
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]60#define PLATFORM_INFO_XML_PATH_INTCODEC "/etc/audio_platform_info_intcodec.xml"
61#define PLATFORM_INFO_XML_PATH_SKUSH "/etc/audio_platform_info_skush.xml"
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]62#define PLATFORM_INFO_XML_PATH_SKUW "/etc/audio_platform_info_skuw.xml"
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]63#define PLATFORM_INFO_XML_PATH "/etc/audio_platform_info.xml"
64#define MIXER_XML_PATH_AUXPCM "/etc/mixer_paths_auxpcm.xml"
65#define MIXER_XML_PATH_I2S "/etc/mixer_paths_i2s.xml"
66#define PLATFORM_INFO_XML_PATH_I2S "/etc/audio_platform_info_i2s.xml"
67#else
Naresh Tanniru10758b62017-06-05 21:05:53 +0530[diff] [blame]68#define MIXER_XML_BASE_STRING "/vendor/etc/mixer_paths"
69#define MIXER_XML_DEFAULT_PATH "/vendor/etc/mixer_paths.xml"
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]70#define PLATFORM_INFO_XML_PATH_INTCODEC "/vendor/etc/audio_platform_info_intcodec.xml"
71#define PLATFORM_INFO_XML_PATH_SKUSH "/vendor/etc/audio_platform_info_skush.xml"
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]72#define PLATFORM_INFO_XML_PATH_SKUW "/vendor/etc/audio_platform_info_skuw.xml"
Naresh Tanniru10758b62017-06-05 21:05:53 +0530[diff] [blame]73#define PLATFORM_INFO_XML_PATH "/vendor/etc/audio_platform_info.xml"
74#define MIXER_XML_PATH_AUXPCM "/vendor/etc/mixer_paths_auxpcm.xml"
75#define MIXER_XML_PATH_I2S "/vendor/etc/mixer_paths_i2s.xml"
76#define PLATFORM_INFO_XML_PATH_I2S "/vendor/etc/audio_platform_info_i2s.xml"
Kuirong Wang0b73b3f2016-12-04 12:59:43 -0800[diff] [blame]77#endif
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]78
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]79#include <linux/msm_audio.h>
Sharad Sangled39232d2017-08-08 20:27:18 +0530[diff] [blame]80#if defined (PLATFORM_MSM8998) || (PLATFORM_SDM845) || (PLATFORM_SDM670)
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]81#include <sound/devdep_params.h>
82#endif
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]83
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]84#define LIB_ACDB_LOADER "libacdbloader.so"
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]85#define CVD_VERSION_MIXER_CTL "CVD Version"
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]86
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]87#define FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)
88#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024 * 1024)
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]89#define MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024)
90#define COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING (2 * 1024)
91#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
92
Vikram Panduranga7e784962016-10-27 12:32:30 -0700[diff] [blame]93
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]94/*
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]95 * This file will have a maximum of 38 bytes:
96 *
97 * 4 bytes: number of audio blocks
98 * 4 bytes: total length of Short Audio Descriptor (SAD) blocks
99 * Maximum 10 * 3 bytes: SAD blocks
100 */
101#define MAX_SAD_BLOCKS 10
102#define SAD_BLOCK_SIZE 3
103
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]104#define MAX_CVD_VERSION_STRING_SIZE 100
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]105#define MAX_SND_CARD_STRING_SIZE 100
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]106
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]107/* EDID format ID for LPCM audio */
108#define EDID_FORMAT_LPCM 1
109
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]110/* fallback app type if the default app type from acdb loader fails */
Srikanth Uyyalaa1e32352015-10-09 14:48:04 +0530[diff] [blame]111#define DEFAULT_APP_TYPE_RX_PATH 0x11130
112#define DEFAULT_APP_TYPE_TX_PATH 0x11132
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]113
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]114#define SAMPLE_RATE_8KHZ 8000
115#define SAMPLE_RATE_16KHZ 16000
116
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]117#define MAX_SET_CAL_BYTE_SIZE 65536
118
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]119/* Mixer path names */
120#define AFE_SIDETONE_MIXER_PATH "afe-sidetone"
121
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]122#define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence"
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]123#define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable"
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]124#define AUDIO_PARAMETER_KEY_HD_VOICE "hd_voice"
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]125#define AUDIO_PARAMETER_KEY_VOLUME_BOOST "volume_boost"
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]126#define AUDIO_PARAMETER_KEY_AUD_CALDATA "cal_data"
127#define AUDIO_PARAMETER_KEY_AUD_CALRESULT "cal_result"
128
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]129#define AUDIO_PARAMETER_KEY_MONO_SPEAKER "mono_speaker"
130
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]131#define AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS "perf_lock_opts"
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]132
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]133/* Reload ACDB files from specified path */
134#define AUDIO_PARAMETER_KEY_RELOAD_ACDB "reload_acdb"
135
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]136/* Query external audio device connection status */
137#define AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE "ext_audio_device"
138
139#define EVENT_EXTERNAL_SPK_1 "qc_ext_spk_1"
140#define EVENT_EXTERNAL_SPK_2 "qc_ext_spk_2"
141#define EVENT_EXTERNAL_MIC "qc_ext_mic"
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]142#define MAX_CAL_NAME 20
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]143#define MAX_MIME_TYPE_LENGTH 30
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]144
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]145#define GET_IN_DEVICE_INDEX(SND_DEVICE) ((SND_DEVICE) - (SND_DEVICE_IN_BEGIN))
146
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]147#ifdef DYNAMIC_LOG_ENABLED
148extern void log_utils_init(void);
149extern void log_utils_deinit(void);
150#endif
151
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]152char cal_name_info[WCD9XXX_MAX_CAL][MAX_CAL_NAME] = {
153 [WCD9XXX_ANC_CAL] = "anc_cal",
154 [WCD9XXX_MBHC_CAL] = "mbhc_cal",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]155 [WCD9XXX_VBAT_CAL] = "vbat_cal",
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]156};
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]157static char *default_rx_backend = NULL;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]158
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]159#define AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED "is_hw_dec_session_allowed"
160
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]161char dsp_only_decoders_mime[][MAX_MIME_TYPE_LENGTH] = {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]162 "audio/x-ms-wma" /* wma*/ ,
163 "audio/x-ms-wma-lossless" /* wma lossless */ ,
164 "audio/x-ms-wma-pro" /* wma prop */ ,
165 "audio/amr-wb-plus" /* amr wb plus */ ,
166 "audio/alac" /*alac */ ,
167 "audio/x-ape" /*ape */,
168};
169
170
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]171enum {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]172 VOICE_FEATURE_SET_DEFAULT,
173 VOICE_FEATURE_SET_VOLUME_BOOST
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]174};
sangwoo53b2cf02013-07-25 19:18:44 -0700[diff] [blame]175
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]176struct audio_block_header
177{
178 int reserved;
179 int length;
180};
181
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]182typedef struct acdb_audio_cal_cfg {
183 uint32_t persist;
184 uint32_t snd_dev_id;
185 audio_devices_t dev_id;
186 int32_t acdb_dev_id;
187 uint32_t app_type;
188 uint32_t topo_id;
189 uint32_t sampling_rate;
190 uint32_t cal_type;
191 uint32_t module_id;
192 uint32_t param_id;
193} acdb_audio_cal_cfg_t;
194
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]195enum {
196 CAL_MODE_SEND = 0x1,
197 CAL_MODE_PERSIST = 0x2,
198 CAL_MODE_RTAC = 0x4
199};
200
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]201acdb_loader_get_calibration_t acdb_loader_get_calibration;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]202
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]203typedef struct codec_backend_cfg {
204 uint32_t sample_rate;
205 uint32_t bit_width;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]206 uint32_t channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]207 uint32_t format;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]208 char *bitwidth_mixer_ctl;
209 char *samplerate_mixer_ctl;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]210 char *channels_mixer_ctl;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]211} codec_backend_cfg_t;
212
Ashish Jain4826f6c2017-02-06 13:33:20 +0530[diff] [blame]213static native_audio_prop na_props = {0, 0, NATIVE_AUDIO_MODE_INVALID};
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]214static bool supports_true_32_bit = false;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]215
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]216static int max_be_dai_names = 0;
217static const struct be_dai_name_struct *be_dai_name_table;
218
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]219struct platform_data {
220 struct audio_device *adev;
221 bool fluence_in_spkr_mode;
222 bool fluence_in_voice_call;
223 bool fluence_in_voice_rec;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]224 bool fluence_in_audio_rec;
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]225 bool fluence_in_hfp_call;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]226 bool external_spk_1;
227 bool external_spk_2;
228 bool external_mic;
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]229 bool speaker_lr_swap;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]230 int fluence_type;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]231 int fluence_mode;
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]232 char fluence_cap[PROPERTY_VALUE_MAX];
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]233 bool slowtalk;
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]234 bool hd_voice;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]235 bool ec_ref_enabled;
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]236 bool is_i2s_ext_modem;
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]237 bool is_acdb_initialized;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]238 /* Vbat monitor related flags */
239 bool is_vbat_speaker;
240 bool gsm_mode_enabled;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]241 bool is_slimbus_interface;
242 bool is_internal_codec;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]243 int mono_speaker;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]244 /* Audio calibration related functions */
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]245 void *acdb_handle;
246 int voice_feature_set;
247 acdb_init_t acdb_init;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]248 acdb_init_v3_t acdb_init_v3;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]249 acdb_deallocate_t acdb_deallocate;
250 acdb_send_audio_cal_t acdb_send_audio_cal;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]251 acdb_send_audio_cal_v3_t acdb_send_audio_cal_v3;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]252 acdb_set_audio_cal_t acdb_set_audio_cal;
253 acdb_get_audio_cal_t acdb_get_audio_cal;
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]254 acdb_send_voice_cal_t acdb_send_voice_cal;
255 acdb_reload_vocvoltable_t acdb_reload_vocvoltable;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]256 acdb_get_default_app_type_t acdb_get_default_app_type;
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]257 acdb_send_common_top_t acdb_send_common_top;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]258 acdb_set_codec_data_t acdb_set_codec_data;
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]259 acdb_reload_t acdb_reload;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]260 acdb_reload_v2_t acdb_reload_v2;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]261 void *hw_info;
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]262 acdb_send_gain_dep_cal_t acdb_send_gain_dep_cal;
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]263 struct csd_data *csd;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]264 void *edid_info;
265 bool edid_valid;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]266 int ext_disp_type;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]267 char ec_ref_mixer_path[64];
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]268 codec_backend_cfg_t current_backend_cfg[MAX_CODEC_BACKENDS];
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]269 char codec_version[CODEC_VERSION_MAX_LENGTH];
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]270 int hw_dep_fd;
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]271 char cvd_version[MAX_CVD_VERSION_STRING_SIZE];
272 char snd_card_name[MAX_SND_CARD_STRING_SIZE];
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]273 int source_mic_type;
274 int max_mic_count;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]275 bool is_dsd_supported;
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530[diff] [blame]276 bool is_asrc_supported;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]277 struct listnode acdb_meta_key_list;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]278};
279
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]280static int pcm_device_table[AUDIO_USECASE_MAX][2] = {
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]281 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE,
282 DEEP_BUFFER_PCM_DEVICE},
283 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]284 LOWLATENCY_PCM_DEVICE},
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]285 [USECASE_AUDIO_PLAYBACK_ULL] = {MULTIMEDIA3_PCM_DEVICE,
286 MULTIMEDIA3_PCM_DEVICE},
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]287 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE,
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]288 MULTIMEDIA2_PCM_DEVICE},
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700[diff] [blame]289 [USECASE_AUDIO_PLAYBACK_HIFI] = {MULTIMEDIA2_PCM_DEVICE,
290 MULTIMEDIA2_PCM_DEVICE},
Krishnankutty Kolathappillya43f96e2013-11-01 12:17:53 -0700[diff] [blame]291 [USECASE_AUDIO_PLAYBACK_OFFLOAD] =
292 {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE},
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700[diff] [blame]293 [USECASE_AUDIO_PLAYBACK_OFFLOAD2] =
294 {PLAYBACK_OFFLOAD_DEVICE2, PLAYBACK_OFFLOAD_DEVICE2},
295 [USECASE_AUDIO_PLAYBACK_OFFLOAD3] =
296 {PLAYBACK_OFFLOAD_DEVICE3, PLAYBACK_OFFLOAD_DEVICE3},
297 [USECASE_AUDIO_PLAYBACK_OFFLOAD4] =
298 {PLAYBACK_OFFLOAD_DEVICE4, PLAYBACK_OFFLOAD_DEVICE4},
299 [USECASE_AUDIO_PLAYBACK_OFFLOAD5] =
300 {PLAYBACK_OFFLOAD_DEVICE5, PLAYBACK_OFFLOAD_DEVICE5},
301 [USECASE_AUDIO_PLAYBACK_OFFLOAD6] =
302 {PLAYBACK_OFFLOAD_DEVICE6, PLAYBACK_OFFLOAD_DEVICE6},
303 [USECASE_AUDIO_PLAYBACK_OFFLOAD7] =
304 {PLAYBACK_OFFLOAD_DEVICE7, PLAYBACK_OFFLOAD_DEVICE7},
305 [USECASE_AUDIO_PLAYBACK_OFFLOAD8] =
306 {PLAYBACK_OFFLOAD_DEVICE8, PLAYBACK_OFFLOAD_DEVICE8},
307 [USECASE_AUDIO_PLAYBACK_OFFLOAD9] =
308 {PLAYBACK_OFFLOAD_DEVICE9, PLAYBACK_OFFLOAD_DEVICE9},
vivek mehta0ea887a2015-08-26 14:01:20 -0700[diff] [blame]309
vivek mehta0ea887a2015-08-26 14:01:20 -0700[diff] [blame]310
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]311 [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE},
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]312 [USECASE_AUDIO_RECORD_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, COMPRESS_CAPTURE_DEVICE},
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530[diff] [blame]313 [USECASE_AUDIO_RECORD_COMPRESS2] = {-1, -1},
314 [USECASE_AUDIO_RECORD_COMPRESS3] = {-1, -1},
315 [USECASE_AUDIO_RECORD_COMPRESS4] = {-1, -1},
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]316 [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
317 LOWLATENCY_PCM_DEVICE},
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]318 [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE,
319 MULTIMEDIA2_PCM_DEVICE},
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700[diff] [blame]320 [USECASE_AUDIO_RECORD_HIFI] = {MULTIMEDIA2_PCM_DEVICE,
321 MULTIMEDIA2_PCM_DEVICE},
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]322 [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE},
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -0800[diff] [blame]323 [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX},
Vimal Puthanveed47e64852013-12-20 13:23:39 -0800[diff] [blame]324 [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX},
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]325 [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]326 [USECASE_AUDIO_PLAYBACK_MMAP] = {MMAP_PLAYBACK_PCM_DEVICE,
327 MMAP_PLAYBACK_PCM_DEVICE},
328 [USECASE_AUDIO_RECORD_MMAP] = {MMAP_RECORD_PCM_DEVICE,
329 MMAP_RECORD_PCM_DEVICE},
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]330 [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE},
331 [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE},
332 [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE},
Vicky Sehrawat7e4fc152014-02-12 17:58:59 -0800[diff] [blame]333 [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE},
Vidyakumar Athota0e109352015-02-12 17:38:22 -0800[diff] [blame]334 [USECASE_VOICEMMODE1_CALL] = {VOICEMMODE1_CALL_PCM_DEVICE,
335 VOICEMMODE1_CALL_PCM_DEVICE},
336 [USECASE_VOICEMMODE2_CALL] = {VOICEMMODE2_CALL_PCM_DEVICE,
337 VOICEMMODE2_CALL_PCM_DEVICE},
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]338 [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE},
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]339 [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE,
340 AUDIO_RECORD_PCM_DEVICE},
341 [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
342 AUDIO_RECORD_PCM_DEVICE},
343 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
344 AUDIO_RECORD_PCM_DEVICE},
Helen Zenge56b4852013-12-03 16:54:40 -0800[diff] [blame]345 [USECASE_INCALL_REC_UPLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
346 COMPRESS_CAPTURE_DEVICE},
347 [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
348 COMPRESS_CAPTURE_DEVICE},
349 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
350 COMPRESS_CAPTURE_DEVICE},
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -0700[diff] [blame]351 [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE,
352 INCALL_MUSIC_UPLINK_PCM_DEVICE},
353 [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE,
354 INCALL_MUSIC_UPLINK2_PCM_DEVICE},
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]355 [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1},
356 [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE},
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]357
358 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
359 AFE_PROXY_RECORD_PCM_DEVICE},
360 [USECASE_AUDIO_RECORD_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
361 AFE_PROXY_RECORD_PCM_DEVICE},
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]362 [USECASE_AUDIO_PLAYBACK_EXT_DISP_SILENCE] = {MULTIMEDIA9_PCM_DEVICE, -1},
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]363 [USECASE_AUDIO_TRANSCODE_LOOPBACK] = {TRANSCODE_LOOPBACK_RX_DEV_ID, TRANSCODE_LOOPBACK_TX_DEV_ID},
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]364
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]365 [USECASE_AUDIO_PLAYBACK_VOIP] = {AUDIO_PLAYBACK_VOIP_PCM_DEVICE, AUDIO_PLAYBACK_VOIP_PCM_DEVICE},
366 [USECASE_AUDIO_RECORD_VOIP] = {AUDIO_RECORD_VOIP_PCM_DEVICE, AUDIO_RECORD_VOIP_PCM_DEVICE},
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]367 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1] =
368 {PLAYBACK_INTERACTIVE_STRM_DEVICE1, PLAYBACK_INTERACTIVE_STRM_DEVICE1},
369 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2] =
370 {PLAYBACK_INTERACTIVE_STRM_DEVICE2, PLAYBACK_INTERACTIVE_STRM_DEVICE2},
371 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3] =
372 {PLAYBACK_INTERACTIVE_STRM_DEVICE3, PLAYBACK_INTERACTIVE_STRM_DEVICE3},
373 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4] =
374 {PLAYBACK_INTERACTIVE_STRM_DEVICE4, PLAYBACK_INTERACTIVE_STRM_DEVICE4},
375 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5] =
376 {PLAYBACK_INTERACTIVE_STRM_DEVICE5, PLAYBACK_INTERACTIVE_STRM_DEVICE5},
377 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6] =
378 {PLAYBACK_INTERACTIVE_STRM_DEVICE6, PLAYBACK_INTERACTIVE_STRM_DEVICE6},
379 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7] =
380 {PLAYBACK_INTERACTIVE_STRM_DEVICE7, PLAYBACK_INTERACTIVE_STRM_DEVICE7},
381 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8] =
382 {PLAYBACK_INTERACTIVE_STRM_DEVICE8, PLAYBACK_INTERACTIVE_STRM_DEVICE8},
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]383
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]384};
385
386/* Array to store sound devices */
387static const char * const device_table[SND_DEVICE_MAX] = {
388 [SND_DEVICE_NONE] = "none",
389 /* Playback sound devices */
390 [SND_DEVICE_OUT_HANDSET] = "handset",
391 [SND_DEVICE_OUT_SPEAKER] = "speaker",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]392 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = "speaker-ext-1",
393 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = "speaker-ext-2",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]394 [SND_DEVICE_OUT_SPEAKER_VBAT] = "speaker-vbat",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]395 [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",
396 [SND_DEVICE_OUT_HEADPHONES] = "headphones",
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]397 [SND_DEVICE_OUT_HEADPHONES_DSD] = "headphones-dsd",
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]398 [SND_DEVICE_OUT_HEADPHONES_44_1] = "headphones-44.1",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]399 [SND_DEVICE_OUT_LINE] = "line",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]400 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]401 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = "speaker-and-line",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]402 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = "speaker-and-headphones-ext-1",
403 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = "speaker-and-headphones-ext-2",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]404 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
405 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]406 [SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = "voice-speaker-vbat",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]407 [SND_DEVICE_OUT_VOICE_SPEAKER_2] = "voice-speaker-2",
408 [SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = "voice-speaker-2-vbat",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]409 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]410 [SND_DEVICE_OUT_VOICE_LINE] = "voice-line",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]411 [SND_DEVICE_OUT_HDMI] = "hdmi",
412 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]413 [SND_DEVICE_OUT_DISPLAY_PORT] = "display-port",
414 [SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = "speaker-and-display-port",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]415 [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]416 [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]417 [SND_DEVICE_OUT_BT_A2DP] = "bt-a2dp",
418 [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = "speaker-and-bt-a2dp",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]419 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
420 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
421 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]422 [SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = "voice-tty-full-usb",
423 [SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = "voice-tty-vco-usb",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]424 [SND_DEVICE_OUT_VOICE_TX] = "voice-tx",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]425 [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy",
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]426 [SND_DEVICE_OUT_USB_HEADSET] = "usb-headset",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]427 [SND_DEVICE_OUT_VOICE_USB_HEADSET] = "usb-headset",
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]428 [SND_DEVICE_OUT_USB_HEADPHONES] = "usb-headphones",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]429 [SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = "usb-headphones",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]430 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]431 [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]432 [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones",
433 [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones",
434 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones",
435 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones",
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]436 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = "voice-speaker-and-voice-headphones",
437 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = "voice-speaker-and-voice-anc-headphones",
438 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = "voice-speaker-and-voice-anc-fb-headphones",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]439 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones",
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]440 [SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = "speaker-and-anc-fb-headphones",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]441 [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]442 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]443 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = "voice-speaker-protected",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]444 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = "voice-speaker-2-protected",
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]445 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = "speaker-protected-vbat",
446 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = "voice-speaker-protected-vbat",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]447 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT] = "voice-speaker-2-protected-vbat",
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]448 [SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS] = "speaker-protected",
449 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS] = "speaker-protected-vbat",
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]450 [SND_DEVICE_OUT_SPEAKER_AND_BT_SCO] = "speaker-and-bt-sco",
451 [SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB] = "speaker-and-bt-sco-wb",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]452
453 /* Capture sound devices */
454 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]455 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = "handset-mic-ext",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]456 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]457 [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic",
458 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic",
459 [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]460 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]461 [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire",
462 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire",
463 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]464 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]465 [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic",
466 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic",
467 [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]468 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]469 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire",
470 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire",
471 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
472 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]473 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
474 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
475 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
476 [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]477 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = "bt-sco-mic",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]478 [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]479 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = "bt-sco-mic-wb",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]480 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]481 [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]482 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
Vidyakumar Athotaadfe4e32013-12-13 14:51:26 -0800[diff] [blame]483 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]484 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
485 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
486 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]487 [SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = "voice-tty-full-usb-mic",
488 [SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = "voice-tty-hco-usb-mic",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]489 [SND_DEVICE_IN_VOICE_RX] = "voice-rx",
490
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]491 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]492 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic",
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]493 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef",
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]494 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]495 [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]496 [SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] ="usb-headset-mic",
497 [SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = "usb-headset-mic",
498 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = "usb-headset-mic",
499 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = "usb-headset-mic",
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]500 [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]501 [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]502 [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = "aanc-handset-mic",
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]503 [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]504 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef",
505 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]506 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback",
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]507 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = "vi-feedback-mono-1",
508 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = "vi-feedback-mono-2",
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]509 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = "voice-speaker-dmic-broadside",
510 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = "speaker-dmic-broadside",
511 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = "speaker-dmic-broadside",
512 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = "speaker-dmic-broadside",
513 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = "speaker-dmic-broadside",
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]514 [SND_DEVICE_IN_HANDSET_QMIC] = "quad-mic",
515 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = "quad-mic",
516 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = "quad-mic",
517 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = "quad-mic",
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]518 [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = "quad-mic",
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -0700[diff] [blame]519 [SND_DEVICE_IN_THREE_MIC] = "three-mic",
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]520 [SND_DEVICE_IN_HANDSET_TMIC] = "three-mic",
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]521 [SND_DEVICE_IN_VOICE_REC_TMIC] = "three-mic",
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]522 [SND_DEVICE_IN_UNPROCESSED_MIC] = "unprocessed-mic",
Aalique Grahame97748be2017-10-10 14:32:29 -0700[diff] [blame]523 [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = "unprocessed-stereo-mic",
524 [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = "unprocessed-three-mic",
525 [SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = "unprocessed-quad-mic",
526 [SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = "unprocessed-headset-mic",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]527};
528
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]529// Platform specific backend bit width table
530static int backend_bit_width_table[SND_DEVICE_MAX] = {0};
531
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]532static struct audio_effect_config effect_config_table[GET_IN_DEVICE_INDEX(SND_DEVICE_MAX)][EFFECT_MAX] = {
533 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FLUENCE_PROV2, 0x0, 0x10EAF, 0x01},
534 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FLUENCE_PROV2, 0x0, 0x10EAF, 0x02},
535 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)][EFFECT_AEC] = {TX_VOICE_DM_FV5_BROADSIDE, 0x0,
536 0x10EAF, 0x01},
537 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)][EFFECT_NS] = {TX_VOICE_DM_FV5_BROADSIDE, 0x0,
538 0x10EAF, 0x02},
539 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x01},
540 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x02},
541 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_SM, 0x0, 0x10EAF, 0x01},
542 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_SM, 0x0, 0x10EAF, 0x02},
543 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x01},
544 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_DM, 0x0, 0x10EAF, 0x02},
545 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)][EFFECT_AEC] = {TX_VOICE_FV5ECNS_SM, 0x0, 0x10EAF, 0x01},
546 [GET_IN_DEVICE_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)][EFFECT_NS] = {TX_VOICE_FV5ECNS_SM, 0x0, 0x10EAF, 0x02},
547};
548
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]549/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]550static int acdb_device_table[SND_DEVICE_MAX] = {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]551 [SND_DEVICE_NONE] = -1,
552 [SND_DEVICE_OUT_HANDSET] = 7,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]553 [SND_DEVICE_OUT_SPEAKER] = 14,
Tanya Finkel87af1a52015-03-27 14:54:23 -0700[diff] [blame]554 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = 130,
555 [SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = 130,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]556 [SND_DEVICE_OUT_SPEAKER_VBAT] = 14,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]557 [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]558 [SND_DEVICE_OUT_LINE] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]559 [SND_DEVICE_OUT_HEADPHONES] = 10,
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]560 [SND_DEVICE_OUT_HEADPHONES_DSD] = 10,
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]561 [SND_DEVICE_OUT_HEADPHONES_44_1] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]562 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]563 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = 10,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]564 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = 130,
565 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = 130,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]566 [SND_DEVICE_OUT_VOICE_HANDSET] = 7,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]567 [SND_DEVICE_OUT_VOICE_SPEAKER] = 14,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]568 [SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = 14,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]569 [SND_DEVICE_OUT_VOICE_SPEAKER_2] = 14,
570 [SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = 14,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]571 [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10,
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]572 [SND_DEVICE_OUT_VOICE_LINE] = 10,
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]573 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = 10,
574 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = 10,
575 [SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = 10,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]576 [SND_DEVICE_OUT_HDMI] = 18,
Vidyakumar Athotac29d4ab2013-11-14 16:58:02 -0800[diff] [blame]577 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]578 [SND_DEVICE_OUT_DISPLAY_PORT] = 18,
579 [SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = 14,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]580 [SND_DEVICE_OUT_BT_SCO] = 22,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]581 [SND_DEVICE_OUT_BT_SCO_WB] = 39,
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]582 [SND_DEVICE_OUT_BT_A2DP] = 20,
583 [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = 14,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]584 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
585 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
586 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]587 [SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = 17,
588 [SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = 17,
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]589 [SND_DEVICE_OUT_VOICE_TX] = 45,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]590 [SND_DEVICE_OUT_AFE_PROXY] = 0,
Vidyakumar Athotab9522202014-01-14 20:08:27 -0800[diff] [blame]591 [SND_DEVICE_OUT_USB_HEADSET] = 45,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]592 [SND_DEVICE_OUT_VOICE_USB_HEADSET] = 45,
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]593 [SND_DEVICE_OUT_USB_HEADPHONES] = 45,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]594 [SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = 45,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]595 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]596 [SND_DEVICE_OUT_TRANSMISSION_FM] = 0,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]597 [SND_DEVICE_OUT_ANC_HEADSET] = 26,
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]598 [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]599 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26,
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]600 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]601 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26,
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]602 [SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = 27,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]603 [SND_DEVICE_OUT_ANC_HANDSET] = 103,
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]604 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 124,
605 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = 101,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]606 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = 101,
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]607 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = 124,
608 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = 101,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]609 [SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT] = 101,
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]610 [SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS] = 134,
611 [SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS] = 134,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]612 [SND_DEVICE_IN_HANDSET_MIC] = 4,
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]613 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = 4,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]614 [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106,
615 [SND_DEVICE_IN_HANDSET_MIC_NS] = 107,
616 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]617 [SND_DEVICE_IN_HANDSET_DMIC] = 41,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]618 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109,
619 [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110,
620 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]621 [SND_DEVICE_IN_SPEAKER_MIC] = 11,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]622 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112,
623 [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113,
624 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]625 [SND_DEVICE_IN_SPEAKER_DMIC] = 43,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]626 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115,
627 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116,
628 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]629 [SND_DEVICE_IN_HEADSET_MIC] = 8,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]630 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]631 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11,
632 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
633 [SND_DEVICE_IN_HDMI_MIC] = 4,
634 [SND_DEVICE_IN_BT_SCO_MIC] = 21,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]635 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = 122,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]636 [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]637 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = 123,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]638 [SND_DEVICE_IN_CAMCORDER_MIC] = 4,
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]639 [SND_DEVICE_IN_VOICE_DMIC] = 41,
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]640 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43,
Vidyakumar Athotaadfe4e32013-12-13 14:51:26 -0800[diff] [blame]641 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]642 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16,
643 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
644 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]645 [SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = 16,
646 [SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = 16,
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]647 [SND_DEVICE_IN_VOICE_RX] = 44,
648
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]649 [SND_DEVICE_IN_VOICE_REC_MIC] = 4,
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]650 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107,
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]651 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34,
652 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41,
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]653 [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]654 [SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = 44,
655 [SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = 44,
656 [SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = 44,
657 [SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = 44,
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]658 [SND_DEVICE_IN_CAPTURE_FM] = 0,
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]659 [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]660 [SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = 105,
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]661 [SND_DEVICE_IN_QUAD_MIC] = 46,
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]662 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34,
663 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35,
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]664 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]665 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = 102,
666 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = 102,
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]667 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = 12,
668 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = 12,
669 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = 119,
670 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = 121,
671 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120,
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]672 [SND_DEVICE_IN_HANDSET_QMIC] = 125,
673 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = 126,
674 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = 127,
675 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = 129,
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]676 [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = 125,
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]677 [SND_DEVICE_IN_THREE_MIC] = 46, /* for APSS Surround Sound Recording */
678 [SND_DEVICE_IN_HANDSET_TMIC] = 125, /* for 3mic recording with fluence */
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]679 [SND_DEVICE_IN_VOICE_REC_TMIC] = 125,
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]680 [SND_DEVICE_IN_UNPROCESSED_MIC] = 143,
681 [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = 144,
682 [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = 145,
683 [SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = 146,
684 [SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = 147,
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]685};
686
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]687struct name_to_index {
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]688 char name[100];
689 unsigned int index;
690};
691
692#define TO_NAME_INDEX(X) #X, X
693
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]694/* Used to get index from parsed string */
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]695static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = {
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]696 {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)},
697 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]698 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_EXTERNAL_1)},
699 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_EXTERNAL_2)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]700 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_VBAT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]701 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},
702 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]703 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_DSD)},
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]704 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES_44_1)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]705 {TO_NAME_INDEX(SND_DEVICE_OUT_LINE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]706 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]707 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_LINE)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]708 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1)},
709 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]710 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET)},
711 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]712 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_VBAT)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]713 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2)},
714 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]715 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HEADPHONES)},
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]716 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_LINE)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]717 {TO_NAME_INDEX(SND_DEVICE_OUT_HDMI)},
718 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]719 {TO_NAME_INDEX(SND_DEVICE_OUT_DISPLAY_PORT)},
720 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]721 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
722 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]723 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_A2DP)},
724 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]725 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
726 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
727 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]728 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_SCO)},
729 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB)},
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]730 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_USB)},
731 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_USB)},
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]732 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TX)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]733 {TO_NAME_INDEX(SND_DEVICE_OUT_AFE_PROXY)},
734 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]735 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_USB_HEADSET)},
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]736 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADPHONES)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]737 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_USB_HEADPHONES)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]738 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)},
739 {TO_NAME_INDEX(SND_DEVICE_OUT_TRANSMISSION_FM)},
740 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HEADSET)},
741 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_FB_HEADSET)},
742 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_HEADSET)},
743 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)},
744 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET)},
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]745 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]746 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HANDSET)},
747 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)},
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]748 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]749 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED)},
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]750 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT)},
751 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]752 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT)},
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]753 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS)},
754 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]755 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC)},
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]756 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_EXTERNAL)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]757 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC)},
758 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_NS)},
759 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)},
760 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC)},
761 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC)},
762 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_NS)},
763 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)},
764 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC)},
765 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC)},
766 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_NS)},
767 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)},
768 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC)},
769 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC)},
770 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS)},
771 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)},
772 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC)},
773 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_FLUENCE)},
774 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC)},
775 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_HEADSET_MIC)},
776 {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_MIC)},
777 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]778 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_NREC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]779 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]780 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]781 {TO_NAME_INDEX(SND_DEVICE_IN_CAMCORDER_MIC)},
782 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC)},
783 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC)},
784 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_QMIC)},
785 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC)},
786 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC)},
787 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC)},
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]788 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC)},
789 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]790 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC)},
791 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_NS)},
792 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)},
793 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)},
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]794 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RX)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]795 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)},
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]796 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_USB_HEADSET_MIC)},
797 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC)},
798 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC)},
799 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC_AEC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]800 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_FM)},
801 {TO_NAME_INDEX(SND_DEVICE_IN_AANC_HANDSET_MIC)},
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]802 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]803 {TO_NAME_INDEX(SND_DEVICE_IN_QUAD_MIC)},
804 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_STEREO_DMIC)},
805 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_STEREO_DMIC)},
806 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)},
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]807 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1)},
808 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2)},
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]809 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE)},
810 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE)},
811 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE)},
812 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE)},
813 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)},
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]814 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_QMIC)},
815 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC)},
816 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_NS)},
817 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)},
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]818 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE)},
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]819 {TO_NAME_INDEX(SND_DEVICE_IN_THREE_MIC)},
820 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC)},
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]821 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_TMIC)},
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]822 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_MIC)},
823 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_STEREO_MIC)},
824 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_THREE_MIC)},
825 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_QUAD_MIC)},
826 {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC)},
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]827};
828
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]829static char * backend_tag_table[SND_DEVICE_MAX] = {0};
830static char * hw_interface_table[SND_DEVICE_MAX] = {0};
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]831
832static struct name_to_index usecase_name_index[AUDIO_USECASE_MAX] = {
833 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_DEEP_BUFFER)},
834 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_LOW_LATENCY)},
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700[diff] [blame]835 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_ULL)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]836 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MULTI_CH)},
837 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD)},
Alexy Joseph2f89cfa2014-10-06 12:15:01 -0700[diff] [blame]838 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD2)},
839 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD3)},
840 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD4)},
841 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD5)},
842 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD6)},
843 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD7)},
844 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD8)},
845 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD9)},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]846 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MMAP)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]847 {TO_NAME_INDEX(USECASE_AUDIO_RECORD)},
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530[diff] [blame]848 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS)},
849 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS2)},
850 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS3)},
851 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_COMPRESS4)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]852 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_LOW_LATENCY)},
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]853 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_MMAP)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]854 {TO_NAME_INDEX(USECASE_VOICE_CALL)},
855 {TO_NAME_INDEX(USECASE_VOICE2_CALL)},
856 {TO_NAME_INDEX(USECASE_VOLTE_CALL)},
857 {TO_NAME_INDEX(USECASE_QCHAT_CALL)},
858 {TO_NAME_INDEX(USECASE_VOWLAN_CALL)},
Shiv Maliyappanahallif2d2a492016-05-11 22:03:47 -0700[diff] [blame]859 {TO_NAME_INDEX(USECASE_VOICEMMODE1_CALL)},
860 {TO_NAME_INDEX(USECASE_VOICEMMODE2_CALL)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]861 {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK)},
862 {TO_NAME_INDEX(USECASE_INCALL_REC_DOWNLINK)},
863 {TO_NAME_INDEX(USECASE_INCALL_REC_UPLINK_AND_DOWNLINK)},
864 {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO)},
Satya Krishna Pindiprolic6b0a742017-02-03 14:37:18 +0530[diff] [blame]865 {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO_WB)},
Shiv Maliyappanahallie236ff02016-05-26 11:47:48 -0700[diff] [blame]866 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_FM)},
867 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_FM_VIRTUAL)},
Stephen Oglesbyf8a7bf92016-05-11 14:23:16 -0700[diff] [blame]868 {TO_NAME_INDEX(USECASE_AUDIO_SPKR_CALIB_RX)},
869 {TO_NAME_INDEX(USECASE_AUDIO_SPKR_CALIB_TX)},
Garmond Leunge1e8c762016-06-27 16:35:15 -0700[diff] [blame]870 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_AFE_PROXY)},
871 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_AFE_PROXY)},
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]872 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_EXT_DISP_SILENCE)},
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]873};
874
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]875#define NO_COLS 2
876#ifdef PLATFORM_APQ8084
877static int msm_device_to_be_id [][NO_COLS] = {
878 {AUDIO_DEVICE_OUT_EARPIECE , 2},
879 {AUDIO_DEVICE_OUT_SPEAKER , 2},
880 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 2},
881 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 2},
882 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
883 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
884 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
885 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
886 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
887 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
888 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
889 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
890 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
891 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
892 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
893 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
894 {AUDIO_DEVICE_OUT_PROXY , 9},
895 {AUDIO_DEVICE_OUT_FM , 7},
896 {AUDIO_DEVICE_OUT_FM_TX , 8},
897 {AUDIO_DEVICE_OUT_ALL , -1},
898 {AUDIO_DEVICE_NONE , -1},
899 {AUDIO_DEVICE_OUT_DEFAULT , -1},
900};
901#elif PLATFORM_MSM8994
902static int msm_device_to_be_id [][NO_COLS] = {
903 {AUDIO_DEVICE_OUT_EARPIECE , 2},
904 {AUDIO_DEVICE_OUT_SPEAKER , 2},
905 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 2},
906 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 2},
907 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 38},
908 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 38},
909 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 38},
910 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
911 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
912 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
913 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
914 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
915 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
916 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
917 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
918 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
919 {AUDIO_DEVICE_OUT_PROXY , 9},
920/* Add the correct be ids */
921 {AUDIO_DEVICE_OUT_FM , 7},
922 {AUDIO_DEVICE_OUT_FM_TX , 8},
923 {AUDIO_DEVICE_OUT_ALL , -1},
924 {AUDIO_DEVICE_NONE , -1},
925 {AUDIO_DEVICE_OUT_DEFAULT , -1},
926};
Pradnya Chaphekarf0b1cfe2015-04-15 16:52:49 -0700[diff] [blame]927#elif PLATFORM_MSM8996
928static int msm_device_to_be_id [][NO_COLS] = {
929 {AUDIO_DEVICE_OUT_EARPIECE , 2},
930 {AUDIO_DEVICE_OUT_SPEAKER , 2},
Sharad Sangle1f705a72016-10-05 20:01:39 +0530[diff] [blame]931 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 41},
932 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 41},
Pradnya Chaphekarf0b1cfe2015-04-15 16:52:49 -0700[diff] [blame]933 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
934 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
935 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
936 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
937 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
938 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
939 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
940 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
941 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
942 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
943 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
944 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
945 {AUDIO_DEVICE_OUT_PROXY , 9},
946/* Add the correct be ids */
947 {AUDIO_DEVICE_OUT_FM , 7},
948 {AUDIO_DEVICE_OUT_FM_TX , 8},
949 {AUDIO_DEVICE_OUT_ALL , -1},
950 {AUDIO_DEVICE_NONE , -1},
951 {AUDIO_DEVICE_OUT_DEFAULT , -1},
952};
Weiyin Jiang6f4c8062016-11-23 15:30:29 +0800[diff] [blame]953#elif PLATFORM_MSM8998
954static int msm_device_to_be_id [][NO_COLS] = {
955 {AUDIO_DEVICE_OUT_EARPIECE , 2},
956 {AUDIO_DEVICE_OUT_SPEAKER , 2},
957 {AUDIO_DEVICE_OUT_WIRED_HEADSET , 41},
958 {AUDIO_DEVICE_OUT_WIRED_HEADPHONE , 41},
959 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO , 11},
960 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET , 11},
961 {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT , 11},
962 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP , -1},
963 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES , -1},
964 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER , -1},
965 {AUDIO_DEVICE_OUT_AUX_DIGITAL , 4},
966 {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET , 9},
967 {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET , 9},
968 {AUDIO_DEVICE_OUT_USB_ACCESSORY , -1},
969 {AUDIO_DEVICE_OUT_USB_DEVICE , -1},
970 {AUDIO_DEVICE_OUT_REMOTE_SUBMIX , 9},
971 {AUDIO_DEVICE_OUT_PROXY , 9},
972/* Add the correct be ids */
973 {AUDIO_DEVICE_OUT_FM , 7},
974 {AUDIO_DEVICE_OUT_FM_TX , 8},
975 {AUDIO_DEVICE_OUT_ALL , -1},
976 {AUDIO_DEVICE_NONE , -1},
977 {AUDIO_DEVICE_OUT_DEFAULT , -1},
978};
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]979#else
980static int msm_device_to_be_id [][NO_COLS] = {
981 {AUDIO_DEVICE_NONE, -1},
982};
983#endif
984static int msm_be_id_array_len =
985 sizeof(msm_device_to_be_id) / sizeof(msm_device_to_be_id[0]);
986
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]987#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]988#define PCM_OFFLOAD_PLATFORM_DELAY (30*1000LL)
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]989#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700[diff] [blame]990#define ULL_PLATFORM_DELAY (6*1000LL)
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]991#define MMAP_PLATFORM_DELAY (3*1000LL)
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]992
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]993static void update_codec_type_and_interface(struct platform_data * my_data, const char *snd_card_name) {
994
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]995 if (!strncmp(snd_card_name, "sdm670-skuw-snd-card",
996 sizeof("sdm670-skuw-snd-card")) ||
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]997 !strncmp(snd_card_name, "sdm660-snd-card-skush",
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]998 sizeof("sdm660-snd-card-skush")) ||
999 !strncmp(snd_card_name, "sdm660-snd-card-mtp",
1000 sizeof("sdm660-snd-card-mtp")) ||
Sharad Sangle999cf722017-10-18 18:25:47 +0530[diff] [blame]1001 !strncmp(snd_card_name, "sdm670-mtp-snd-card",
1002 sizeof("sdm670-mtp-snd-card"))) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1003 ALOGI("%s: snd_card_name: %s",__func__,snd_card_name);
1004 my_data->is_internal_codec = true;
1005 my_data->is_slimbus_interface = false;
1006 }
1007}
1008
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1009static bool can_enable_mbdrc_on_device(snd_device_t snd_device)
1010{
1011 bool ret = false;
1012
1013 if (snd_device == SND_DEVICE_OUT_SPEAKER ||
1014 snd_device == SND_DEVICE_OUT_SPEAKER_WSA ||
1015 snd_device == SND_DEVICE_OUT_SPEAKER_VBAT ||
1016 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
1017 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT ||
1018 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
1019 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
1020 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_WSA ||
1021 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_WSA) {
1022 ret = true;
1023 }
1024 return ret;
1025}
1026
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]1027static const char *platform_get_mixer_control(struct mixer_ctl *);
1028
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1029bool platform_send_gain_dep_cal(void *platform, int level) {
1030 bool ret_val = false;
1031 struct platform_data *my_data = (struct platform_data *)platform;
1032 struct audio_device *adev = my_data->adev;
1033 int acdb_dev_id, app_type;
1034 int acdb_dev_type = MSM_SNDDEV_CAP_RX;
1035 int mode = CAL_MODE_RTAC;
1036 struct listnode *node;
1037 struct audio_usecase *usecase;
1038
1039 if (my_data->acdb_send_gain_dep_cal == NULL) {
1040 ALOGE("%s: dlsym error for acdb_send_gain_dep_cal", __func__);
1041 return ret_val;
1042 }
1043
1044 if (!voice_is_in_call(adev)) {
1045 ALOGV("%s: Not Voice call usecase, apply new cal for level %d",
1046 __func__, level);
1047
1048 // find the current active sound device
1049 list_for_each(node, &adev->usecase_list) {
1050 usecase = node_to_item(node, struct audio_usecase, list);
1051
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700[diff] [blame]1052 if (usecase != NULL && usecase->type == PCM_PLAYBACK) {
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1053 int new_snd_device[2] = {0};
1054 int i, num_devices = 1;
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1055
1056 ALOGV("%s: out device is %d", __func__, usecase->out_snd_device);
1057 app_type = usecase->stream.out->app_type_cfg.app_type;
Preetam Singh Ranawatafe17c72017-05-16 13:12:34 +0530[diff] [blame]1058 acdb_dev_id = acdb_device_table[usecase->out_snd_device];
vivek mehta0b8ea6f2015-07-23 17:27:26 -0700[diff] [blame]1059
Preetam Singh Ranawatbfec31e2017-05-04 11:51:50 +0530[diff] [blame]1060 if (platform_split_snd_device(my_data, usecase->out_snd_device,
1061 &num_devices, new_snd_device) < 0)
1062 new_snd_device[0] = usecase->out_snd_device;
1063
1064 for (i = 0; i < num_devices; i++)
1065 if (can_enable_mbdrc_on_device(new_snd_device[i])) {
1066 if (audio_extn_spkr_prot_is_enabled())
1067 acdb_dev_id = platform_get_spkr_prot_acdb_id(new_snd_device[i]);
1068 else
1069 acdb_dev_id = acdb_device_table[new_snd_device[i]];
1070 }
vivek mehta0b8ea6f2015-07-23 17:27:26 -0700[diff] [blame]1071
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]1072 if (!my_data->acdb_send_gain_dep_cal(acdb_dev_id, app_type,
1073 acdb_dev_type, mode, level)) {
1074 // set ret_val true if at least one calibration is set successfully
1075 ret_val = true;
1076 } else {
1077 ALOGE("%s: my_data->acdb_send_gain_dep_cal failed ", __func__);
1078 }
1079 } else {
1080 ALOGW("%s: Usecase list is empty", __func__);
1081 }
1082 }
1083 } else {
1084 ALOGW("%s: Voice call in progress .. ignore setting new cal",
1085 __func__);
1086 }
1087 return ret_val;
1088}
1089
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1090void platform_set_gsm_mode(void *platform, bool enable)
1091{
1092 struct platform_data *my_data = (struct platform_data *)platform;
1093 struct audio_device *adev = my_data->adev;
1094
1095 if (my_data->gsm_mode_enabled) {
1096 my_data->gsm_mode_enabled = false;
1097 ALOGV("%s: disabling gsm mode", __func__);
1098 audio_route_reset_and_update_path(adev->audio_route, "gsm-mode");
1099 }
1100
1101 if (enable) {
1102 my_data->gsm_mode_enabled = true;
1103 ALOGD("%s: enabling gsm mode", __func__);
1104 audio_route_apply_and_update_path(adev->audio_route, "gsm-mode");
1105 }
1106}
1107
1108void platform_set_echo_reference(struct audio_device *adev, bool enable,
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]1109 audio_devices_t out_device __unused)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1110{
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1111 struct platform_data *my_data = (struct platform_data *)adev->platform;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1112
1113 if (strcmp(my_data->ec_ref_mixer_path, "")) {
1114 ALOGV("%s: disabling %s", __func__, my_data->ec_ref_mixer_path);
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1115 audio_route_reset_and_update_path(adev->audio_route,
1116 my_data->ec_ref_mixer_path);
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]1117 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1118
Ravi Kumar Alamandad1c85bb2014-11-17 18:36:24 -0800[diff] [blame]1119 if (enable) {
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1120 /*
1121 * If native audio device reference count > 0, then apply codec EC otherwise
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1122 * fallback to Speakers with VBat if enabled or default
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1123 */
1124 if (adev->snd_dev_ref_cnt[SND_DEVICE_OUT_HEADPHONES_44_1] > 0)
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1125 strlcpy(my_data->ec_ref_mixer_path, "echo-reference headphones-44.1",
1126 sizeof(my_data->ec_ref_mixer_path));
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]1127 else if (adev->snd_dev_ref_cnt[SND_DEVICE_OUT_SPEAKER_VBAT] > 0)
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1128 strlcpy(my_data->ec_ref_mixer_path, "echo-reference speaker-vbat",
1129 sizeof(my_data->ec_ref_mixer_path));
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1130 else
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1131 strlcpy(my_data->ec_ref_mixer_path, "echo-reference",
1132 sizeof(my_data->ec_ref_mixer_path));
Ravi Kumar Alamandad1c85bb2014-11-17 18:36:24 -0800[diff] [blame]1133
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]1134 ALOGD("%s: enabling %s", __func__, my_data->ec_ref_mixer_path);
1135 audio_route_apply_and_update_path(adev->audio_route, my_data->ec_ref_mixer_path);
1136 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1137}
1138
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1139static struct csd_data *open_csd_client(bool i2s_ext_modem)
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1140{
1141 struct csd_data *csd = calloc(1, sizeof(struct csd_data));
1142
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -0700[diff] [blame]1143 if (!csd) {
1144 ALOGE("failed to allocate csd_data mem");
1145 return NULL;
1146 }
1147
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1148 csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW);
1149 if (csd->csd_client == NULL) {
1150 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT);
1151 goto error;
1152 } else {
1153 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT);
1154
1155 csd->deinit = (deinit_t)dlsym(csd->csd_client,
1156 "csd_client_deinit");
1157 if (csd->deinit == NULL) {
1158 ALOGE("%s: dlsym error %s for csd_client_deinit", __func__,
1159 dlerror());
1160 goto error;
1161 }
1162 csd->disable_device = (disable_device_t)dlsym(csd->csd_client,
1163 "csd_client_disable_device");
1164 if (csd->disable_device == NULL) {
1165 ALOGE("%s: dlsym error %s for csd_client_disable_device",
1166 __func__, dlerror());
1167 goto error;
1168 }
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]1169 csd->enable_device_config = (enable_device_config_t)dlsym(csd->csd_client,
1170 "csd_client_enable_device_config");
1171 if (csd->enable_device_config == NULL) {
1172 ALOGE("%s: dlsym error %s for csd_client_enable_device_config",
1173 __func__, dlerror());
1174 goto error;
1175 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1176 csd->enable_device = (enable_device_t)dlsym(csd->csd_client,
1177 "csd_client_enable_device");
1178 if (csd->enable_device == NULL) {
1179 ALOGE("%s: dlsym error %s for csd_client_enable_device",
1180 __func__, dlerror());
1181 goto error;
1182 }
1183 csd->start_voice = (start_voice_t)dlsym(csd->csd_client,
1184 "csd_client_start_voice");
1185 if (csd->start_voice == NULL) {
1186 ALOGE("%s: dlsym error %s for csd_client_start_voice",
1187 __func__, dlerror());
1188 goto error;
1189 }
1190 csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client,
1191 "csd_client_stop_voice");
1192 if (csd->stop_voice == NULL) {
1193 ALOGE("%s: dlsym error %s for csd_client_stop_voice",
1194 __func__, dlerror());
1195 goto error;
1196 }
1197 csd->volume = (volume_t)dlsym(csd->csd_client,
1198 "csd_client_volume");
1199 if (csd->volume == NULL) {
1200 ALOGE("%s: dlsym error %s for csd_client_volume",
1201 __func__, dlerror());
1202 goto error;
1203 }
1204 csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client,
1205 "csd_client_mic_mute");
1206 if (csd->mic_mute == NULL) {
1207 ALOGE("%s: dlsym error %s for csd_client_mic_mute",
1208 __func__, dlerror());
1209 goto error;
1210 }
1211 csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client,
1212 "csd_client_slow_talk");
1213 if (csd->slow_talk == NULL) {
1214 ALOGE("%s: dlsym error %s for csd_client_slow_talk",
1215 __func__, dlerror());
1216 goto error;
1217 }
1218 csd->start_playback = (start_playback_t)dlsym(csd->csd_client,
1219 "csd_client_start_playback");
1220 if (csd->start_playback == NULL) {
1221 ALOGE("%s: dlsym error %s for csd_client_start_playback",
1222 __func__, dlerror());
1223 goto error;
1224 }
1225 csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client,
1226 "csd_client_stop_playback");
1227 if (csd->stop_playback == NULL) {
1228 ALOGE("%s: dlsym error %s for csd_client_stop_playback",
1229 __func__, dlerror());
1230 goto error;
1231 }
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]1232 csd->set_lch = (set_lch_t)dlsym(csd->csd_client, "csd_client_set_lch");
1233 if (csd->set_lch == NULL) {
1234 ALOGE("%s: dlsym error %s for csd_client_set_lch",
1235 __func__, dlerror());
1236 /* Ignore the error as this is not mandatory function for
1237 * basic voice call to work.
1238 */
1239 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1240 csd->start_record = (start_record_t)dlsym(csd->csd_client,
1241 "csd_client_start_record");
1242 if (csd->start_record == NULL) {
1243 ALOGE("%s: dlsym error %s for csd_client_start_record",
1244 __func__, dlerror());
1245 goto error;
1246 }
1247 csd->stop_record = (stop_record_t)dlsym(csd->csd_client,
1248 "csd_client_stop_record");
1249 if (csd->stop_record == NULL) {
1250 ALOGE("%s: dlsym error %s for csd_client_stop_record",
1251 __func__, dlerror());
1252 goto error;
1253 }
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1254
1255 csd->get_sample_rate = (get_sample_rate_t)dlsym(csd->csd_client,
1256 "csd_client_get_sample_rate");
1257 if (csd->get_sample_rate == NULL) {
1258 ALOGE("%s: dlsym error %s for csd_client_get_sample_rate",
1259 __func__, dlerror());
1260
1261 goto error;
1262 }
1263
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1264 csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init");
1265
1266 if (csd->init == NULL) {
1267 ALOGE("%s: dlsym error %s for csd_client_init",
1268 __func__, dlerror());
1269 goto error;
1270 } else {
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1271 csd->init(i2s_ext_modem);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]1272 }
1273 }
1274 return csd;
1275
1276error:
1277 free(csd);
1278 csd = NULL;
1279 return csd;
1280}
1281
1282void close_csd_client(struct csd_data *csd)
1283{
1284 if (csd != NULL) {
1285 csd->deinit();
1286 dlclose(csd->csd_client);
1287 free(csd);
1288 csd = NULL;
1289 }
1290}
1291
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1292static bool platform_is_i2s_ext_modem(const char *snd_card_name,
1293 struct platform_data *plat_data)
1294{
1295 plat_data->is_i2s_ext_modem = false;
1296
1297 if (!strncmp(snd_card_name, "apq8084-taiko-i2s-mtp-snd-card",
1298 sizeof("apq8084-taiko-i2s-mtp-snd-card")) ||
1299 !strncmp(snd_card_name, "apq8084-taiko-i2s-cdp-snd-card",
Josh Kirschc3894372016-03-28 15:59:48 -0700[diff] [blame]1300 sizeof("apq8084-taiko-i2s-cdp-snd-card")) ||
1301 !strncmp(snd_card_name, "apq8096-tasha-i2c-snd-card",
1302 sizeof("apq8096-tasha-i2c-snd-card"))) {
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1303 plat_data->is_i2s_ext_modem = true;
1304 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]1305 ALOGV("%s, is_i2s_ext_modem:%d soundcard name is %s",__func__,
1306 plat_data->is_i2s_ext_modem, snd_card_name);
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]1307
1308 return plat_data->is_i2s_ext_modem;
Helen Zeng008aebd2014-02-23 19:13:12 -0800[diff] [blame]1309}
1310
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1311static void set_platform_defaults(struct platform_data * my_data)
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1312{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]1313 int32_t dev;
1314 unsigned int count = 0;
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1315 const char *MEDIA_MIMETYPE_AUDIO_ALAC = "audio/alac";
1316 const char *MEDIA_MIMETYPE_AUDIO_APE = "audio/x-ape";
1317
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1318 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1319 backend_tag_table[dev] = NULL;
1320 hw_interface_table[dev] = NULL;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1321 }
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]1322 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]1323 backend_bit_width_table[dev] = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]1324 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1325
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1326 // To overwrite these go to the audio_platform_info.xml file.
1327 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("bt-sco");
1328 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("bt-sco-wb");
1329 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("bt-sco");
1330 backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("bt-sco-wb");
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]1331 backend_tag_table[SND_DEVICE_IN_HDMI_MIC] = strdup("hdmi-mic");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1332 backend_tag_table[SND_DEVICE_OUT_BT_SCO] = strdup("bt-sco");
1333 backend_tag_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("bt-sco-wb");
1334 backend_tag_table[SND_DEVICE_OUT_HDMI] = strdup("hdmi");
1335 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("speaker-and-hdmi");
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]1336 backend_tag_table[SND_DEVICE_OUT_DISPLAY_PORT] = strdup("display-port");
1337 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]1338 backend_tag_table[SND_DEVICE_OUT_VOICE_TX] = strdup("afe-proxy");
1339 backend_tag_table[SND_DEVICE_IN_VOICE_RX] = strdup("afe-proxy");
1340 backend_tag_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("afe-proxy");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1341 backend_tag_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("usb-headset");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1342 backend_tag_table[SND_DEVICE_OUT_VOICE_USB_HEADSET] = strdup("usb-headset");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1343 backend_tag_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("usb-headphones");
Aniket Kumar Latab26135f2017-06-16 12:20:04 -0700[diff] [blame]1344 backend_tag_table[SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = strdup("usb-headset");
1345 backend_tag_table[SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = strdup("usb-headphones");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1346 backend_tag_table[SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = strdup("usb-headphones");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1347 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] =
Sidipotu Ashokeaec6392016-04-19 09:37:57 +0530[diff] [blame]1348 strdup("speaker-and-usb-headphones");
Aniket Kumar Lata6bbd3bb2017-07-21 11:09:21 -0700[diff] [blame]1349 backend_tag_table[SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = strdup("usb-headset-mic");
1350 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]1351 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1352 backend_tag_table[SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1353 backend_tag_table[SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1354 backend_tag_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = strdup("usb-headset-mic");
1355 backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = strdup("usb-headset-mic");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1356 backend_tag_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("capture-fm");
1357 backend_tag_table[SND_DEVICE_OUT_TRANSMISSION_FM] = strdup("transmission-fm");
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]1358 backend_tag_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("headphones-dsd");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1359 backend_tag_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("headphones-44.1");
1360 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = strdup("voice-speaker-vbat");
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]1361 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]1362 backend_tag_table[SND_DEVICE_OUT_BT_A2DP] = strdup("bt-a2dp");
1363 backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("speaker-and-bt-a2dp");
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]1364 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = strdup("speaker-and-headphones");
1365 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = strdup("speaker-and-headphones");
1366 backend_tag_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = strdup("speaker-and-headphones");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1367
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1368 hw_interface_table[SND_DEVICE_OUT_HANDSET] = strdup("SLIMBUS_0_RX");
1369 hw_interface_table[SND_DEVICE_OUT_SPEAKER] = strdup("SLIMBUS_0_RX");
1370 hw_interface_table[SND_DEVICE_OUT_SPEAKER_EXTERNAL_1] = strdup("SLIMBUS_0_RX");
1371 hw_interface_table[SND_DEVICE_OUT_SPEAKER_EXTERNAL_2] = strdup("SLIMBUS_0_RX");
1372 hw_interface_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = strdup("SLIMBUS_0_RX");
1373 hw_interface_table[SND_DEVICE_OUT_SPEAKER_VBAT] = strdup("SLIMBUS_0_RX");
1374 hw_interface_table[SND_DEVICE_OUT_LINE] = strdup("SLIMBUS_6_RX");
1375 hw_interface_table[SND_DEVICE_OUT_HEADPHONES] = strdup("SLIMBUS_6_RX");
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]1376 hw_interface_table[SND_DEVICE_OUT_HEADPHONES_DSD] = strdup("SLIMBUS_2_RX");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]1377 hw_interface_table[SND_DEVICE_OUT_HEADPHONES_44_1] = strdup("SLIMBUS_5_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1378 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]1379 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1380 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1381 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1382 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_LINE] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1383 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1384 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1385 hw_interface_table[SND_DEVICE_OUT_VOICE_HANDSET] = strdup("SLIMBUS_0_RX");
1386 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER] = strdup("SLIMBUS_0_RX");
1387 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_VBAT] = strdup("SLIMBUS_0_RX");
1388 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2] = strdup("SLIMBUS_0_RX");
1389 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT] = strdup("SLIMBUS_0_RX");
1390 hw_interface_table[SND_DEVICE_OUT_VOICE_HEADPHONES] = strdup("SLIMBUS_6_RX");
1391 hw_interface_table[SND_DEVICE_OUT_VOICE_LINE] = strdup("SLIMBUS_6_RX");
1392 hw_interface_table[SND_DEVICE_OUT_HDMI] = strdup("HDMI");
1393 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("SLIMBUS_0_RX-and-HDMI");
1394 hw_interface_table[SND_DEVICE_OUT_DISPLAY_PORT] = strdup("DISPLAY_PORT");
1395 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT] = strdup("SLIMBUS_0_RX-and-DISPLAY_PORT");
1396 hw_interface_table[SND_DEVICE_OUT_BT_SCO] = strdup("SLIMBUS_7_RX");
1397 hw_interface_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("SLIMBUS_7_RX");
1398 hw_interface_table[SND_DEVICE_OUT_BT_A2DP] = strdup("SLIMBUS_7_RX");
1399 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("SLIMBUS_0_RX-and-SLIMBUS_7_RX");
1400 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = strdup("SLIMBUS_6_RX");
1401 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = strdup("SLIMBUS_6_RX");
1402 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]1403 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_USB] = strdup("USB_AUDIO_RX");
1404 hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_USB] = strdup("USB_AUDIO_RX");
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1405 hw_interface_table[SND_DEVICE_OUT_VOICE_TX] = strdup("RT_PROXY_DAI_001_RX");
1406 hw_interface_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("RT_PROXY_DAI_001_RX");
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]1407 hw_interface_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("USB_AUDIO_RX");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1408 hw_interface_table[SND_DEVICE_OUT_VOICE_USB_HEADSET] = strdup("USB_AUDIO_RX");
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]1409 hw_interface_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("USB_AUDIO_RX");
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]1410 hw_interface_table[SND_DEVICE_OUT_VOICE_USB_HEADPHONES] = strdup("USB_AUDIO_RX");
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]1411 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]1412 hw_interface_table[SND_DEVICE_OUT_TRANSMISSION_FM] = strdup("SLIMBUS_8_TX");
1413 hw_interface_table[SND_DEVICE_OUT_ANC_HEADSET] = strdup("SLIMBUS_6_RX");
1414 hw_interface_table[SND_DEVICE_OUT_ANC_FB_HEADSET] = strdup("SLIMBUS_6_RX");
1415 hw_interface_table[SND_DEVICE_OUT_VOICE_ANC_HEADSET] = strdup("SLIMBUS_6_RX");
1416 hw_interface_table[SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = strdup("SLIMBUS_6_RX");
1417 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1418 hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET] = strdup("SLIMBUS_0_RX-and-SLIMBUS_6_RX");
1419 hw_interface_table[SND_DEVICE_OUT_ANC_HANDSET] = strdup("SLIMBUS_0_RX");
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]1420 hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
1421 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
1422 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED] = strdup("SLIMBUS_0_RX");
1423 hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT] = strdup("SLIMBUS_0_RX");
1424 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT] = strdup("SLIMBUS_0_RX");
1425 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]1426 hw_interface_table[SND_DEVICE_OUT_SPEAKER_WSA] = strdup("SLIMBUS_0_RX");
1427 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_WSA] = strdup("SLIMBUS_0_RX");
1428 hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_2_WSA] = strdup("SLIMBUS_0_RX");
1429 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1430 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = strdup("SLIMBUS_0_TX");
1431 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC] = strdup("SLIMBUS_0_TX");
1432 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_NS] = strdup("SLIMBUS_0_TX");
1433 hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1434 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC] = strdup("SLIMBUS_0_TX");
1435 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC] = strdup("SLIMBUS_0_TX");
1436 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_NS] = strdup("SLIMBUS_0_TX");
1437 hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1438 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
1439 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_AEC] = strdup("SLIMBUS_0_TX");
1440 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_NS] = strdup("SLIMBUS_0_TX");
1441 hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1442 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC] = strdup("SLIMBUS_0_TX");
1443 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC] = strdup("SLIMBUS_0_TX");
1444 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_NS] = strdup("SLIMBUS_0_TX");
1445 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1446 hw_interface_table[SND_DEVICE_IN_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
1447 hw_interface_table[SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1448 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
1449 hw_interface_table[SND_DEVICE_IN_VOICE_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
1450 hw_interface_table[SND_DEVICE_IN_HDMI_MIC] = strdup("HDMI");
1451 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("SLIMBUS_7_TX");
1452 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("SLIMBUS_7_TX");
1453 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("SLIMBUS_7_TX");
1454 hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("SLIMBUS_7_TX");
1455 hw_interface_table[SND_DEVICE_IN_CAMCORDER_MIC] = strdup("SLIMBUS_0_TX");
1456 hw_interface_table[SND_DEVICE_IN_VOICE_DMIC] = strdup("SLIMBUS_0_TX");
1457 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = strdup("SLIMBUS_0_TX");
1458 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = strdup("SLIMBUS_0_TX");
1459 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
1460 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1461 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Aniket Kumar Latab26135f2017-06-16 12:20:04 -0700[diff] [blame]1462 hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = strdup("USB_AUDIO_TX");
1463 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]1464 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC] = strdup("SLIMBUS_0_TX");
1465 hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_NS] = strdup("SLIMBUS_0_TX");
1466 hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
1467 hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1468 hw_interface_table[SND_DEVICE_IN_VOICE_RX] = strdup("RT_PROXY_DAI_002_TX");
1469 hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
1470 hw_interface_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("SLIMBUS_8_TX");
1471 hw_interface_table[SND_DEVICE_IN_AANC_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
1472 hw_interface_table[SND_DEVICE_IN_QUAD_MIC] = strdup("SLIMBUS_0_TX");
1473 hw_interface_table[SND_DEVICE_IN_HANDSET_STEREO_DMIC] = strdup("SLIMBUS_0_TX");
1474 hw_interface_table[SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = strdup("SLIMBUS_0_TX");
1475 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = strdup("SLIMBUS_4_TX");
1476 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1] = strdup("SLIMBUS_4_TX");
1477 hw_interface_table[SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2] = strdup("SLIMBUS_4_TX");
1478 hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1479 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1480 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = strdup("SLIMBUS_0_TX");
1481 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = strdup("SLIMBUS_0_TX");
1482 hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = strdup("SLIMBUS_0_TX");
1483 hw_interface_table[SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC] = strdup("SLIMBUS_0_TX");
1484 hw_interface_table[SND_DEVICE_IN_HANDSET_QMIC] = strdup("SLIMBUS_0_TX");
1485 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_AEC] = strdup("SLIMBUS_0_TX");
1486 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_NS] = strdup("SLIMBUS_0_TX");
1487 hw_interface_table[SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
1488 hw_interface_table[SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = strdup("SLIMBUS_0_TX");
1489 hw_interface_table[SND_DEVICE_IN_THREE_MIC] = strdup("SLIMBUS_0_TX");
1490 hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC] = strdup("SLIMBUS_0_TX");
1491 hw_interface_table[SND_DEVICE_IN_VOICE_REC_TMIC] = strdup("SLIMBUS_0_TX");
1492 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_MIC] = strdup("SLIMBUS_0_TX");
1493 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = strdup("SLIMBUS_0_TX");
1494 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = strdup("SLIMBUS_0_TX");
1495 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = strdup("SLIMBUS_0_TX");
1496 hw_interface_table[SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1497
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1498 my_data->max_mic_count = PLATFORM_DEFAULT_MIC_COUNT;
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1499
1500 /*remove ALAC & APE from DSP decoder list based on software decoder availability*/
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]1501 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]1502 count++) {
1503
1504 if (!strncmp(MEDIA_MIMETYPE_AUDIO_ALAC, dsp_only_decoders_mime[count],
1505 strlen(dsp_only_decoders_mime[count]))) {
1506
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]1507 if(property_get_bool("vendor.audio.use.sw.alac.decoder", false)) {
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1508 ALOGD("Alac software decoder is available...removing alac from DSP decoder list");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1509 strlcpy(dsp_only_decoders_mime[count],"none",5);
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1510 }
1511 } else if (!strncmp(MEDIA_MIMETYPE_AUDIO_APE, dsp_only_decoders_mime[count],
1512 strlen(dsp_only_decoders_mime[count]))) {
1513
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]1514 if(property_get_bool("vendor.audio.use.sw.ape.decoder", false)) {
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1515 ALOGD("APE software decoder is available...removing ape from DSP decoder list");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1516 strlcpy(dsp_only_decoders_mime[count],"none",5);
Naresh Tanniru34a303c2016-01-27 17:26:41 +0530[diff] [blame]1517 }
1518 }
1519 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]1520}
1521
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]1522void get_cvd_version(char *cvd_version, struct audio_device *adev)
1523{
1524 struct mixer_ctl *ctl;
1525 int count;
1526 int ret = 0;
1527
1528 ctl = mixer_get_ctl_by_name(adev->mixer, CVD_VERSION_MIXER_CTL);
1529 if (!ctl) {
1530 ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, CVD_VERSION_MIXER_CTL);
1531 goto done;
1532 }
1533 mixer_ctl_update(ctl);
1534
1535 count = mixer_ctl_get_num_values(ctl);
1536 if (count > MAX_CVD_VERSION_STRING_SIZE)
1537 count = MAX_CVD_VERSION_STRING_SIZE;
1538
1539 ret = mixer_ctl_get_array(ctl, cvd_version, count);
1540 if (ret != 0) {
1541 ALOGE("%s: ERROR! mixer_ctl_get_array() failed to get CVD Version", __func__);
1542 goto done;
1543 }
1544
1545done:
1546 return;
1547}
1548
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1549static int hw_util_open(int card_no)
1550{
1551 int fd = -1;
1552 char dev_name[256];
1553
1554 snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
1555 card_no, WCD9XXX_CODEC_HWDEP_NODE);
1556 ALOGD("%s Opening device %s\n", __func__, dev_name);
1557 fd = open(dev_name, O_WRONLY);
1558 if (fd < 0) {
1559 ALOGE("%s: cannot open device '%s'\n", __func__, dev_name);
1560 return fd;
1561 }
1562 ALOGD("%s success", __func__);
1563 return fd;
1564}
1565
1566struct param_data {
1567 int use_case;
1568 int acdb_id;
1569 int get_size;
1570 int buff_size;
1571 int data_size;
1572 void *buff;
1573};
1574
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1575static int send_vbat_adc_data_to_acdb(struct platform_data *plat_data, char *cal_type)
1576{
1577 int ret = 0;
1578 struct mixer_ctl *ctl;
1579 uint16_t vbat_adc_data[2];
1580 struct platform_data *my_data = plat_data;
1581 struct audio_device *adev = my_data->adev;
1582
1583 const char *mixer_ctl_name = "Vbat ADC data";
1584
1585 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1586 if (!ctl) {
1587 ALOGE("%s: Could not get ctl for mixer ctl name - %s",
1588 __func__, mixer_ctl_name);
1589 ret = -EINVAL;
1590 goto done;
1591 }
1592
1593 vbat_adc_data[0] = mixer_ctl_get_value(ctl, 0);
1594 vbat_adc_data[1] = mixer_ctl_get_value(ctl, 1);
1595
1596 ALOGD("%s: Vbat ADC output values: Dcp1: %d , Dcp2: %d",
1597 __func__, vbat_adc_data[0], vbat_adc_data[1]);
1598
1599 ret = my_data->acdb_set_codec_data(&vbat_adc_data[0], cal_type);
1600
1601done:
1602 return ret;
1603}
1604
1605static void send_codec_cal(acdb_loader_get_calibration_t acdb_loader_get_calibration,
1606 struct platform_data *plat_data, int fd)
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1607{
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1608 int type;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1609
1610 for (type = WCD9XXX_ANC_CAL; type < WCD9XXX_MAX_CAL; type++) {
1611 struct wcdcal_ioctl_buffer codec_buffer;
1612 struct param_data calib;
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1613 int ret;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1614
Bharath Ramachandramurthy63a47ef2015-08-31 17:41:46 -0700[diff] [blame]1615 /* MAD calibration is handled by sound trigger HAL, skip here */
1616 if (type == WCD9XXX_MAD_CAL)
1617 continue;
1618
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1619 ret = 0;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1620
Banajit Goswami4dc87fb2015-10-11 21:46:07 -0700[diff] [blame]1621 if ((plat_data->is_vbat_speaker) && (WCD9XXX_VBAT_CAL == type)) {
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1622 ret = send_vbat_adc_data_to_acdb(plat_data, cal_name_info[type]);
1623 if (ret < 0)
1624 ALOGE("%s error in sending vbat adc data to acdb", __func__);
1625 }
1626
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1627 calib.get_size = 1;
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1628 ret = acdb_loader_get_calibration(cal_name_info[type],
1629 sizeof(struct param_data),
1630 &calib);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1631 if (ret < 0) {
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1632 ALOGE("%s: %s get_calibration size failed, err = %d\n",
1633 __func__, cal_name_info[type], ret);
1634 continue;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1635 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1636
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1637 calib.get_size = 0;
1638 calib.buff = malloc(calib.buff_size);
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1639 if (!calib.buff) {
1640 ALOGE("%s: %s: No Memory for size = %d\n",
1641 __func__, cal_name_info[type], calib.buff_size);
1642 continue;
1643 }
1644
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1645 ret = acdb_loader_get_calibration(cal_name_info[type],
1646 sizeof(struct param_data), &calib);
1647 if (ret < 0) {
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1648 ALOGE("%s: %s get_calibration failed, err = %d\n",
1649 __func__, cal_name_info[type], ret);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1650 free(calib.buff);
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1651 continue;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1652 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1653
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1654 codec_buffer.buffer = calib.buff;
1655 codec_buffer.size = calib.data_size;
1656 codec_buffer.cal_type = type;
1657 if (ioctl(fd, SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE, &codec_buffer) < 0)
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1658 ALOGE("%s: %s Failed to call ioctl, err=%d",
1659 __func__, cal_name_info[type], errno);
1660 else
1661 ALOGD("%s: %s cal sent successfully\n",
1662 __func__, cal_name_info[type]);
1663
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1664 free(calib.buff);
1665 }
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1666}
1667
1668static void audio_hwdep_send_cal(struct platform_data *plat_data)
1669{
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]1670 int fd = plat_data->hw_dep_fd;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1671
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]1672 if (fd < 0)
1673 fd = hw_util_open(plat_data->adev->snd_card);
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1674 if (fd == -1) {
1675 ALOGE("%s error open\n", __func__);
1676 return;
1677 }
1678
1679 acdb_loader_get_calibration = (acdb_loader_get_calibration_t)
1680 dlsym(plat_data->acdb_handle, "acdb_loader_get_calibration");
1681
1682 if (acdb_loader_get_calibration == NULL) {
1683 ALOGE("%s: ERROR. dlsym Error:%s acdb_loader_get_calibration", __func__,
1684 dlerror());
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]1685 if (fd >= 0) {
1686 close(fd);
1687 plat_data->hw_dep_fd = -1;
1688 }
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1689 return;
1690 }
Bhalchandra Gajare7c1ad7c2015-07-17 17:12:09 -0700[diff] [blame]1691
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]1692 send_codec_cal(acdb_loader_get_calibration, plat_data, fd);
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]1693 plat_data->hw_dep_fd = fd;
Anish Kumar55e6df22014-08-26 17:38:05 -0700[diff] [blame]1694}
1695
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1696const char * get_snd_card_name_for_acdb_loader(const char *snd_card_name) {
1697
1698 if(snd_card_name == NULL)
1699 return NULL;
1700
1701 if(!strncmp(snd_card_name, "sdm660-tashalite-snd-card",
1702 sizeof("sdm660-tashalite-snd-card"))) {
1703 ALOGD("using tasha ACDB files for tasha-lite");
1704 return "sdm660-tasha-snd-card";
1705 }
Sharad Sangled39232d2017-08-08 20:27:18 +0530[diff] [blame]1706 if(!strncmp(snd_card_name, "sdm670-tashalite-snd-card",
1707 sizeof("sdm670-tashalite-snd-card"))) {
1708 ALOGD("using tasha ACDB files for tasha-lite");
1709 return "sdm670-tasha-snd-card";
1710 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1711 return snd_card_name;
1712}
1713
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]1714static int platform_acdb_init(void *platform)
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1715{
1716 struct platform_data *my_data = (struct platform_data *)platform;
1717 char *cvd_version = NULL;
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1718 const char *snd_card_name;
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]1719 int result = -1;
1720 struct listnode *node;
1721 struct meta_key_list *key_info;
1722 int key = 0;
1723
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1724 cvd_version = calloc(1, MAX_CVD_VERSION_STRING_SIZE);
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1725 if (!cvd_version) {
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1726 ALOGE("Failed to allocate cvd version");
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1727 return -1;
1728 } else {
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1729 get_cvd_version(cvd_version, my_data->adev);
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]1730 }
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1731
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1732 snd_card_name = mixer_get_name(my_data->adev->mixer);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1733 snd_card_name = get_snd_card_name_for_acdb_loader(snd_card_name);
1734
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]1735 if (my_data->acdb_init_v3) {
1736 result = my_data->acdb_init_v3(snd_card_name, cvd_version,
1737 &my_data->acdb_meta_key_list);
1738 } else if (my_data->acdb_init) {
1739 node = list_head(&my_data->acdb_meta_key_list);
1740 key_info = node_to_item(node, struct meta_key_list, list);
1741 key = key_info->cal_info.nKey;
1742 result = my_data->acdb_init(snd_card_name, cvd_version, key);
1743 }
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]1744
1745 /* Save these variables in platform_data. These will be used
1746 while reloading ACDB files during run time. */
1747 strlcpy(my_data->cvd_version, cvd_version, MAX_CVD_VERSION_STRING_SIZE);
1748 strlcpy(my_data->snd_card_name, snd_card_name,
1749 MAX_SND_CARD_STRING_SIZE);
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]1750
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]1751 if (cvd_version)
1752 free(cvd_version);
1753 if (!result) {
1754 my_data->is_acdb_initialized = true;
1755 ALOGD("ACDB initialized");
1756 audio_hwdep_send_cal(my_data);
1757 } else {
1758 my_data->is_acdb_initialized = false;
1759 ALOGD("ACDB initialization failed");
1760 }
1761 return result;
1762}
1763
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]1764static void get_source_mic_type(struct platform_data * my_data)
1765{
1766 // support max to mono, example if max count is 3, usecase supports Three, dual and mono mic
1767 switch (my_data->max_mic_count) {
1768 case 4:
1769 my_data->source_mic_type |= SOURCE_QUAD_MIC;
1770 case 3:
1771 my_data->source_mic_type |= SOURCE_THREE_MIC;
1772 case 2:
1773 my_data->source_mic_type |= SOURCE_DUAL_MIC;
1774 case 1:
1775 my_data->source_mic_type |= SOURCE_MONO_MIC;
1776 break;
1777 default:
1778 ALOGE("%s: max_mic_count (%d), is not supported, setting to default",
1779 __func__, my_data->max_mic_count);
1780 my_data->source_mic_type = SOURCE_MONO_MIC | SOURCE_DUAL_MIC;
1781 break;
1782 }
1783}
1784
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]1785/*
1786 * Retrieves the be_dai_name_table from kernel to enable a mapping
1787 * between sound device hw interfaces and backend IDs. This allows HAL to
1788 * specify the backend a specific calibration is needed for.
1789 */
1790static int init_be_dai_name_table(struct audio_device *adev)
1791{
1792 const char *mixer_ctl_name = "Backend DAI Name Table";
1793 struct mixer_ctl *ctl;
1794 int i, j, ret, size;
1795 bool valid_hw_interface;
1796
1797 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1798 if (!ctl) {
1799 ALOGE("%s: Could not get ctl for mixer name %s\n",
1800 __func__, mixer_ctl_name);
1801 ret = -EINVAL;
1802 goto done;
1803 }
1804
1805 mixer_ctl_update(ctl);
1806
1807 size = mixer_ctl_get_num_values(ctl);
1808 if (size <= 0){
1809 ALOGE("%s: Failed to get %s size %d\n",
1810 __func__, mixer_ctl_name, size);
1811 ret = -EFAULT;
1812 goto done;
1813 }
1814
1815 be_dai_name_table =
1816 (const struct be_dai_name_struct *)calloc(1, size);
1817 if (be_dai_name_table == NULL) {
1818 ALOGE("%s: Failed to allocate memory for %s\n",
1819 __func__, mixer_ctl_name);
1820 ret = -ENOMEM;
1821 goto freeMem;
1822 }
1823
1824 ret = mixer_ctl_get_array(ctl, (void *)be_dai_name_table, size);
1825 if (ret) {
1826 ALOGE("%s: Failed to get %s, ret %d\n",
1827 __func__, mixer_ctl_name, ret);
1828 ret = -EFAULT;
1829 goto freeMem;
1830 }
1831
1832 if (be_dai_name_table != NULL) {
1833 max_be_dai_names = size / sizeof(struct be_dai_name_struct);
1834 ALOGV("%s: Successfully got %s, number of be dais is %d\n",
1835 __func__, mixer_ctl_name, max_be_dai_names);
1836 ret = 0;
1837 } else {
1838 ALOGE("%s: Failed to get %s\n", __func__, mixer_ctl_name);
1839 ret = -EFAULT;
1840 goto freeMem;
1841 }
1842
1843 /*
1844 * Validate all sound devices have a valid backend set to catch
1845 * errors for uncommon sound devices
1846 */
1847 for (i = 0; i < SND_DEVICE_MAX; i++) {
1848 valid_hw_interface = false;
1849
1850 if (hw_interface_table[i] == NULL) {
1851 ALOGW("%s: sound device %s has no hw interface set\n",
1852 __func__, platform_get_snd_device_name(i));
1853 continue;
1854 }
1855
1856 for (j = 0; j < max_be_dai_names; j++) {
1857 if (strcmp(hw_interface_table[i], be_dai_name_table[j].be_name)
1858 == 0) {
1859 valid_hw_interface = true;
1860 break;
1861 }
1862 }
1863 if (!valid_hw_interface)
1864 ALOGD("%s: sound device %s does not have a valid hw interface set (disregard for combo devices) %s\n",
1865 __func__, platform_get_snd_device_name(i), hw_interface_table[i]);
1866 }
1867
1868 goto done;
1869
1870freeMem:
1871 if (be_dai_name_table) {
1872 free((void *)be_dai_name_table);
1873 be_dai_name_table = NULL;
1874 }
1875
1876done:
1877 return ret;
1878}
1879
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1880void *platform_init(struct audio_device *adev)
1881{
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]1882 char platform[PROPERTY_VALUE_MAX];
1883 char baseband[PROPERTY_VALUE_MAX];
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1884 char value[PROPERTY_VALUE_MAX];
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]1885 struct platform_data *my_data = NULL;
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]1886 char *snd_card_name = NULL, *snd_card_name_t = NULL;
Apoorv Raghuvanshia433fb52015-03-16 15:22:30 -0700[diff] [blame]1887 char *snd_internal_name = NULL;
1888 char *tmp = NULL;
1889 char mixer_xml_file[MIXER_PATH_MAX_LENGTH]= {0};
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]1890 int idx;
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]1891 struct mixer_ctl *ctl = NULL;
1892 const char *id_string = NULL;
1893 int cfg_value = -1;
sangwoo1b9f4b32013-06-21 18:22:55 -0700[diff] [blame]1894
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1895 adev->snd_card = audio_extn_utils_get_snd_card_num();
1896 if (adev->snd_card < 0) {
1897 ALOGE("%s: Unable to find correct sound card", __func__);
1898 return NULL;
1899 }
1900 ALOGD("%s: Opened sound card:%d", __func__, adev->snd_card);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]1901
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1902 adev->mixer = mixer_open(adev->snd_card);
1903 if (!adev->mixer) {
1904 ALOGE("%s: Unable to open the mixer card: %d", __func__,
1905 adev->snd_card);
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -0700[diff] [blame]1906 return NULL;
1907 }
1908
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1909 snd_card_name = strdup(mixer_get_name(adev->mixer));
1910 if (!snd_card_name) {
1911 ALOGE("failed to allocate memory for snd_card_name\n");
Mingming Yindda29e62015-12-02 18:02:28 -0800[diff] [blame]1912 mixer_close(adev->mixer);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1913 return NULL;
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]1914 }
1915
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1916 my_data = calloc(1, sizeof(struct platform_data));
1917 if (!my_data) {
1918 ALOGE("failed to allocate platform data");
1919 if (snd_card_name)
1920 free(snd_card_name);
1921 mixer_close(adev->mixer);
1922 return NULL;
1923 }
1924
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1925 my_data->is_slimbus_interface = true;
1926 my_data->is_internal_codec = false;
1927
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1928 my_data->hw_info = hw_info_init(snd_card_name);
1929 if (!my_data->hw_info) {
1930 ALOGE("failed to init hw_info");
1931 mixer_close(adev->mixer);
1932 if (my_data)
1933 free(my_data);
1934
1935 if (snd_card_name)
1936 free(snd_card_name);
1937 return NULL;
1938 }
1939
1940 if (platform_is_i2s_ext_modem(snd_card_name, my_data)) {
1941 ALOGD("%s: Call MIXER_XML_PATH_I2S", __func__);
1942
1943 adev->audio_route = audio_route_init(adev->snd_card,
1944 MIXER_XML_PATH_I2S);
1945 } else {
1946 /* Get the codec internal name from the sound card name
1947 * and form the mixer paths file name dynamically. This
1948 * is generic way of picking any codec name based mixer
1949 * files in future with no code change. This code
1950 * assumes mixer files are formed with format as
1951 * mixer_paths_internalcodecname.xml
1952
1953 * If this dynamically read mixer files fails to open then it
1954 * falls back to default mixer file i.e mixer_paths.xml. This is
1955 * done to preserve backward compatibility but not mandatory as
1956 * long as the mixer files are named as per above assumption.
1957 */
1958 snd_card_name_t = strdup(snd_card_name);
1959 snd_internal_name = strtok_r(snd_card_name_t, "-", &tmp);
1960
1961 if (snd_internal_name != NULL) {
1962 snd_internal_name = strtok_r(NULL, "-", &tmp);
1963 }
1964 if (snd_internal_name != NULL) {
1965 strlcpy(mixer_xml_file, MIXER_XML_BASE_STRING,
1966 MIXER_PATH_MAX_LENGTH);
1967 strlcat(mixer_xml_file, MIXER_FILE_DELIMITER,
1968 MIXER_PATH_MAX_LENGTH);
1969 strlcat(mixer_xml_file, snd_internal_name,
1970 MIXER_PATH_MAX_LENGTH);
1971 strlcat(mixer_xml_file, MIXER_FILE_EXT,
1972 MIXER_PATH_MAX_LENGTH);
1973 } else {
1974 strlcpy(mixer_xml_file, MIXER_XML_DEFAULT_PATH,
1975 MIXER_PATH_MAX_LENGTH);
1976 }
1977
1978 if (F_OK == access(mixer_xml_file, 0)) {
1979 ALOGD("%s: Loading mixer file: %s", __func__, mixer_xml_file);
1980 if (audio_extn_read_xml(adev, adev->snd_card, mixer_xml_file,
1981 MIXER_XML_PATH_AUXPCM) == -ENOSYS)
1982 adev->audio_route = audio_route_init(adev->snd_card,
1983 mixer_xml_file);
Sharad Sangle999cf722017-10-18 18:25:47 +0530[diff] [blame]1984 update_codec_type_and_interface(my_data, snd_card_name);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1985 } else {
1986 ALOGD("%s: Loading default mixer file", __func__);
1987 if (audio_extn_read_xml(adev, adev->snd_card, MIXER_XML_DEFAULT_PATH,
1988 MIXER_XML_PATH_AUXPCM) == -ENOSYS)
1989 adev->audio_route = audio_route_init(adev->snd_card,
1990 MIXER_XML_DEFAULT_PATH);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]1991 update_codec_type_and_interface(my_data, snd_card_name);
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]1992 }
1993 }
1994 if (!adev->audio_route) {
1995 ALOGE("%s: Failed to init audio route controls, aborting.",
1996 __func__);
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]1997 if (my_data)
1998 free(my_data);
Ravi Kumar Alamanda31c90df2015-10-16 10:06:59 -0700[diff] [blame]1999 if (snd_card_name)
2000 free(snd_card_name);
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2001 if (snd_card_name_t)
2002 free(snd_card_name_t);
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]2003 mixer_close(adev->mixer);
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -0800[diff] [blame]2004 return NULL;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]2005 }
2006
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2007 my_data->adev = adev;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2008 my_data->fluence_in_spkr_mode = false;
2009 my_data->fluence_in_voice_call = false;
2010 my_data->fluence_in_voice_rec = false;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]2011 my_data->fluence_in_audio_rec = false;
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2012 my_data->fluence_in_hfp_call = false;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]2013 my_data->external_spk_1 = false;
2014 my_data->external_spk_2 = false;
2015 my_data->external_mic = false;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2016 my_data->fluence_type = FLUENCE_NONE;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2017 my_data->fluence_mode = FLUENCE_ENDFIRE;
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]2018 my_data->slowtalk = false;
2019 my_data->hd_voice = false;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]2020 my_data->edid_info = NULL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]2021 my_data->ext_disp_type = EXT_DISPLAY_TYPE_NONE;
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2022 my_data->hw_dep_fd = -1;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]2023 my_data->mono_speaker = SPKR_1;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2024
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2025 be_dai_name_table = NULL;
2026
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2027 property_get("ro.vendor.audio.sdk.fluencetype", my_data->fluence_cap, "");
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]2028 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) {
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]2029 my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]2030 } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2031 my_data->fluence_type = FLUENCE_DUAL_MIC;
2032 } else {
2033 my_data->fluence_type = FLUENCE_NONE;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2034 }
2035
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2036 if (my_data->fluence_type != FLUENCE_NONE) {
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2037 property_get("persist.vendor.audio.fluence.voicecall",value,"");
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2038 if (!strncmp("true", value, sizeof("true"))) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2039 my_data->fluence_in_voice_call = true;
2040 }
2041
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2042 property_get("persist.vendor.audio.fluence.voicerec",value,"");
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2043 if (!strncmp("true", value, sizeof("true"))) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2044 my_data->fluence_in_voice_rec = true;
2045 }
2046
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2047 property_get("persist.vendor.audio.fluence.audiorec",value,"");
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]2048 if (!strncmp("true", value, sizeof("true"))) {
2049 my_data->fluence_in_audio_rec = true;
2050 }
2051
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2052 property_get("persist.vendor.audio.fluence.speaker",value,"");
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]2053 if (!strncmp("true", value, sizeof("true"))) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2054 my_data->fluence_in_spkr_mode = true;
2055 }
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2056
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2057 property_get("persist.vendor.audio.fluence.mode",value,"");
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]2058 if (!strncmp("broadside", value, sizeof("broadside"))) {
2059 my_data->fluence_mode = FLUENCE_BROADSIDE;
2060 }
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2061
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2062 property_get("persist.vendor.audio.fluence.hfpcall",value,"");
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2063 if (!strncmp("true", value, sizeof("true"))) {
2064 my_data->fluence_in_hfp_call = true;
2065 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2066 }
2067
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2068 /* Check if Vbat speaker enabled property is set, this should be done before acdb init */
2069 bool ret = false;
2070 ret = audio_extn_can_use_vbat();
2071 if (ret)
2072 my_data->is_vbat_speaker = true;
2073
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2074 list_init(&my_data->acdb_meta_key_list);
2075
2076 set_platform_defaults(my_data);
2077
2078 /* Initialize ACDB ID's */
2079 if (my_data->is_i2s_ext_modem)
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2080 platform_info_init(PLATFORM_INFO_XML_PATH_I2S, my_data, PLATFORM);
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2081 else if (!strncmp(snd_card_name, "sdm660-snd-card-skush",
2082 sizeof("sdm660-snd-card-skush")))
2083 platform_info_init(PLATFORM_INFO_XML_PATH_SKUSH, my_data, PLATFORM);
Walter Yang319c6fe2017-09-21 17:09:39 +0800[diff] [blame]2084 else if (!strncmp(snd_card_name, "sdm670-skuw-snd-card",
2085 sizeof("sdm670-skuw-snd-card")))
2086 platform_info_init(PLATFORM_INFO_XML_PATH_SKUW, my_data, PLATFORM);
2087 else if (my_data->is_internal_codec)
2088 platform_info_init(PLATFORM_INFO_XML_PATH_INTCODEC, my_data, PLATFORM);
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2089 else
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2090 platform_info_init(PLATFORM_INFO_XML_PATH, my_data, PLATFORM);
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2091
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2092 my_data->voice_feature_set = VOICE_FEATURE_SET_DEFAULT;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2093 my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
2094 if (my_data->acdb_handle == NULL) {
2095 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER);
2096 } else {
2097 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);
2098 my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle,
2099 "acdb_loader_deallocate_ACDB");
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2100 if (!my_data->acdb_deallocate)
2101 ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s",
2102 __func__, LIB_ACDB_LOADER);
2103
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2104 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]2105 "acdb_loader_send_audio_cal_v2");
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2106 if (!my_data->acdb_send_audio_cal)
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2107 ALOGE("%s: Could not find the symbol acdb_send_audio_cal_v2 from %s",
2108 __func__, LIB_ACDB_LOADER);
2109
2110 my_data->acdb_send_audio_cal_v3 = (acdb_send_audio_cal_v3_t)dlsym(my_data->acdb_handle,
2111 "acdb_loader_send_audio_cal_v3");
2112 if (!my_data->acdb_send_audio_cal_v3)
2113 ALOGE("%s: Could not find the symbol acdb_send_audio_cal_v3 from %s",
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2114 __func__, LIB_ACDB_LOADER);
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2115
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]2116 my_data->acdb_set_audio_cal = (acdb_set_audio_cal_t)dlsym(my_data->acdb_handle,
2117 "acdb_loader_set_audio_cal_v2");
2118 if (!my_data->acdb_set_audio_cal)
2119 ALOGE("%s: Could not find the symbol acdb_set_audio_cal_v2 from %s",
2120 __func__, LIB_ACDB_LOADER);
2121
2122 my_data->acdb_get_audio_cal = (acdb_get_audio_cal_t)dlsym(my_data->acdb_handle,
2123 "acdb_loader_get_audio_cal_v2");
2124 if (!my_data->acdb_get_audio_cal)
2125 ALOGE("%s: Could not find the symbol acdb_get_audio_cal_v2 from %s",
2126 __func__, LIB_ACDB_LOADER);
2127
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2128 my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle,
2129 "acdb_loader_send_voice_cal");
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]2130 if (!my_data->acdb_send_voice_cal)
2131 ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s",
2132 __func__, LIB_ACDB_LOADER);
2133
2134 my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle,
2135 "acdb_loader_reload_vocvoltable");
2136 if (!my_data->acdb_reload_vocvoltable)
2137 ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s",
2138 __func__, LIB_ACDB_LOADER);
2139
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]2140 my_data->acdb_get_default_app_type = (acdb_get_default_app_type_t)dlsym(
2141 my_data->acdb_handle,
2142 "acdb_loader_get_default_app_type");
2143 if (!my_data->acdb_get_default_app_type)
2144 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2145 __func__, LIB_ACDB_LOADER);
2146
vivek mehtaa76401a2015-04-24 14:12:15 -0700[diff] [blame]2147 my_data->acdb_send_gain_dep_cal = (acdb_send_gain_dep_cal_t)dlsym(my_data->acdb_handle,
2148 "acdb_loader_send_gain_dep_cal");
2149 if (!my_data->acdb_send_gain_dep_cal)
2150 ALOGV("%s: Could not find the symbol acdb_loader_send_gain_dep_cal from %s",
2151 __func__, LIB_ACDB_LOADER);
2152
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2153 my_data->acdb_send_common_top = (acdb_send_common_top_t)dlsym(
2154 my_data->acdb_handle,
2155 "acdb_loader_send_common_custom_topology");
2156 if (!my_data->acdb_send_common_top)
2157 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2158 __func__, LIB_ACDB_LOADER);
2159
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2160 my_data->acdb_set_codec_data = (acdb_set_codec_data_t)dlsym(
2161 my_data->acdb_handle,
2162 "acdb_loader_set_codec_data");
2163 if (!my_data->acdb_set_codec_data)
2164 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
2165 __func__, LIB_ACDB_LOADER);
2166
2167
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2168 my_data->acdb_init_v3 = (acdb_init_v3_t)dlsym(my_data->acdb_handle,
2169 "acdb_loader_init_v3");
2170 if (my_data->acdb_init_v3 == NULL) {
2171 ALOGE("%s: dlsym error %s for acdb_loader_init_v3", __func__, dlerror());
2172 }
2173
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2174 my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle,
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2175 "acdb_loader_init_v3");
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2176 if (my_data->acdb_init == NULL) {
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2177 ALOGE("%s: dlsym error %s for acdb_loader_init_v3", __func__, dlerror());
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2178 goto acdb_init_fail;
2179 }
2180
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2181 my_data->acdb_reload_v2 = (acdb_reload_v2_t)dlsym(my_data->acdb_handle,
2182 "acdb_loader_reload_acdb_files_v2");
2183 if (my_data->acdb_reload_v2 == NULL) {
2184 ALOGE("%s: dlsym error %s for acdb_loader_reload_acdb_files_v2", __func__, dlerror());
2185 }
2186
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]2187 my_data->acdb_reload = (acdb_reload_t)dlsym(my_data->acdb_handle,
2188 "acdb_loader_reload_acdb_files");
2189 if (my_data->acdb_reload == NULL) {
2190 ALOGE("%s: dlsym error %s for acdb_loader_reload_acdb_files", __func__, dlerror());
2191 goto acdb_init_fail;
2192 }
Vignesh Kulothungan55396882017-04-20 14:37:02 -0700[diff] [blame]2193
2194 int result = acdb_init(adev->snd_card);
2195 if (!result) {
2196 my_data->is_acdb_initialized = true;
2197 ALOGD("ACDB initialized");
2198 audio_hwdep_send_cal(my_data);
2199 } else {
2200 my_data->is_acdb_initialized = false;
2201 ALOGD("ACDB initialization failed");
2202 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2203 }
2204
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530[diff] [blame]2205 /* init keep-alive for compress passthru */
2206 audio_extn_keep_alive_init(adev);
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]2207#ifdef DYNAMIC_LOG_ENABLED
2208 log_utils_init();
2209#endif
Walter Yang6f800052014-07-14 16:15:38 -0700[diff] [blame]2210acdb_init_fail:
2211
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]2212
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2213 /*
2214 * Get the be_dai_name_table from kernel which provides a mapping
2215 * between a backend string name and a backend ID
2216 */
2217 init_be_dai_name_table(adev);
2218
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]2219 if (audio_extn_can_use_ras()) {
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]2220 if (property_get_bool("persist.vendor.audio.speaker.prot.enable", false)) {
Srinivas Julakanti1ca769a2017-01-04 23:18:08 -0800[diff] [blame]2221 platform_set_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED,
2222 acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_RAS]);
2223 platform_set_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT,
2224 acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT_RAS]);
2225 } else {
2226 ALOGD("%s: RAS Feature should be enabled with Speaker Protection", __func__);
2227 }
2228 }
2229
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]2230 /* If platform is apq8084 and baseband is MDM, load CSD Client specific
2231 * symbols. Voice call is handled by MDM and apps processor talks to
2232 * MDM through CSD Client
2233 */
2234 property_get("ro.board.platform", platform, "");
2235 property_get("ro.baseband", baseband, "");
Josh Kirschc3894372016-03-28 15:59:48 -0700[diff] [blame]2236 if ((!strncmp("apq8084", platform, sizeof("apq8084")) ||
2237 !strncmp("msm8996", platform, sizeof("msm8996"))) &&
Vidyakumar Athota77327dd2014-08-07 16:44:25 -0700[diff] [blame]2238 !strncmp("mdm", baseband, (sizeof("mdm")-1))) {
2239 my_data->csd = open_csd_client(my_data->is_i2s_ext_modem);
2240 } else {
2241 my_data->csd = NULL;
2242 }
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]2243
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2244 /* obtain source mic type from max mic count*/
2245 get_source_mic_type(my_data);
2246 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]2247 " 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]2248 __func__, my_data->fluence_type, my_data->max_mic_count, my_data->source_mic_type,
2249 my_data->fluence_in_voice_call, my_data->fluence_in_voice_rec,
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]2250 my_data->fluence_in_spkr_mode, my_data->fluence_in_hfp_call);
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]2251
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]2252 /* init usb */
2253 audio_extn_usb_init(adev);
2254
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]2255 /*init a2dp*/
2256 audio_extn_a2dp_init(adev);
2257
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]2258 /* init dap hal */
2259 audio_extn_dap_hal_init(adev->snd_card);
2260
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]2261 /* Read one time ssr property */
Mingming Yin49be8032013-12-19 12:51:25 -0800[diff] [blame]2262 audio_extn_ssr_update_enabled();
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700[diff] [blame]2263 audio_extn_spkr_prot_init(adev);
Dhananjay Kumar89ea3bd2014-04-29 15:45:57 +0530[diff] [blame]2264
Dhananjay Kumar89ea3bd2014-04-29 15:45:57 +0530[diff] [blame]2265
Lior Barenboim0b61bc72014-05-13 13:01:37 +0300[diff] [blame]2266 /* init audio device arbitration */
2267 audio_extn_dev_arbi_init();
2268
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2269 default_rx_backend = strdup("SLIMBUS_0_RX");
2270
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]2271 /* initialize backend config */
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2272 for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {
2273 my_data->current_backend_cfg[idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
2274 if (idx == HEADPHONE_44_1_BACKEND)
2275 my_data->current_backend_cfg[idx].sample_rate = OUTPUT_SAMPLING_RATE_44100;
2276 my_data->current_backend_cfg[idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]2277 my_data->current_backend_cfg[idx].channels = CODEC_BACKEND_DEFAULT_CHANNELS;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2278 if (idx > MAX_RX_CODEC_BACKENDS)
2279 my_data->current_backend_cfg[idx].channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]2280 my_data->current_backend_cfg[idx].format = AUDIO_FORMAT_PCM;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]2281 my_data->current_backend_cfg[idx].bitwidth_mixer_ctl = NULL;
2282 my_data->current_backend_cfg[idx].samplerate_mixer_ctl = NULL;
2283 my_data->current_backend_cfg[idx].channels_mixer_ctl = NULL;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]2284 }
2285
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2286 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2287 strdup("SLIM_0_RX Format");
2288 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2289 strdup("SLIM_0_RX SampleRate");
2290
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2291 my_data->current_backend_cfg[DSD_NATIVE_BACKEND].bitwidth_mixer_ctl =
2292 strdup("SLIM_2_RX Format");
2293 my_data->current_backend_cfg[DSD_NATIVE_BACKEND].samplerate_mixer_ctl =
2294 strdup("SLIM_2_RX SampleRate");
2295
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2296 my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].bitwidth_mixer_ctl =
2297 strdup("SLIM_5_RX Format");
2298 my_data->current_backend_cfg[HEADPHONE_44_1_BACKEND].samplerate_mixer_ctl =
2299 strdup("SLIM_5_RX SampleRate");
2300
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2301 if (!my_data->is_slimbus_interface) {
Sharad Sangled39232d2017-08-08 20:27:18 +0530[diff] [blame]2302 if (!strncmp(snd_card_name, "sdm660", strlen("sdm660")) ||
2303 !strncmp(snd_card_name, "sdm670", strlen("sdm670"))) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2304
2305 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2306 strdup("INT4_MI2S_RX Format");
2307 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2308 strdup("INT4_MI2S_RX SampleRate");
2309
2310 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2311 strdup("INT3_MI2S_TX Format");
2312 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2313 strdup("INT3_MI2S_TX SampleRate");
2314
2315 if (default_rx_backend)
2316 free(default_rx_backend);
2317 default_rx_backend = strdup("INT4_MI2S_RX");
2318
2319 } else {
2320 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
2321 strdup("MI2S_RX Format");
2322 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
2323 strdup("MI2S_RX SampleRate");
2324 my_data->current_backend_cfg[DEFAULT_CODEC_BACKEND].channels_mixer_ctl =
2325 strdup("MI2S_RX Channels");
2326
2327 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2328 strdup("MI2S_TX Format");
2329 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2330 strdup("MI2S_TX SampleRate");
2331 }
2332 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2333 strdup("INT0_MI2S_RX Format");
2334 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2335 strdup("INT0_MI2S_RX SampleRate");
2336
Revathi Uddaraju75843112017-11-30 14:30:47 +0530[diff] [blame^]2337 } else {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2338
Revathi Uddaraju75843112017-11-30 14:30:47 +0530[diff] [blame^]2339 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
2340 strdup("SLIM_0_TX Format");
2341 my_data->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
2342 strdup("SLIM_0_TX SampleRate");
2343 my_data->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
2344 strdup("SLIM_6_RX Format");
2345 my_data->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
2346 strdup("SLIM_6_RX SampleRate");
2347 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]2348
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2349 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].bitwidth_mixer_ctl =
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2350 strdup("USB_AUDIO_TX Format");
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2351 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].samplerate_mixer_ctl =
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2352 strdup("USB_AUDIO_TX SampleRate");
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]2353 my_data->current_backend_cfg[USB_AUDIO_TX_BACKEND].channels_mixer_ctl =
2354 strdup("USB_AUDIO_TX Channels");
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]2355
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]2356 my_data->current_backend_cfg[HDMI_TX_BACKEND].bitwidth_mixer_ctl =
2357 strdup("QUAT_MI2S_TX Format");
2358 my_data->current_backend_cfg[HDMI_TX_BACKEND].samplerate_mixer_ctl =
2359 strdup("QUAT_MI2S_TX SampleRate");
2360 my_data->current_backend_cfg[HDMI_TX_BACKEND].channels_mixer_ctl =
2361 strdup("QUAT_MI2S_TX Channels");
2362
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]2363 for (idx = 0; idx < MAX_CODEC_BACKENDS; idx++) {
2364 if (my_data->current_backend_cfg[idx].bitwidth_mixer_ctl) {
2365 ctl = mixer_get_ctl_by_name(adev->mixer,
2366 my_data->current_backend_cfg[idx].bitwidth_mixer_ctl);
2367 id_string = platform_get_mixer_control(ctl);
2368 if (id_string) {
2369 cfg_value = audio_extn_utils_get_bit_width_from_string(id_string);
2370 if (cfg_value > 0)
2371 my_data->current_backend_cfg[idx].bit_width = cfg_value;
2372 }
2373 }
2374
2375 if (my_data->current_backend_cfg[idx].samplerate_mixer_ctl) {
2376 ctl = mixer_get_ctl_by_name(adev->mixer,
2377 my_data->current_backend_cfg[idx].samplerate_mixer_ctl);
2378 id_string = platform_get_mixer_control(ctl);
2379 if (id_string) {
2380 cfg_value = audio_extn_utils_get_sample_rate_from_string(id_string);
2381 if (cfg_value > 0)
2382 my_data->current_backend_cfg[idx].sample_rate = cfg_value;
2383 }
2384 }
2385
2386 if (my_data->current_backend_cfg[idx].channels_mixer_ctl) {
2387 ctl = mixer_get_ctl_by_name(adev->mixer,
2388 my_data->current_backend_cfg[idx].channels_mixer_ctl);
2389 id_string = platform_get_mixer_control(ctl);
2390 if (id_string) {
2391 cfg_value = audio_extn_utils_get_channels_from_string(id_string);
2392 if (cfg_value > 0)
2393 my_data->current_backend_cfg[idx].channels = cfg_value;
2394 }
2395 }
2396 }
2397
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2398 ret = audio_extn_utils_get_codec_version(snd_card_name,
2399 my_data->adev->snd_card,
2400 my_data->codec_version);
2401
2402 if (NATIVE_AUDIO_MODE_INVALID != platform_get_native_support()) {
2403 /*
2404 * Native playback is enabled from the UI.
2405 */
2406 if(strstr(snd_card_name, "tasha")) {
2407 if (strstr(my_data->codec_version, "WCD9335_1_0") ||
2408 strstr(my_data->codec_version, "WCD9335_1_1")) {
2409 ALOGD("%s:napb: TASHA 1.0 or 1.1 only SRC mode is supported",
2410 __func__);
2411 platform_set_native_support(NATIVE_AUDIO_MODE_SRC);
2412 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2413 }
Ashish Jain4826f6c2017-02-06 13:33:20 +0530[diff] [blame]2414 if (strstr(snd_card_name, "tavil")) {
2415 ALOGD("%s:DSD playback is supported", __func__);
2416 my_data->is_dsd_supported = true;
2417 my_data->is_asrc_supported = true;
2418 platform_set_native_support(NATIVE_AUDIO_MODE_MULTIPLE_44_1);
2419 }
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2420 }
2421
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]2422 my_data->current_backend_cfg[HDMI_RX_BACKEND].bitwidth_mixer_ctl =
2423 strdup("HDMI_RX Bit Format");
2424 my_data->current_backend_cfg[HDMI_RX_BACKEND].samplerate_mixer_ctl =
2425 strdup("HDMI_RX SampleRate");
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]2426 my_data->current_backend_cfg[HDMI_RX_BACKEND].channels_mixer_ctl =
2427 strdup("HDMI_RX Channels");
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]2428 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].bitwidth_mixer_ctl =
2429 strdup("Display Port RX Bit Format");
2430 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].samplerate_mixer_ctl =
2431 strdup("Display Port RX SampleRate");
2432 my_data->current_backend_cfg[DISP_PORT_RX_BACKEND].channels_mixer_ctl =
2433 strdup("Display Port RX Channels");
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2434
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]2435 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].bitwidth_mixer_ctl =
2436 strdup("USB_AUDIO_RX Format");
2437 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].samplerate_mixer_ctl =
2438 strdup("USB_AUDIO_RX SampleRate");
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]2439 my_data->current_backend_cfg[USB_AUDIO_RX_BACKEND].channels_mixer_ctl =
2440 strdup("USB_AUDIO_RX Channels");
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]2441
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]2442 my_data->edid_info = NULL;
Sudheer Papothi4e0ea9a2015-09-30 06:57:51 +0530[diff] [blame]2443 free(snd_card_name);
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2444 free(snd_card_name_t);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2445 return my_data;
2446}
2447
2448void platform_deinit(void *platform)
2449{
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]2450 struct platform_data *my_data = (struct platform_data *)platform;
2451
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]2452 if (my_data->edid_info) {
2453 free(my_data->edid_info);
2454 my_data->edid_info = NULL;
2455 }
2456
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]2457 if (be_dai_name_table) {
2458 free((void *)be_dai_name_table);
2459 be_dai_name_table = NULL;
2460 }
2461
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2462 if (my_data->hw_dep_fd >= 0) {
2463 close(my_data->hw_dep_fd);
2464 my_data->hw_dep_fd = -1;
2465 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2466 if (default_rx_backend)
2467 free(default_rx_backend);
Venkata Narendra Kumar Guttae071e5a2016-01-11 18:08:26 +0530[diff] [blame]2468
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]2469 hw_info_deinit(my_data->hw_info);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]2470 close_csd_client(my_data->csd);
2471
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2472 int32_t dev;
2473 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2474 if (backend_tag_table[dev]) {
2475 free(backend_tag_table[dev]);
2476 backend_tag_table[dev]= NULL;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2477 }
2478 }
2479
Lior Barenboim0b61bc72014-05-13 13:01:37 +0300[diff] [blame]2480 /* deinit audio device arbitration */
2481 audio_extn_dev_arbi_deinit();
2482
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]2483 if (my_data->edid_info) {
2484 free(my_data->edid_info);
2485 my_data->edid_info = NULL;
2486 }
2487
Dhananjay Kumara5ba5f22016-11-30 16:01:29 +0530[diff] [blame]2488 if (my_data->adev->mixer) {
2489 mixer_close(my_data->adev->mixer);
2490 my_data->adev->mixer = NULL;
2491 }
2492
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2493 free(platform);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]2494 /* deinit usb */
2495 audio_extn_usb_deinit();
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]2496 audio_extn_dap_hal_deinit();
Aditya Bavanaria56da222017-07-14 17:54:21 +0530[diff] [blame]2497 if (audio_extn_spkr_prot_is_enabled())
2498 audio_extn_spkr_prot_deinit();
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +0530[diff] [blame]2499#ifdef DYNAMIC_LOG_ENABLED
2500 log_utils_deinit();
2501#endif
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2502}
2503
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2504static int platform_is_acdb_initialized(void *platform)
Ramjee Singh203473b2015-06-09 15:18:42 +0530[diff] [blame]2505{
2506 struct platform_data *my_data = (struct platform_data *)platform;
2507 ALOGD("%s: acdb initialized %d\n", __func__, my_data->is_acdb_initialized);
2508 return my_data->is_acdb_initialized;
2509}
2510
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]2511void platform_snd_card_update(void *platform, card_status_t card_status)
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2512{
2513 struct platform_data *my_data = (struct platform_data *)platform;
2514
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]2515 if (card_status == CARD_STATUS_ONLINE) {
Ben Rombergerfeca4b82015-07-07 20:40:44 -0700[diff] [blame]2516 if (!platform_is_acdb_initialized(my_data)) {
2517 if(platform_acdb_init(my_data))
2518 ALOGE("%s: acdb initialization is failed", __func__);
2519 } else if (my_data->acdb_send_common_top() < 0) {
2520 ALOGD("%s: acdb did not set common topology", __func__);
2521 }
2522 }
2523}
2524
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2525const char *platform_get_snd_device_name(snd_device_t snd_device)
2526{
2527 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX)
2528 return device_table[snd_device];
2529 else
2530 return "";
2531}
2532
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -0700[diff] [blame]2533int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
2534 char *device_name)
2535{
2536 struct platform_data *my_data = (struct platform_data *)platform;
2537
2538 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
2539 strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
2540 hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
2541 } else {
2542 strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE);
2543 return -EINVAL;
2544 }
2545
2546 return 0;
2547}
2548
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2549void platform_add_backend_name(char *mixer_path, snd_device_t snd_device,
2550 struct audio_usecase *usecase)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2551{
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2552 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
2553 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
2554 return;
2555 }
2556
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]2557 if ((snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
2558 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]2559 !(usecase->type == VOICE_CALL || usecase->type == VOIP_CALL)) {
2560 ALOGI("%s: Not adding vbat speaker device to non voice use cases", __func__);
2561 return;
2562 }
2563
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2564 const char * suffix = backend_tag_table[snd_device];
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2565
2566 if (suffix != NULL) {
2567 strlcat(mixer_path, " ", MIXER_PATH_MAX_LENGTH);
2568 strlcat(mixer_path, suffix, MIXER_PATH_MAX_LENGTH);
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]2569 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2570}
2571
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2572bool platform_check_backends_match(snd_device_t snd_device1, snd_device_t snd_device2)
2573{
2574 bool result = true;
2575
2576 ALOGV("%s: snd_device1 = %s, snd_device2 = %s", __func__,
2577 platform_get_snd_device_name(snd_device1),
2578 platform_get_snd_device_name(snd_device2));
2579
2580 if ((snd_device1 < SND_DEVICE_MIN) || (snd_device1 >= SND_DEVICE_OUT_END)) {
2581 ALOGE("%s: Invalid snd_device = %s", __func__,
2582 platform_get_snd_device_name(snd_device1));
2583 return false;
2584 }
2585 if ((snd_device2 < SND_DEVICE_MIN) || (snd_device2 >= SND_DEVICE_OUT_END)) {
2586 ALOGE("%s: Invalid snd_device = %s", __func__,
2587 platform_get_snd_device_name(snd_device2));
2588 return false;
2589 }
2590 const char * be_itf1 = hw_interface_table[snd_device1];
2591 const char * be_itf2 = hw_interface_table[snd_device2];
2592
2593 if (NULL != be_itf1 && NULL != be_itf2) {
Kuirong Wangb9fbb1e2016-05-03 18:36:39 -0700[diff] [blame]2594 if ((NULL == strstr(be_itf2, be_itf1)) && (NULL == strstr(be_itf1, be_itf2)))
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2595 result = false;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2596 } 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]2597 result = false;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]2598 } 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]2599 result = false;
2600 }
2601
2602 ALOGV("%s: be_itf1 = %s, be_itf2 = %s, match %d", __func__, be_itf1, be_itf2, result);
2603 return result;
2604}
2605
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]2606int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
2607{
2608 int device_id;
2609 if (device_type == PCM_PLAYBACK)
2610 device_id = pcm_device_table[usecase][0];
2611 else
2612 device_id = pcm_device_table[usecase][1];
2613 return device_id;
2614}
2615
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2616static int find_index(struct name_to_index * table, int32_t len, const char * name)
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]2617{
2618 int ret = 0;
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2619 int32_t i;
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]2620
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2621 if (table == NULL) {
2622 ALOGE("%s: table is NULL", __func__);
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]2623 ret = -ENODEV;
2624 goto done;
2625 }
2626
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2627 if (name == NULL) {
2628 ALOGE("null key");
2629 ret = -ENODEV;
2630 goto done;
2631 }
2632
2633 for (i=0; i < len; i++) {
2634 const char* tn = table[i].name;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]2635 size_t len = strlen(tn);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2636 if (strncmp(tn, name, len) == 0) {
2637 if (strlen(name) != len) {
2638 continue; // substring
2639 }
2640 ret = table[i].index;
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]2641 goto done;
2642 }
2643 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2644 ALOGE("%s: Could not find index for name = %s",
2645 __func__, name);
Ben Romberger61764e32014-01-10 13:49:02 -0800[diff] [blame]2646 ret = -ENODEV;
2647done:
2648 return ret;
2649}
2650
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]2651int platform_set_fluence_type(void *platform, char *value)
2652{
2653 int ret = 0;
2654 int fluence_type = FLUENCE_NONE;
2655 int fluence_flag = NONE_FLAG;
2656 struct platform_data *my_data = (struct platform_data *)platform;
2657 struct audio_device *adev = my_data->adev;
2658
2659 ALOGV("%s: fluence type:%d", __func__, my_data->fluence_type);
2660
2661 /* only dual mic turn on and off is supported as of now through setparameters */
2662 if (!strncmp(AUDIO_PARAMETER_VALUE_DUALMIC,value, sizeof(AUDIO_PARAMETER_VALUE_DUALMIC))) {
2663 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro")) ||
2664 !strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
2665 ALOGV("fluence dualmic feature enabled \n");
2666 fluence_type = FLUENCE_DUAL_MIC;
2667 fluence_flag = DMIC_FLAG;
2668 } else {
2669 ALOGE("%s: Failed to set DUALMIC", __func__);
2670 ret = -1;
2671 goto done;
2672 }
2673 } else if (!strncmp(AUDIO_PARAMETER_KEY_NO_FLUENCE, value, sizeof(AUDIO_PARAMETER_KEY_NO_FLUENCE))) {
2674 ALOGV("fluence disabled");
2675 fluence_type = FLUENCE_NONE;
2676 } else {
2677 ALOGE("Invalid fluence value : %s",value);
2678 ret = -1;
2679 goto done;
2680 }
2681
2682 if (fluence_type != my_data->fluence_type) {
2683 ALOGV("%s: Updating fluence_type to :%d", __func__, fluence_type);
2684 my_data->fluence_type = fluence_type;
2685 adev->acdb_settings = (adev->acdb_settings & FLUENCE_MODE_CLEAR) | fluence_flag;
2686 }
2687done:
2688 return ret;
2689}
2690
2691int platform_get_fluence_type(void *platform, char *value, uint32_t len)
2692{
2693 int ret = 0;
2694 struct platform_data *my_data = (struct platform_data *)platform;
2695
2696 if (my_data->fluence_type == FLUENCE_QUAD_MIC) {
2697 strlcpy(value, "quadmic", len);
2698 } else if (my_data->fluence_type == FLUENCE_DUAL_MIC) {
2699 strlcpy(value, "dualmic", len);
2700 } else if (my_data->fluence_type == FLUENCE_NONE) {
2701 strlcpy(value, "none", len);
2702 } else
2703 ret = -1;
2704
2705 return ret;
2706}
2707
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2708int platform_get_snd_device_index(char *device_name)
2709{
2710 return find_index(snd_device_name_index, SND_DEVICE_MAX, device_name);
2711}
2712
2713int platform_get_usecase_index(const char *usecase_name)
2714{
2715 return find_index(usecase_name_index, AUDIO_USECASE_MAX, usecase_name);
2716}
2717
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]2718int platform_get_effect_config_data(snd_device_t snd_device,
2719 struct audio_effect_config *effect_config,
2720 effect_type_t effect_type)
2721{
2722 int ret = 0;
2723
2724 if ((snd_device < SND_DEVICE_IN_BEGIN) || (snd_device >= SND_DEVICE_MAX) ||
2725 (effect_type <= EFFECT_NONE) || (effect_type >= EFFECT_MAX)) {
2726 ALOGE("%s: Invalid snd_device = %d",
2727 __func__, snd_device);
2728 ret = -EINVAL;
2729 goto done;
2730 }
2731
2732 if(effect_config == NULL) {
2733 ALOGE("%s: Invalid effect_config", __func__);
2734 ret = -EINVAL;
2735 goto done;
2736 }
2737
2738 ALOGV("%s: snd_device = %d module_id = %d",
2739 __func__, snd_device, effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type].module_id);
2740 memcpy(effect_config, &effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type],
2741 sizeof(struct audio_effect_config));
2742
2743done:
2744 return ret;
2745}
2746
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]2747int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)
2748{
2749 int ret = 0;
2750
2751 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
2752 ALOGE("%s: Invalid snd_device = %d",
2753 __func__, snd_device);
2754 ret = -EINVAL;
2755 goto done;
2756 }
2757
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]2758 ALOGV("%s: acdb_device_table[%s]: old = %d new = %d", __func__,
2759 platform_get_snd_device_name(snd_device), acdb_device_table[snd_device], acdb_id);
Ben Romberger55886882014-01-10 13:49:02 -0800[diff] [blame]2760 acdb_device_table[snd_device] = acdb_id;
2761done:
2762 return ret;
2763}
2764
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]2765int platform_set_effect_config_data(snd_device_t snd_device,
2766 struct audio_effect_config effect_config,
2767 effect_type_t effect_type)
2768{
2769 int ret = 0;
2770
2771 if ((snd_device < SND_DEVICE_IN_BEGIN) || (snd_device >= SND_DEVICE_MAX) ||
2772 (effect_type <= EFFECT_NONE) || (effect_type >= EFFECT_MAX)) {
2773 ALOGE("%s: Invalid snd_device = %d",
2774 __func__, snd_device);
2775 ret = -EINVAL;
2776 goto done;
2777 }
2778
2779 ALOGV("%s 0x%x 0x%x 0x%x 0x%x", __func__, effect_config.module_id,
2780 effect_config.instance_id, effect_config.param_id,
2781 effect_config.param_value);
2782 effect_config_table[GET_IN_DEVICE_INDEX(snd_device)][effect_type] = effect_config;
2783
2784done:
2785 return ret;
2786}
2787
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]2788int platform_set_acdb_metainfo_key(void *platform, char *name, int key)
2789{
2790 struct meta_key_list *key_info;
2791 struct platform_data *pdata = (struct platform_data *)platform;
2792
2793 key_info = (struct meta_key_list *)calloc(1, sizeof(struct meta_key_list));
2794 if (!key_info) {
2795 ALOGE("%s: Could not allocate memory for key %d", __func__, key);
2796 return -ENOMEM;
2797 }
2798
2799 key_info->cal_info.nKey = key;
2800 strlcpy(key_info->name, name, sizeof(key_info->name));
2801 list_add_tail(&pdata->acdb_meta_key_list, &key_info->list);
2802
2803 ALOGD("%s: successfully added module %s and key %d to the list", __func__,
2804 key_info->name, key_info->cal_info.nKey);
2805 return 0;
2806}
2807
2808int platform_get_meta_info_key_from_list(void *platform, char *mod_name)
2809{
2810 struct listnode *node;
2811 struct meta_key_list *key_info;
2812 struct platform_data *pdata = (struct platform_data *)platform;
2813 int key = 0;
2814
2815 ALOGV("%s: for module %s", __func__, mod_name);
2816
2817 list_for_each(node, &pdata->acdb_meta_key_list) {
2818 key_info = node_to_item(node, struct meta_key_list, list);
2819 if (strcmp(key_info->name, mod_name) == 0) {
2820 key = key_info->cal_info.nKey;
2821 ALOGD("%s: Found key %d for module %s", __func__, key, mod_name);
2822 break;
2823 }
2824 }
2825 return key;
2826}
2827
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]2828int platform_get_default_app_type(void *platform)
2829{
2830 struct platform_data *my_data = (struct platform_data *)platform;
2831
2832 if (my_data->acdb_get_default_app_type)
2833 return my_data->acdb_get_default_app_type();
2834 else
Srikanth Uyyalaa1e32352015-10-09 14:48:04 +0530[diff] [blame]2835 return DEFAULT_APP_TYPE_RX_PATH;
2836}
2837
2838int platform_get_default_app_type_v2(void *platform, usecase_type_t type)
2839{
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]2840 ALOGV("%s: Platform: %p, type: %d", __func__, platform, type);
Srikanth Uyyalaa1e32352015-10-09 14:48:04 +0530[diff] [blame]2841 if(type == PCM_CAPTURE)
2842 return DEFAULT_APP_TYPE_TX_PATH;
2843 else
2844 return DEFAULT_APP_TYPE_RX_PATH;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]2845}
2846
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -0700[diff] [blame]2847int platform_get_snd_device_acdb_id(snd_device_t snd_device)
2848{
2849 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
2850 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
2851 return -EINVAL;
2852 }
2853 return acdb_device_table[snd_device];
2854}
2855
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]2856int platform_set_snd_device_bit_width(snd_device_t snd_device, unsigned int bit_width)
2857{
2858 int ret = 0;
2859
2860 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
2861 ALOGE("%s: Invalid snd_device = %d",
2862 __func__, snd_device);
2863 ret = -EINVAL;
2864 goto done;
2865 }
2866
2867 backend_bit_width_table[snd_device] = bit_width;
2868done:
2869 return ret;
2870}
2871
2872int platform_get_snd_device_bit_width(snd_device_t snd_device)
2873{
2874 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
2875 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]2876 return CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Amit Shekhar5a39c912014-10-14 15:39:30 -0700[diff] [blame]2877 }
2878 return backend_bit_width_table[snd_device];
2879}
2880
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2881int platform_set_native_support(int na_mode)
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2882{
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2883 if (NATIVE_AUDIO_MODE_SRC == na_mode || NATIVE_AUDIO_MODE_TRUE_44_1 == na_mode
2884 || NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2885 na_props.platform_na_prop_enabled = na_props.ui_na_prop_enabled = true;
2886 na_props.na_mode = na_mode;
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]2887 ALOGD("%s:napb: native audio playback enabled in (%s) mode", __func__,
2888 ((na_mode == NATIVE_AUDIO_MODE_SRC)?"SRC":
2889 (na_mode == NATIVE_AUDIO_MODE_TRUE_44_1)?"True":"Multiple"));
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2890 }
2891 else {
2892 na_props.platform_na_prop_enabled = false;
2893 na_props.na_mode = NATIVE_AUDIO_MODE_INVALID;
2894 ALOGD("%s:napb: native audio playback disabled", __func__);
2895 }
2896
2897 return 0;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2898}
2899
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2900bool platform_check_codec_dsd_support(void *platform)
2901{
2902 struct platform_data *my_data = (struct platform_data *)platform;
2903 return my_data->is_dsd_supported;
2904}
2905
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530[diff] [blame]2906bool platform_check_codec_asrc_support(void *platform)
2907{
2908 struct platform_data *my_data = (struct platform_data *)platform;
2909 return my_data->is_asrc_supported;
2910}
2911
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2912int platform_get_native_support()
2913{
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2914 int ret = NATIVE_AUDIO_MODE_INVALID;
2915 if (na_props.platform_na_prop_enabled &&
2916 na_props.ui_na_prop_enabled) {
2917 ret = na_props.na_mode;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2918 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2919 ALOGV("%s:napb: ui Prop enabled(%d) version(%d)", __func__,
2920 na_props.ui_na_prop_enabled, na_props.na_mode);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2921 return ret;
2922}
2923
2924void native_audio_get_params(struct str_parms *query,
2925 struct str_parms *reply,
2926 char *value, int len)
2927{
2928 int ret;
2929 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
2930 value, len);
2931 if (ret >= 0) {
2932 if (na_props.platform_na_prop_enabled) {
2933 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
2934 na_props.ui_na_prop_enabled ? "true" : "false");
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2935 ALOGV("%s:napb: na_props.ui_na_prop_enabled: %d", __func__,
2936 na_props.ui_na_prop_enabled);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2937 } else {
2938 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
2939 "false");
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2940 ALOGV("%s:napb: native audio not supported: %d", __func__,
2941 na_props.platform_na_prop_enabled);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2942 }
2943 }
2944}
2945
2946int native_audio_set_params(struct platform_data *platform,
2947 struct str_parms *parms, char *value, int len)
2948{
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]2949 int ret = -1;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2950 struct audio_usecase *usecase;
2951 struct listnode *node;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2952 int mode = NATIVE_AUDIO_MODE_INVALID;
2953
Preetam Singh Ranawat6746b7a2016-07-18 16:40:24 +0530[diff] [blame]2954 if (!value || !parms)
2955 return ret;
2956
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2957 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO_MODE,
2958 value, len);
2959 if (ret >= 0) {
2960 if (value && !strncmp(value, "src", sizeof("src")))
2961 mode = NATIVE_AUDIO_MODE_SRC;
2962 else if (value && !strncmp(value, "true", sizeof("true")))
2963 mode = NATIVE_AUDIO_MODE_TRUE_44_1;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]2964 else if (value && !strncmp(value, "multiple", sizeof("multiple")))
2965 mode = NATIVE_AUDIO_MODE_MULTIPLE_44_1;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2966 else {
2967 mode = NATIVE_AUDIO_MODE_INVALID;
2968 ALOGE("%s:napb:native_audio_mode in platform info xml,invalid mode string",
2969 __func__);
2970 }
2971 ALOGD("%s:napb updating mode (%d) from XML",__func__, mode);
2972 platform_set_native_support(mode);
2973 }
2974
2975
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2976
2977 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO,
2978 value, len);
2979 if (ret >= 0) {
2980 if (na_props.platform_na_prop_enabled) {
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]2981 if (!strncmp("true", value, sizeof("true"))) {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2982 na_props.ui_na_prop_enabled = true;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2983 ALOGD("%s:napb: native audio feature enabled from UI",
2984 __func__);
2985 } else {
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2986 na_props.ui_na_prop_enabled = false;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]2987 ALOGD("%s:napb: native audio feature disabled from UI",
2988 __func__);
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]2989 }
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]2990
2991 str_parms_del(parms, AUDIO_PARAMETER_KEY_NATIVE_AUDIO);
2992
2993 /*
2994 * Iterate through the usecase list and trigger device switch for
2995 * all the appropriate usecases
2996 */
2997 list_for_each(node, &(platform->adev)->usecase_list) {
2998 usecase = node_to_item(node, struct audio_usecase, list);
2999
3000 if (is_offload_usecase(usecase->id) &&
3001 (usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
3002 usecase->stream.out->devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) &&
3003 OUTPUT_SAMPLING_RATE_44100 == usecase->stream.out->sample_rate) {
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]3004 ALOGD("%s:napb: triggering dynamic device switch for usecase %d, %s"
3005 " stream %p, device (%u)", __func__, usecase->id,
3006 use_case_table[usecase->id],
3007 (void*) usecase->stream.out,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3008 usecase->stream.out->devices);
Sidipotu Ashok894644d2015-07-06 18:35:03 +0530[diff] [blame]3009 select_devices(platform->adev, usecase->id);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3010 }
3011 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3012 } else
3013 ALOGD("%s:napb: native audio cannot be enabled from UI",
3014 __func__);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3015 }
3016 return ret;
3017}
3018
Sidipotu Ashokad8fff82016-02-02 10:48:42 +0530[diff] [blame]3019int check_hdset_combo_device(snd_device_t snd_device)
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3020{
3021 int ret = false;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3022
Sidipotu Ashokad8fff82016-02-02 10:48:42 +0530[diff] [blame]3023 if (SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES == snd_device ||
3024 SND_DEVICE_OUT_SPEAKER_AND_LINE == snd_device ||
3025 SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1 == snd_device ||
3026 SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2 == snd_device ||
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]3027 SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET == snd_device ||
3028 SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET == snd_device)
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3029 ret = true;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3030
3031 return ret;
3032}
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3033
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3034int codec_device_supports_native_playback(audio_devices_t out_device)
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3035{
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3036 int ret = false;
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3037
3038 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
3039 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
3040 out_device & AUDIO_DEVICE_OUT_LINE)
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]3041 ret = true;
kunleiz207afaa2016-07-22 14:26:49 +0800[diff] [blame]3042
3043 return ret;
3044}
3045
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3046int platform_get_backend_index(snd_device_t snd_device)
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]3047{
3048 int32_t port = DEFAULT_CODEC_BACKEND;
3049
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3050 if (snd_device >= SND_DEVICE_OUT_BEGIN && snd_device < SND_DEVICE_OUT_END) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3051 if (backend_tag_table[snd_device] != NULL) {
3052 if (strncmp(backend_tag_table[snd_device], "headphones-44.1",
3053 sizeof("headphones-44.1")) == 0)
3054 port = HEADPHONE_44_1_BACKEND;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3055 else if (strncmp(backend_tag_table[snd_device], "headphones-dsd",
3056 sizeof("headphones-dsd")) == 0)
3057 port = DSD_NATIVE_BACKEND;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3058 else if (strncmp(backend_tag_table[snd_device], "headphones",
3059 sizeof("headphones")) == 0)
3060 port = HEADPHONE_BACKEND;
3061 else if (strcmp(backend_tag_table[snd_device], "hdmi") == 0)
3062 port = HDMI_RX_BACKEND;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3063 else if (strcmp(backend_tag_table[snd_device], "display-port") == 0)
3064 port = DISP_PORT_RX_BACKEND;
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]3065 else if ((strcmp(backend_tag_table[snd_device], "usb-headphones") == 0) ||
3066 (strcmp(backend_tag_table[snd_device], "usb-headset") == 0))
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]3067 port = USB_AUDIO_RX_BACKEND;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3068 }
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3069 } else if (snd_device >= SND_DEVICE_IN_BEGIN && snd_device < SND_DEVICE_IN_END) {
3070 port = DEFAULT_CODEC_TX_BACKEND;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3071 if (backend_tag_table[snd_device] != NULL) {
3072 if (strcmp(backend_tag_table[snd_device], "usb-headset-mic") == 0)
3073 port = USB_AUDIO_TX_BACKEND;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]3074 else if (strstr(backend_tag_table[snd_device], "bt-sco") != NULL)
3075 port = BT_SCO_TX_BACKEND;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]3076 else if (strcmp(backend_tag_table[snd_device], "hdmi-mic") == 0)
3077 port = HDMI_TX_BACKEND;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3078 }
3079 } else {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3080 ALOGW("%s:napb: Invalid device - %d ", __func__, snd_device);
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3081 }
3082
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]3083 ALOGV("%s:napb: backend port - %d device - %d ", __func__, port, snd_device);
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]3084 return port;
3085}
3086
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3087int platform_send_audio_calibration(void *platform, struct audio_usecase *usecase,
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]3088 int app_type, int sample_rate)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3089{
3090 struct platform_data *my_data = (struct platform_data *)platform;
3091 int acdb_dev_id, acdb_dev_type;
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3092 int snd_device = SND_DEVICE_OUT_SPEAKER;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]3093 int new_snd_device[SND_DEVICE_OUT_END] = {0};
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3094 int i, num_devices = 1;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3095
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3096 if (usecase->type == PCM_PLAYBACK)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3097 snd_device = usecase->out_snd_device;
Karthik Reddy Katta81c42612015-11-13 17:49:07 +0530[diff] [blame]3098 else if ((usecase->type == PCM_CAPTURE) &&
3099 voice_is_in_call_rec_stream(usecase->stream.in))
3100 snd_device = voice_get_incall_rec_snd_device(usecase->in_snd_device);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +0530[diff] [blame]3101 else if ((usecase->type == PCM_HFP_CALL) || (usecase->type == PCM_CAPTURE))
Vidyakumar Athotab0975c32015-07-21 14:15:03 -0700[diff] [blame]3102 snd_device = usecase->in_snd_device;
Siddartha Shaik343abc62017-08-08 11:15:25 +0530[diff] [blame]3103 else if (usecase->type == TRANSCODE_LOOPBACK)
3104 snd_device = usecase->out_snd_device;
Vidyakumar Athotab0975c32015-07-21 14:15:03 -0700[diff] [blame]3105
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]3106 acdb_dev_id = acdb_device_table[platform_get_spkr_prot_snd_device(snd_device)];
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3107 if (acdb_dev_id < 0) {
3108 ALOGE("%s: Could not find acdb id for device(%d)",
3109 __func__, snd_device);
3110 return -EINVAL;
3111 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3112
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3113 if (platform_split_snd_device(my_data, snd_device,
3114 &num_devices, new_snd_device) < 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3115 new_snd_device[0] = snd_device;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3116 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3117
3118 for (i = 0; i < num_devices; i++) {
3119 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]3120
3121 // Do not use Rx path default app type for TX path
3122 if ((usecase->type == PCM_CAPTURE) && (app_type == DEFAULT_APP_TYPE_RX_PATH)) {
3123 ALOGD("Resetting app type for Tx path to default");
3124 app_type = DEFAULT_APP_TYPE_TX_PATH;
3125 }
3126
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3127 if (acdb_dev_id < 0) {
3128 ALOGE("%s: Could not find acdb id for device(%d)",
3129 __func__, new_snd_device[i]);
3130 return -EINVAL;
3131 }
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]3132 ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
3133 __func__, new_snd_device[i], acdb_dev_id);
3134 if (new_snd_device[i] >= SND_DEVICE_OUT_BEGIN &&
3135 new_snd_device[i] < SND_DEVICE_OUT_END)
3136 acdb_dev_type = ACDB_DEV_TYPE_OUT;
3137 else
3138 acdb_dev_type = ACDB_DEV_TYPE_IN;
3139
3140 if (my_data->acdb_send_audio_cal_v3) {
3141 my_data->acdb_send_audio_cal_v3(acdb_dev_id, acdb_dev_type,
3142 app_type, sample_rate, i);
3143 } else if (my_data->acdb_send_audio_cal) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3144 my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type, app_type,
3145 sample_rate);
3146 }
3147 }
3148
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3149 return 0;
3150}
3151
3152int platform_switch_voice_call_device_pre(void *platform)
3153{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3154 struct platform_data *my_data = (struct platform_data *)platform;
3155 int ret = 0;
3156
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]3157 if (my_data->csd != NULL &&
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -0700[diff] [blame]3158 voice_is_in_call(my_data->adev)) {
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3159 /* This must be called before disabling mixer controls on APQ side */
3160 ret = my_data->csd->disable_device();
3161 if (ret < 0) {
3162 ALOGE("%s: csd_client_disable_device, failed, error %d",
3163 __func__, ret);
3164 }
3165 }
3166 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3167}
3168
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3169int platform_switch_voice_call_enable_device_config(void *platform,
3170 snd_device_t out_snd_device,
3171 snd_device_t in_snd_device)
3172{
3173 struct platform_data *my_data = (struct platform_data *)platform;
3174 int acdb_rx_id, acdb_tx_id;
3175 int ret = 0;
3176
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3177 if (my_data->csd == NULL)
3178 return ret;
3179
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3180 if ((out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3181 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
3182 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
3183 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3184 audio_extn_spkr_prot_is_enabled()) {
3185 if (my_data->is_vbat_speaker)
3186 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT];
3187 else
3188 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED];
3189 } else
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3190 acdb_rx_id = acdb_device_table[out_snd_device];
3191
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3192 acdb_tx_id = acdb_device_table[in_snd_device];
3193
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3194 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
3195 ret = my_data->csd->enable_device_config(acdb_rx_id, acdb_tx_id);
3196 if (ret < 0) {
3197 ALOGE("%s: csd_enable_device_config, failed, error %d",
3198 __func__, ret);
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3199 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3200 } else {
3201 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
3202 acdb_rx_id, acdb_tx_id);
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3203 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3204
Vidyakumar Athota545dbd32013-11-13 17:30:53 -0800[diff] [blame]3205 return ret;
3206}
3207
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3208int platform_switch_voice_call_device_post(void *platform,
3209 snd_device_t out_snd_device,
3210 snd_device_t in_snd_device)
3211{
3212 struct platform_data *my_data = (struct platform_data *)platform;
3213 int acdb_rx_id, acdb_tx_id;
3214
3215 if (my_data->acdb_send_voice_cal == NULL) {
3216 ALOGE("%s: dlsym error for acdb_send_voice_call", __func__);
3217 } else {
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3218 if (audio_extn_spkr_prot_is_enabled()) {
3219 if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER)
3220 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED;
3221 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT)
3222 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT;
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]3223 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2)
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3224 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED;
3225 else if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT)
3226 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT;
3227 }
Anish Kumar46c7b872014-09-09 01:49:44 -0700[diff] [blame]3228
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]3229 acdb_rx_id = acdb_device_table[out_snd_device];
3230 acdb_tx_id = acdb_device_table[in_snd_device];
3231
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3232 if (acdb_rx_id > 0 && acdb_tx_id > 0)
3233 my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id);
3234 else
3235 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
3236 acdb_rx_id, acdb_tx_id);
3237 }
3238
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]3239 return 0;
3240}
3241
3242int platform_switch_voice_call_usecase_route_post(void *platform,
3243 snd_device_t out_snd_device,
3244 snd_device_t in_snd_device)
3245{
3246 struct platform_data *my_data = (struct platform_data *)platform;
3247 int acdb_rx_id, acdb_tx_id;
3248 int ret = 0;
3249
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3250 if (my_data->csd == NULL)
3251 return ret;
3252
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3253 if ((out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3254 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2 ||
3255 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
3256 out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT) &&
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3257 audio_extn_spkr_prot_is_enabled()) {
3258 if (my_data->is_vbat_speaker)
3259 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT];
3260 else
3261 acdb_rx_id = acdb_device_table[SND_DEVICE_OUT_SPEAKER_PROTECTED];
3262 } else
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3263 acdb_rx_id = acdb_device_table[out_snd_device];
3264
Vidyakumar Athota1fd21792013-11-15 14:50:57 -0800[diff] [blame]3265 acdb_tx_id = acdb_device_table[in_snd_device];
3266
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3267 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
3268 ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id,
3269 my_data->adev->acdb_settings);
3270 if (ret < 0) {
3271 ALOGE("%s: csd_enable_device, failed, error %d", __func__, ret);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3272 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3273 } else {
3274 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
3275 acdb_rx_id, acdb_tx_id);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3276 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -0800[diff] [blame]3277
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3278 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3279}
3280
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3281int platform_start_voice_call(void *platform, uint32_t vsid)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3282{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3283 struct platform_data *my_data = (struct platform_data *)platform;
3284 int ret = 0;
3285
3286 if (my_data->csd != NULL) {
3287 ret = my_data->csd->start_voice(vsid);
3288 if (ret < 0) {
3289 ALOGE("%s: csd_start_voice error %d\n", __func__, ret);
3290 }
3291 }
3292 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3293}
3294
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3295int platform_stop_voice_call(void *platform, uint32_t vsid)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3296{
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3297 struct platform_data *my_data = (struct platform_data *)platform;
3298 int ret = 0;
3299
3300 if (my_data->csd != NULL) {
3301 ret = my_data->csd->stop_voice(vsid);
3302 if (ret < 0) {
3303 ALOGE("%s: csd_stop_voice error %d\n", __func__, ret);
3304 }
3305 }
3306 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3307}
3308
Helen Zeng6a16ad72014-02-23 22:04:44 -0800[diff] [blame]3309int platform_get_sample_rate(void *platform, uint32_t *rate)
3310{
3311 struct platform_data *my_data = (struct platform_data *)platform;
3312 int ret = 0;
3313
3314 if ((my_data->csd != NULL) && my_data->is_i2s_ext_modem) {
3315 ret = my_data->csd->get_sample_rate(rate);
3316 if (ret < 0) {
3317 ALOGE("%s: csd_get_sample_rate error %d\n", __func__, ret);
3318 }
3319 }
3320 return ret;
3321}
3322
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3323int platform_set_voice_volume(void *platform, int volume)
3324{
3325 struct platform_data *my_data = (struct platform_data *)platform;
3326 struct audio_device *adev = my_data->adev;
3327 struct mixer_ctl *ctl;
sangwoo53b2cf02013-07-25 19:18:44 -0700[diff] [blame]3328 const char *mixer_ctl_name = "Voice Rx Gain";
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3329 int vol_index = 0, ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]3330 long set_values[ ] = {0,
3331 ALL_SESSION_VSID,
3332 DEFAULT_VOLUME_RAMP_DURATION_MS};
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3333
3334 // Voice volume levels are mapped to adsp volume levels as follows.
3335 // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0
3336 // But this values don't changed in kernel. So, below change is need.
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3337 vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX);
3338 set_values[0] = vol_index;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3339
3340 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3341 if (!ctl) {
3342 ALOGE("%s: Could not get ctl for mixer cmd - %s",
3343 __func__, mixer_ctl_name);
Josh Kirsch5669ad92016-12-09 10:48:52 -0800[diff] [blame]3344 ret = -EINVAL;
3345 } else {
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]3346 ALOGV("%s: Setting voice volume index: %ld", __func__, set_values[0]);
Josh Kirsch5669ad92016-12-09 10:48:52 -0800[diff] [blame]3347 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3348 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3349
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3350 if (my_data->csd != NULL) {
Vidyakumar Athotac37f42a2014-03-11 11:57:48 -0700[diff] [blame]3351 ret = my_data->csd->volume(ALL_SESSION_VSID, volume,
3352 DEFAULT_VOLUME_RAMP_DURATION_MS);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3353 if (ret < 0) {
3354 ALOGE("%s: csd_volume error %d", __func__, ret);
3355 }
3356 }
3357 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3358}
3359
3360int platform_set_mic_mute(void *platform, bool state)
3361{
3362 struct platform_data *my_data = (struct platform_data *)platform;
3363 struct audio_device *adev = my_data->adev;
3364 struct mixer_ctl *ctl;
3365 const char *mixer_ctl_name = "Voice Tx Mute";
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3366 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]3367 long set_values[ ] = {0,
3368 ALL_SESSION_VSID,
3369 DEFAULT_MUTE_RAMP_DURATION_MS};
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3370
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3371 set_values[0] = state;
3372 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3373 if (!ctl) {
3374 ALOGE("%s: Could not get ctl for mixer cmd - %s",
3375 __func__, mixer_ctl_name);
Josh Kirsch5669ad92016-12-09 10:48:52 -0800[diff] [blame]3376 ret = -EINVAL;
3377 } else {
3378 ALOGV("%s Setting voice mute state: %d", __func__, state);
3379 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3380 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3381
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3382 if (my_data->csd != NULL) {
Vidyakumar Athotac37f42a2014-03-11 11:57:48 -0700[diff] [blame]3383 ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state,
3384 DEFAULT_MUTE_RAMP_DURATION_MS);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3385 if (ret < 0) {
3386 ALOGE("%s: csd_mic_mute error %d", __func__, ret);
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]3387 }
3388 }
3389 return ret;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3390}
3391
Shiv Maliyappanahallic6fd8ee2014-03-07 15:31:55 -0800[diff] [blame]3392int platform_set_device_mute(void *platform, bool state, char *dir)
3393{
3394 struct platform_data *my_data = (struct platform_data *)platform;
3395 struct audio_device *adev = my_data->adev;
3396 struct mixer_ctl *ctl;
3397 char *mixer_ctl_name = NULL;
3398 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]3399 long set_values[ ] = {0,
3400 ALL_SESSION_VSID,
3401 0};
Shiv Maliyappanahallic6fd8ee2014-03-07 15:31:55 -0800[diff] [blame]3402 if(dir == NULL) {
3403 ALOGE("%s: Invalid direction:%s", __func__, dir);
3404 return -EINVAL;
3405 }
3406
3407 if (!strncmp("rx", dir, sizeof("rx"))) {
3408 mixer_ctl_name = "Voice Rx Device Mute";
3409 } else if (!strncmp("tx", dir, sizeof("tx"))) {
3410 mixer_ctl_name = "Voice Tx Device Mute";
3411 } else {
3412 return -EINVAL;
3413 }
3414
3415 set_values[0] = state;
3416 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3417 if (!ctl) {
3418 ALOGE("%s: Could not get ctl for mixer cmd - %s",
3419 __func__, mixer_ctl_name);
3420 return -EINVAL;
3421 }
3422
3423 ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s",
3424 __func__,state, mixer_ctl_name);
3425 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
3426
3427 return ret;
3428}
3429
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3430int platform_split_snd_device(void *platform,
3431 snd_device_t snd_device,
3432 int *num_devices,
3433 snd_device_t *new_snd_devices)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3434{
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3435 int ret = -EINVAL;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3436 struct platform_data *my_data = (struct platform_data *)platform;
3437
3438 if ( NULL == num_devices || NULL == new_snd_devices || NULL == my_data) {
3439 ALOGE("%s: NULL pointer ..", __func__);
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3440 return -EINVAL;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3441 }
3442
3443 /*
3444 * If wired headset/headphones/line devices share the same backend
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3445 * with speaker/earpiece this routine returns -EINVAL.
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3446 */
3447 if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES &&
3448 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HEADPHONES)) {
3449 *num_devices = 2;
3450 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3451 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3452 ret = 0;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3453 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET &&
3454 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_ANC_HEADSET)) {
3455 *num_devices = 2;
3456 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3457 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
3458 ret = 0;
3459 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET &&
3460 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_ANC_FB_HEADSET)) {
3461 *num_devices = 2;
3462 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3463 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
3464 ret = 0;
3465 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES &&
3466 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_HEADPHONES)) {
3467 *num_devices = 2;
3468 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
3469 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_HEADPHONES;
3470 ret = 0;
3471 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET &&
3472 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_ANC_HEADSET)) {
3473 *num_devices = 2;
3474 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
3475 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
3476 ret = 0;
3477 } else if (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET &&
3478 !platform_check_backends_match(SND_DEVICE_OUT_VOICE_SPEAKER, SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)) {
3479 *num_devices = 2;
3480 new_snd_devices[0] = SND_DEVICE_OUT_VOICE_SPEAKER;
3481 new_snd_devices[1] = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
3482 ret = 0;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3483 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI &&
3484 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HDMI)) {
3485 *num_devices = 2;
3486 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3487 new_snd_devices[1] = SND_DEVICE_OUT_HDMI;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3488 ret = 0;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3489 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT &&
3490 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_DISPLAY_PORT)) {
3491 *num_devices = 2;
3492 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3493 new_snd_devices[1] = SND_DEVICE_OUT_DISPLAY_PORT;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3494 ret = 0;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]3495 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET &&
3496 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_USB_HEADSET)) {
3497 *num_devices = 2;
3498 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3499 new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3500 ret = 0;
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]3501 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_SCO &&
3502 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_BT_SCO)) {
3503 *num_devices = 2;
3504 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3505 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO;
3506 ret = 0;
3507 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB &&
3508 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_BT_SCO_WB)) {
3509 *num_devices = 2;
3510 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3511 new_snd_devices[1] = SND_DEVICE_OUT_BT_SCO_WB;
3512 ret = 0;
Naresh Tannirucd2353e2016-08-19 00:37:25 +0530[diff] [blame]3513 } else if (SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) {
3514 *num_devices = 2;
3515 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
3516 new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3517 ret = 0;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3518 }
3519
3520 ALOGD("%s: snd_device(%d) num devices(%d) new_snd_devices(%d)", __func__,
3521 snd_device, *num_devices, *new_snd_devices);
3522
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]3523 return ret;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]3524}
3525
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3526int platform_get_ext_disp_type(void *platform)
3527{
3528 int disp_type;
3529 struct platform_data *my_data = (struct platform_data *)platform;
3530
3531 if (my_data->ext_disp_type != EXT_DISPLAY_TYPE_NONE) {
3532 ALOGD("%s: Returning cached ext disp type:%s",
3533 __func__, (my_data->ext_disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
3534 return my_data->ext_disp_type;
3535 }
3536
3537#ifdef DISPLAY_PORT_ENABLED
3538 struct audio_device *adev = my_data->adev;
3539 struct mixer_ctl *ctl;
3540 char *mixer_ctl_name = "External Display Type";
3541
3542 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3543 if (!ctl) {
3544 ALOGE("%s: Could not get ctl for mixer cmd - %s",
3545 __func__, mixer_ctl_name);
3546 return -EINVAL;
3547 }
3548
3549 disp_type = mixer_ctl_get_value(ctl, 0);
3550 if (disp_type == EXT_DISPLAY_TYPE_NONE) {
3551 ALOGE("%s: Invalid external display type: %d", __func__, disp_type);
3552 return -EINVAL;
3553 }
3554#else
3555 disp_type = EXT_DISPLAY_TYPE_HDMI;
3556#endif
3557
3558 my_data->ext_disp_type = disp_type;
3559 ALOGD("%s: ext disp type:%s", __func__, (disp_type == EXT_DISPLAY_TYPE_DP) ? "DisplayPort" : "HDMI");
3560 return disp_type;
3561}
3562
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]3563snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *out)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3564{
3565 struct platform_data *my_data = (struct platform_data *)platform;
3566 struct audio_device *adev = my_data->adev;
3567 audio_mode_t mode = adev->mode;
3568 snd_device_t snd_device = SND_DEVICE_NONE;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]3569 audio_devices_t devices = out->devices;
3570 unsigned int sample_rate = out->sample_rate;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3571 int na_mode = platform_get_native_support();
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3572
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]3573 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
3574 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
3575 int channel_count = popcount(channel_mask);
3576
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3577 ALOGV("%s: enter: output devices(%#x)", __func__, devices);
3578 if (devices == AUDIO_DEVICE_NONE ||
3579 devices & AUDIO_DEVICE_BIT_IN) {
3580 ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
3581 goto exit;
3582 }
3583
Shiv Maliyappanahallibd401262015-08-17 11:02:21 -0700[diff] [blame]3584 if (popcount(devices) == 2) {
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3585 bool is_active_voice_call = false;
3586
3587 /*
3588 * This is special case handling for combo device use case during
3589 * voice call. APM route use case to combo device if stream type is
3590 * enforced audible (e.g. Camera shutter sound).
3591 */
3592 if ((mode == AUDIO_MODE_IN_CALL) ||
3593 voice_is_in_call(adev) ||
3594 voice_extn_compress_voip_is_active(adev))
3595 is_active_voice_call = true;
3596
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]3597 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
3598 AUDIO_DEVICE_OUT_SPEAKER)) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]3599 if (my_data->external_spk_1)
3600 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1;
3601 else if (my_data->external_spk_2)
3602 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3603 else if (is_active_voice_call)
3604 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES;
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]3605 else
3606 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]3607 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
3608 AUDIO_DEVICE_OUT_SPEAKER)) {
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]3609 if (audio_extn_get_anc_enabled()) {
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3610 if (audio_extn_should_use_fb_anc()) {
3611 if (is_active_voice_call)
3612 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_FB_HEADSET;
3613 else
3614 snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET;
3615 } else {
3616 if (is_active_voice_call)
3617 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_ANC_HEADSET;
3618 else
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3619 snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3620 }
Meng Wang841d6c02017-01-24 12:34:36 +0800[diff] [blame]3621 } else if (my_data->external_spk_1)
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]3622 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_1;
3623 else if (my_data->external_spk_2)
3624 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES_EXTERNAL_2;
Preetam Singh Ranawat91132162017-03-13 20:32:03 +0530[diff] [blame]3625 else {
3626 if (is_active_voice_call)
3627 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_AND_VOICE_HEADPHONES;
3628 else
3629 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
3630 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]3631 } else if (devices == (AUDIO_DEVICE_OUT_LINE |
3632 AUDIO_DEVICE_OUT_SPEAKER)) {
3633 snd_device = SND_DEVICE_OUT_SPEAKER_AND_LINE;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]3634 } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL |
3635 AUDIO_DEVICE_OUT_SPEAKER)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3636 switch(my_data->ext_disp_type) {
3637 case EXT_DISPLAY_TYPE_HDMI:
3638 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI;
3639 break;
3640 case EXT_DISPLAY_TYPE_DP:
3641 snd_device = SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT;
3642 break;
3643 default:
3644 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
3645 goto exit;
3646 }
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]3647 } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
3648 AUDIO_DEVICE_OUT_SPEAKER)) {
3649 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]3650 } else if (devices == (AUDIO_DEVICE_OUT_USB_DEVICE |
3651 AUDIO_DEVICE_OUT_SPEAKER)) {
3652 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]3653 } else if ((devices & AUDIO_DEVICE_OUT_SPEAKER) &&
3654 (devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
3655 snd_device = SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP;
kunleizbe6a8442017-08-08 17:11:35 +0800[diff] [blame]3656 } else if ((devices & AUDIO_DEVICE_OUT_ALL_SCO) &&
3657 ((devices & ~AUDIO_DEVICE_OUT_ALL_SCO) == AUDIO_DEVICE_OUT_SPEAKER)) {
3658 snd_device = adev->bt_wb_speech_enabled ?
3659 SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB :
3660 SND_DEVICE_OUT_SPEAKER_AND_BT_SCO;
Mingming Yin4a72d652014-01-03 18:54:18 -0800[diff] [blame]3661 } else {
3662 ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
3663 goto exit;
3664 }
3665 if (snd_device != SND_DEVICE_NONE) {
3666 goto exit;
3667 }
3668 }
3669
3670 if (popcount(devices) != 1) {
3671 ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
3672 goto exit;
3673 }
3674
Venkata Narendra Kumar Guttabfdfa152015-06-22 14:25:35 +0530[diff] [blame]3675 if ((mode == AUDIO_MODE_IN_CALL) ||
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]3676 voice_is_in_call(adev) ||
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3677 voice_extn_compress_voip_is_active(adev)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3678 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]3679 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
3680 devices & AUDIO_DEVICE_OUT_LINE) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]3681 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
3682 !voice_extn_compress_voip_is_active(adev)) {
3683 switch (adev->voice.tty_mode) {
3684 case TTY_MODE_FULL:
3685 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
3686 break;
3687 case TTY_MODE_VCO:
3688 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
3689 break;
3690 case TTY_MODE_HCO:
3691 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
3692 break;
3693 default:
3694 ALOGE("%s: Invalid TTY mode (%#x)",
3695 __func__, adev->voice.tty_mode);
3696 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]3697 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
3698 snd_device = SND_DEVICE_OUT_VOICE_LINE;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3699 } else if (audio_extn_get_anc_enabled()) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]3700 if (audio_extn_should_use_fb_anc())
3701 snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
3702 else
3703 snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3704 } else {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3705 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3706 }
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]3707 } else if (devices & AUDIO_DEVICE_OUT_USB_DEVICE) {
3708 if (voice_is_in_call(adev)) {
3709 switch (adev->voice.tty_mode) {
3710 case TTY_MODE_FULL:
3711 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_USB;
3712 break;
3713 case TTY_MODE_VCO:
3714 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_USB;
3715 break;
3716 case TTY_MODE_HCO:
3717 // since Hearing will be on handset\speaker, use existing device
3718 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
3719 break;
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]3720 case TTY_MODE_OFF:
3721 break;
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]3722 default:
3723 ALOGE("%s: Invalid TTY mode (%#x)",
3724 __func__, adev->voice.tty_mode);
3725 }
3726 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]3727 if (snd_device == SND_DEVICE_NONE) {
3728 snd_device = audio_extn_usb_is_capture_supported() ?
3729 SND_DEVICE_OUT_VOICE_USB_HEADSET :
3730 SND_DEVICE_OUT_VOICE_USB_HEADPHONES;
3731 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3732 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]3733 if (adev->bt_wb_speech_enabled)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3734 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
3735 else
3736 snd_device = SND_DEVICE_OUT_BT_SCO;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3737 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3738 if (my_data->is_vbat_speaker) {
kunleizaa6a3f12017-01-19 12:28:28 +0800[diff] [blame]3739 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
3740 if (my_data->mono_speaker == SPKR_1)
3741 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_VBAT;
3742 else
3743 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT;
3744 } else
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3745 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_VBAT;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3746 } else {
kunleizaa6a3f12017-01-19 12:28:28 +0800[diff] [blame]3747 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
3748 if (my_data->mono_speaker == SPKR_1)
3749 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
3750 else
3751 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_2;
3752 } else
3753 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]3754 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]3755 } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
3756 snd_device = SND_DEVICE_OUT_BT_A2DP;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3757 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
3758 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
3759 snd_device = SND_DEVICE_OUT_USB_HEADSET;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]3760 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
3761 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3762 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
Ravi Kumar Alamandaceb40822013-11-06 11:01:47 -0800[diff] [blame]3763 if (audio_extn_should_use_handset_anc(channel_count))
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]3764 snd_device = SND_DEVICE_OUT_ANC_HANDSET;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3765 else
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]3766 snd_device = SND_DEVICE_OUT_VOICE_HANDSET;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]3767 } else if (devices & AUDIO_DEVICE_OUT_TELEPHONY_TX)
3768 snd_device = SND_DEVICE_OUT_VOICE_TX;
3769
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3770 if (snd_device != SND_DEVICE_NONE) {
3771 goto exit;
3772 }
3773 }
3774
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3775 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]3776 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
3777 devices & AUDIO_DEVICE_OUT_LINE) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]3778 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET
3779 && audio_extn_get_anc_enabled()) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3780 if (audio_extn_should_use_fb_anc())
3781 snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET;
3782 else
3783 snd_device = SND_DEVICE_OUT_ANC_HEADSET;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3784 } else if (NATIVE_AUDIO_MODE_SRC == na_mode &&
3785 OUTPUT_SAMPLING_RATE_44100 == sample_rate) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]3786 snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]3787 } else if (NATIVE_AUDIO_MODE_MULTIPLE_44_1 == na_mode &&
3788 (sample_rate % OUTPUT_SAMPLING_RATE_44100 == 0) &&
3789 (out->format != AUDIO_FORMAT_DSD)) {
3790 snd_device = SND_DEVICE_OUT_HEADPHONES_44_1;
3791 } else if (out->format == AUDIO_FORMAT_DSD) {
3792 snd_device = SND_DEVICE_OUT_HEADPHONES_DSD;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]3793 } else
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]3794 snd_device = SND_DEVICE_OUT_HEADPHONES;
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]3795 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
3796 snd_device = SND_DEVICE_OUT_LINE;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3797 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]3798 if (my_data->external_spk_1)
3799 snd_device = SND_DEVICE_OUT_SPEAKER_EXTERNAL_1;
3800 else if (my_data->external_spk_2)
3801 snd_device = SND_DEVICE_OUT_SPEAKER_EXTERNAL_2;
3802 else if (adev->speaker_lr_swap)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3803 snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE;
Banajit Goswami20cdd212015-09-11 01:11:30 -0700[diff] [blame]3804 else if (my_data->is_vbat_speaker)
3805 snd_device = SND_DEVICE_OUT_SPEAKER_VBAT;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3806 else
3807 snd_device = SND_DEVICE_OUT_SPEAKER;
3808 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]3809 if (adev->bt_wb_speech_enabled)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]3810 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
3811 else
3812 snd_device = SND_DEVICE_OUT_BT_SCO;
Naresh Tanniru9d027a62015-03-13 01:32:10 +0530[diff] [blame]3813 } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
3814 snd_device = SND_DEVICE_OUT_BT_A2DP;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3815 } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]3816 switch(my_data->ext_disp_type) {
3817 case EXT_DISPLAY_TYPE_HDMI:
3818 snd_device = SND_DEVICE_OUT_HDMI;
3819 break;
3820 case EXT_DISPLAY_TYPE_DP:
3821 snd_device = SND_DEVICE_OUT_DISPLAY_PORT;
3822 break;
3823 default:
3824 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
3825 goto exit;
3826 }
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3827 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
3828 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]3829 ALOGD("%s: setting USB hadset channel capability(2) for Proxy", __func__);
3830 audio_extn_set_afe_proxy_channel_mixer(adev, 2);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3831 snd_device = SND_DEVICE_OUT_USB_HEADSET;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]3832 } else if (devices & AUDIO_DEVICE_OUT_USB_DEVICE) {
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]3833 if (audio_extn_usb_is_capture_supported())
3834 snd_device = SND_DEVICE_OUT_USB_HEADSET;
3835 else
3836 snd_device = SND_DEVICE_OUT_USB_HEADPHONES;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]3837 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
3838 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3839 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
3840 snd_device = SND_DEVICE_OUT_HANDSET;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3841 } else if (devices & AUDIO_DEVICE_OUT_PROXY) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]3842 channel_count = audio_extn_get_afe_proxy_channel_count();
3843 ALOGD("%s: setting sink capability(%d) for Proxy", __func__, channel_count);
3844 audio_extn_set_afe_proxy_channel_mixer(adev, channel_count);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]3845 snd_device = SND_DEVICE_OUT_AFE_PROXY;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3846 } else {
3847 ALOGE("%s: Unknown device(s) %#x", __func__, devices);
3848 }
3849exit:
3850 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
3851 return snd_device;
3852}
3853
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]3854#ifdef DYNAMIC_ECNS_ENABLED
3855static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
3856 audio_devices_t out_device,
3857 audio_devices_t in_device)
3858{
3859 struct audio_device *adev = my_data->adev;
3860 snd_device_t snd_device = SND_DEVICE_NONE;
3861
3862 if (my_data->fluence_type != FLUENCE_NONE) {
3863 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
3864 if (my_data->fluence_in_spkr_mode) {
3865 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
3866 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
3867 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS;
3868 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3869 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3870 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
3871 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
3872 else
3873 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
3874 }
3875 adev->acdb_settings |= DMIC_FLAG;
3876 } else
3877 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
3878 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
3879 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3880 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3881 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
3882 adev->acdb_settings |= DMIC_FLAG;
3883 } else
3884 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
3885 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
3886 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
3887 }
3888 platform_set_echo_reference(adev, true, out_device);
3889 }
3890
3891 return snd_device;
3892}
3893#else
3894static snd_device_t get_snd_device_for_voice_comm(struct platform_data *my_data,
3895 audio_devices_t out_device,
3896 audio_devices_t in_device)
3897{
3898 struct audio_device *adev = my_data->adev;
3899 snd_device_t snd_device = SND_DEVICE_NONE;
3900
3901 if (my_data->fluence_type != FLUENCE_NONE && adev->active_input->enable_aec &&
3902 adev->active_input->enable_ns) {
3903 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
3904 if (my_data->fluence_in_spkr_mode) {
3905 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
3906 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
3907 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS;
3908 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3909 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3910 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
3911 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
3912 else
3913 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
3914 }
3915 adev->acdb_settings |= DMIC_FLAG;
3916 } else
3917 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
3918 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
3919 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3920 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3921 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
3922 adev->acdb_settings |= DMIC_FLAG;
3923 } else
3924 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
3925 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
3926 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
3927 } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE) {
3928 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC_AEC;
3929 }
3930 platform_set_echo_reference(adev, true, out_device);
3931 } else if (my_data->fluence_type != FLUENCE_NONE &&
3932 adev->active_input->enable_aec) {
3933 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
3934 if (my_data->fluence_in_spkr_mode) {
3935 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
3936 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
3937 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC;
3938 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3939 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3940 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
3941 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE;
3942 else
3943 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
3944 }
3945 adev->acdb_settings |= DMIC_FLAG;
3946 } else
3947 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
3948 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
3949 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3950 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3951 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
3952 adev->acdb_settings |= DMIC_FLAG;
3953 } else
3954 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
3955 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
3956 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
3957 } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE) {
3958 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC_AEC;
3959 }
3960 platform_set_echo_reference(adev, true, out_device);
3961 } else if (my_data->fluence_type != FLUENCE_NONE &&
3962 adev->active_input->enable_ns) {
3963 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
3964 if (my_data->fluence_in_spkr_mode) {
3965 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
3966 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
3967 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_NS;
3968 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3969 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3970 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
3971 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE;
3972 else
3973 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
3974 }
3975 adev->acdb_settings |= DMIC_FLAG;
3976 } else
3977 snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
3978 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
3979 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
3980 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
3981 snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
3982 adev->acdb_settings |= DMIC_FLAG;
3983 } else
3984 snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
3985 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
3986 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
3987 }
3988 platform_set_echo_reference(adev, false, out_device);
3989 } else
3990 platform_set_echo_reference(adev, false, out_device);
3991
3992 return snd_device;
3993}
3994#endif //DYNAMIC_ECNS_ENABLED
3995
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]3996snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
3997{
3998 struct platform_data *my_data = (struct platform_data *)platform;
3999 struct audio_device *adev = my_data->adev;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]4000 /*
4001 * TODO: active_input always points to last opened input. Source returned will
4002 * be wrong if more than one active inputs are present.
4003 */
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4004 audio_source_t source = (adev->active_input == NULL) ?
4005 AUDIO_SOURCE_DEFAULT : adev->active_input->source;
4006
4007 audio_mode_t mode = adev->mode;
4008 audio_devices_t in_device = ((adev->active_input == NULL) ?
4009 AUDIO_DEVICE_NONE : adev->active_input->device)
4010 & ~AUDIO_DEVICE_BIT_IN;
4011 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
4012 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
4013 snd_device_t snd_device = SND_DEVICE_NONE;
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4014 int channel_count = popcount(channel_mask);
Ashish Jainb8d55fd2016-12-29 14:00:24 +0530[diff] [blame]4015 int str_bitwidth = (adev->active_input == NULL) ?
4016 CODEC_BACKEND_DEFAULT_BIT_WIDTH : adev->active_input->bit_width;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4017
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4018 ALOGV("%s: enter: out_device(%#x) in_device(%#x) channel_count (%d) channel_mask (0x%x)",
4019 __func__, out_device, in_device, channel_count, channel_mask);
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4020 if (my_data->external_mic) {
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]4021 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]4022 voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) {
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4023 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
4024 out_device & AUDIO_DEVICE_OUT_EARPIECE ||
4025 out_device & AUDIO_DEVICE_OUT_SPEAKER )
4026 snd_device = SND_DEVICE_IN_HANDSET_MIC_EXTERNAL;
4027 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
4028 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
4029 snd_device = SND_DEVICE_IN_HANDSET_MIC_EXTERNAL;
4030 }
4031 }
4032
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]4033 if (snd_device != AUDIO_DEVICE_NONE)
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4034 goto exit;
4035
kunleiz16dbcc32016-12-13 18:23:04 +0800[diff] [blame]4036 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]4037 voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800[diff] [blame]4038 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
4039 !voice_extn_compress_voip_is_active(adev)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4040 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4041 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
4042 out_device & AUDIO_DEVICE_OUT_LINE) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4043 switch (adev->voice.tty_mode) {
Aniket Kumar Lata91886592017-05-25 16:53:32 -0700[diff] [blame]4044 case TTY_MODE_FULL:
4045 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
4046 break;
4047 case TTY_MODE_VCO:
4048 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
4049 break;
4050 case TTY_MODE_HCO:
4051 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
4052 break;
4053 default:
4054 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->voice.tty_mode);
4055 }
4056 goto exit;
4057 } else if (out_device & AUDIO_DEVICE_OUT_USB_DEVICE) {
4058 switch (adev->voice.tty_mode) {
4059 case TTY_MODE_FULL:
4060 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC;
4061 break;
4062 case TTY_MODE_VCO:
4063 // since voice will be captured from handset mic, use existing device
4064 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
4065 break;
4066 case TTY_MODE_HCO:
4067 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC;
4068 break;
4069 default:
4070 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->voice.tty_mode);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4071 }
4072 goto exit;
4073 }
4074 }
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]4075 if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4076 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
4077 out_device & AUDIO_DEVICE_OUT_LINE) {
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4078 if (out_device & AUDIO_DEVICE_OUT_EARPIECE &&
4079 audio_extn_should_use_handset_anc(channel_count)) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4080 if ((my_data->fluence_type != FLUENCE_NONE) &&
4081 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Shiv Maliyappanahallidd287262016-01-08 15:57:07 -0800[diff] [blame]4082 snd_device = SND_DEVICE_IN_VOICE_FLUENCE_DMIC_AANC;
4083 adev->acdb_settings |= DMIC_FLAG;
4084 } else {
4085 snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC;
4086 }
Banajit Goswamide0ea452014-04-07 12:11:47 -0700[diff] [blame]4087 adev->acdb_settings |= ANC_FLAG;
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -0700[diff] [blame]4088 } else if (my_data->fluence_type == FLUENCE_NONE ||
Vikram Pandurangae7b21342017-06-05 15:57:23 -0700[diff] [blame]4089 (my_data->fluence_in_voice_call == false &&
4090 my_data->fluence_in_hfp_call == false)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4091 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]4092 if (audio_extn_hfp_is_active(adev))
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]4093 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4094 } else {
Ravi Kumar Alamandaceb40822013-11-06 11:01:47 -0800[diff] [blame]4095 snd_device = SND_DEVICE_IN_VOICE_DMIC;
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4096 adev->acdb_settings |= DMIC_FLAG;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4097 }
4098 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
4099 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]4100 if (audio_extn_hfp_is_active(adev))
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]4101 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4102 } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]4103 if (adev->bt_wb_speech_enabled) {
4104 if (adev->bluetooth_nrec)
4105 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
4106 else
4107 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
4108 } else {
4109 if (adev->bluetooth_nrec)
4110 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
4111 else
4112 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
4113 }
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]4114 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]4115 if (my_data->fluence_type != FLUENCE_NONE &&
Dhanalakshmi Siddani3dbfc382017-03-21 15:15:03 +0530[diff] [blame]4116 (my_data->fluence_in_voice_call ||
4117 my_data->fluence_in_hfp_call) &&
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]4118 my_data->fluence_in_spkr_mode) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4119 if((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4120 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4121 adev->acdb_settings |= QMIC_FLAG;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]4122 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC;
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]4123 } else {
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4124 adev->acdb_settings |= DMIC_FLAG;
Narsinga Rao Chella61e0f9b2014-03-06 21:25:22 -0800[diff] [blame]4125 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
4126 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE;
4127 else
4128 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC;
Mingming Yin8e5a4f62013-10-07 15:23:41 -0700[diff] [blame]4129 }
Dhanalakshmi Siddani1eb3a352017-06-05 15:18:23 +0530[diff] [blame]4130 if (audio_extn_hfp_is_active(adev))
4131 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4132 } else {
4133 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +0530[diff] [blame]4134 if (audio_extn_hfp_is_active(adev))
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]4135 platform_set_echo_reference(adev, true, out_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4136 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4137 } else if (out_device & AUDIO_DEVICE_OUT_TELEPHONY_TX) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700[diff] [blame]4138 snd_device = SND_DEVICE_IN_VOICE_RX;
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4139 } else if (out_device & AUDIO_DEVICE_OUT_USB_DEVICE) {
4140 if (audio_extn_usb_is_capture_supported()) {
4141 snd_device = SND_DEVICE_IN_VOICE_USB_HEADSET_MIC;
4142 }
4143 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4144 } else if (source == AUDIO_SOURCE_CAMCORDER) {
4145 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
4146 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]4147
4148 if (str_bitwidth == 16) {
4149 if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
4150 (my_data->source_mic_type & SOURCE_DUAL_MIC) &&
4151 (channel_count == 2))
4152 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
4153 else
4154 snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
4155 }
4156 /*
4157 * for other bit widths
4158 */
4159 else {
4160 if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
4161 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
4162 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
4163 snd_device = SND_DEVICE_IN_UNPROCESSED_STEREO_MIC;
4164 }
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4165 else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]4166 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4167 snd_device = SND_DEVICE_IN_UNPROCESSED_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4168 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]4169 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4170 snd_device = SND_DEVICE_IN_UNPROCESSED_QUAD_MIC;
4171 } else {
4172 snd_device = SND_DEVICE_IN_UNPROCESSED_MIC;
4173 }
4174 }
4175 }
4176 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4177 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4178 if (my_data->fluence_in_voice_rec && channel_count == 1) {
4179 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4180 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Ben Romberger182c8252016-07-18 16:54:54 -0700[diff] [blame]4181 snd_device = SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4182 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4183 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
Ben Rombergera4d76db2016-10-13 15:26:02 -0700[diff] [blame]4184 snd_device = SND_DEVICE_IN_VOICE_REC_TMIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4185 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
4186 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Vidyakumar Athota78b70c02015-06-29 17:19:45 -0700[diff] [blame]4187 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
4188 }
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4189 platform_set_echo_reference(adev, true, out_device);
4190 } else if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
4191 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
4192 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
4193 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4194 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4195 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4196 snd_device = SND_DEVICE_IN_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4197 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4198 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4199 snd_device = SND_DEVICE_IN_QUAD_MIC;
4200 }
4201 if (snd_device == SND_DEVICE_NONE) {
4202 if (adev->active_input->enable_ns)
4203 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
4204 else
4205 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -0800[diff] [blame]4206 }
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4207 } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE) {
4208 snd_device = SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4209 }
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]4210 } else if (source == AUDIO_SOURCE_UNPROCESSED) {
4211 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
4212 if (((channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) ||
4213 (channel_mask == AUDIO_CHANNEL_IN_STEREO)) &&
4214 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
4215 snd_device = SND_DEVICE_IN_UNPROCESSED_STEREO_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4216 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_3) &&
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]4217 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4218 snd_device = SND_DEVICE_IN_UNPROCESSED_THREE_MIC;
Dhananjay Kumara5d42b32017-01-11 21:22:16 +0530[diff] [blame]4219 } else if (((int)channel_mask == (int)AUDIO_CHANNEL_INDEX_MASK_4) &&
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]4220 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
4221 snd_device = SND_DEVICE_IN_UNPROCESSED_QUAD_MIC;
4222 } else {
4223 snd_device = SND_DEVICE_IN_UNPROCESSED_MIC;
4224 }
4225 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
Arun Tom Abrahamf888ae82016-12-10 04:51:49 +0530[diff] [blame]4226 snd_device = SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC;
Aniket Kumar Lata3e2e1232017-06-16 17:25:07 -0700[diff] [blame]4227 } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE) {
4228 snd_device = SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC;
Chaithanya Krishna Bacharaju24f86f32016-05-26 16:34:53 +0530[diff] [blame]4229 }
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]4230 } else if ((source == AUDIO_SOURCE_VOICE_COMMUNICATION) ||
4231 (mode == AUDIO_MODE_IN_COMMUNICATION)) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4232 if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
4233 in_device = AUDIO_DEVICE_IN_BACK_MIC;
4234 if (adev->active_input) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700[diff] [blame]4235 snd_device = get_snd_device_for_voice_comm(my_data, out_device, in_device);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4236 }
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]4237 } else if (source == AUDIO_SOURCE_MIC) {
Apoorv Raghuvanshic0536542013-11-14 16:25:59 -0800[diff] [blame]4238 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC &&
4239 channel_count == 1 ) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]4240 if(my_data->fluence_in_audio_rec) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4241 if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4242 (my_data->source_mic_type & SOURCE_QUAD_MIC)) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]4243 snd_device = SND_DEVICE_IN_HANDSET_QMIC;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]4244 platform_set_echo_reference(adev, true, out_device);
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4245 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
4246 (my_data->source_mic_type & SOURCE_THREE_MIC)) {
4247 snd_device = SND_DEVICE_IN_HANDSET_TMIC;
4248 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
4249 (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]4250 snd_device = SND_DEVICE_IN_HANDSET_DMIC;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]4251 platform_set_echo_reference(adev, true, out_device);
Narsinga Rao Chella975572e2014-10-21 11:49:00 -0700[diff] [blame]4252 }
Ravi Kumar Alamanda7076b162014-03-07 11:40:24 -0800[diff] [blame]4253 }
Ravi Kumar Alamandab034ddb2013-11-06 15:52:18 -0800[diff] [blame]4254 }
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]4255 } else if (source == AUDIO_SOURCE_FM_TUNER) {
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]4256 snd_device = SND_DEVICE_IN_CAPTURE_FM;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4257 } else if (source == AUDIO_SOURCE_DEFAULT) {
4258 goto exit;
4259 }
4260
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -0700[diff] [blame]4261 if (adev->active_input && (audio_extn_ssr_get_stream() == adev->active_input))
4262 snd_device = SND_DEVICE_IN_THREE_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4263
4264 if (snd_device != SND_DEVICE_NONE) {
4265 goto exit;
4266 }
4267
4268 if (in_device != AUDIO_DEVICE_NONE &&
4269 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
4270 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
4271 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -0700[diff] [blame]4272 if (adev->active_input && (audio_extn_ssr_get_stream() == adev->active_input))
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]4273 snd_device = SND_DEVICE_IN_QUAD_MIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4274 else if ((my_data->fluence_type & (FLUENCE_DUAL_MIC | FLUENCE_QUAD_MIC)) &&
4275 (channel_count == 2) && (my_data->source_mic_type & SOURCE_DUAL_MIC))
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]4276 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -0700[diff] [blame]4277 else
4278 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4279 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
4280 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
4281 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
4282 snd_device = SND_DEVICE_IN_HEADSET_MIC;
4283 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]4284 if (adev->bt_wb_speech_enabled) {
4285 if (adev->bluetooth_nrec)
4286 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
4287 else
4288 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
4289 } else {
4290 if (adev->bluetooth_nrec)
4291 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
4292 else
4293 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
4294 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4295 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
4296 snd_device = SND_DEVICE_IN_HDMI_MIC;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4297 } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
4298 in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
4299 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]4300 } else if (in_device & AUDIO_DEVICE_IN_FM_TUNER) {
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700[diff] [blame]4301 snd_device = SND_DEVICE_IN_CAPTURE_FM;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]4302 } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE ) {
4303 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4304 } else {
4305 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
4306 ALOGW("%s: Using default handset-mic", __func__);
4307 snd_device = SND_DEVICE_IN_HANDSET_MIC;
4308 }
4309 } else {
4310 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
4311 snd_device = SND_DEVICE_IN_HANDSET_MIC;
4312 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
4313 snd_device = SND_DEVICE_IN_HEADSET_MIC;
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]4314 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4315 if ((my_data->source_mic_type & SOURCE_DUAL_MIC) &&
4316 (channel_count == 2)) {
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]4317 snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4318 } else if ((my_data->source_mic_type & SOURCE_MONO_MIC) &&
4319 (channel_count == 1)) {
4320 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
4321 } else {
4322 ALOGE("%s: something wrong: source type (%d) channel_count (%d) .."
4323 " no combination found .. setting to mono", __func__,
4324 my_data->source_mic_type, channel_count);
Apoorv Raghuvanshi6bd8dbf2013-10-19 18:37:52 -0700[diff] [blame]4325 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4326 }
Ravi Kumar Alamanda52de13c2015-10-17 22:21:52 -0700[diff] [blame]4327 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
4328 out_device & AUDIO_DEVICE_OUT_LINE) {
Narsinga Rao Chella97db8702014-10-03 13:34:45 -0700[diff] [blame]4329 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4330 } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]4331 if (adev->bt_wb_speech_enabled) {
4332 if (adev->bluetooth_nrec)
4333 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
4334 else
4335 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
4336 } else {
4337 if (adev->bluetooth_nrec)
4338 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
4339 else
4340 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
4341 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4342 } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
4343 snd_device = SND_DEVICE_IN_HDMI_MIC;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -0700[diff] [blame]4344 } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
4345 out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
4346 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]4347 } else if (out_device & AUDIO_DEVICE_OUT_USB_DEVICE) {
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]4348 if (audio_extn_usb_is_capture_supported())
4349 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
4350 else
4351 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4352 } else {
4353 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
4354 ALOGW("%s: Using default handset-mic", __func__);
4355 snd_device = SND_DEVICE_IN_HANDSET_MIC;
4356 }
4357 }
4358exit:
4359 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
4360 return snd_device;
4361}
4362
4363int platform_set_hdmi_channels(void *platform, int channel_count)
4364{
4365 struct platform_data *my_data = (struct platform_data *)platform;
4366 struct audio_device *adev = my_data->adev;
4367 struct mixer_ctl *ctl;
4368 const char *channel_cnt_str = NULL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4369 char *mixer_ctl_name;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4370 switch (channel_count) {
4371 case 8:
4372 channel_cnt_str = "Eight"; break;
4373 case 7:
4374 channel_cnt_str = "Seven"; break;
4375 case 6:
4376 channel_cnt_str = "Six"; break;
4377 case 5:
4378 channel_cnt_str = "Five"; break;
4379 case 4:
4380 channel_cnt_str = "Four"; break;
4381 case 3:
4382 channel_cnt_str = "Three"; break;
4383 default:
4384 channel_cnt_str = "Two"; break;
4385 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4386
4387 switch(my_data->ext_disp_type) {
4388 case EXT_DISPLAY_TYPE_HDMI:
4389 mixer_ctl_name = "HDMI_RX Channels";
4390 break;
4391 case EXT_DISPLAY_TYPE_DP:
4392 mixer_ctl_name = "Display Port RX Channels";
4393 break;
4394 default:
4395 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
4396 return -EINVAL;
4397 }
4398
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4399 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4400 if (!ctl) {
4401 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4402 __func__, mixer_ctl_name);
4403 return -EINVAL;
4404 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]4405 ALOGV("Ext disp channel count: %s", channel_cnt_str);
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4406 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
4407 return 0;
4408}
4409
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]4410int platform_edid_get_max_channels(void *platform)
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4411{
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]4412 int channel_count;
4413 int max_channels = 2;
4414 int i = 0, ret = 0;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]4415 struct platform_data *my_data = (struct platform_data *)platform;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]4416 edid_audio_info *info = NULL;
4417 ret = platform_get_edid_info(platform);
4418 info = (edid_audio_info *)my_data->edid_info;
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4419
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]4420 if(ret == 0 && info != NULL) {
4421 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
4422 ALOGV("%s:format %d channel %d", __func__,
4423 info->audio_blocks_array[i].format_id,
4424 info->audio_blocks_array[i].channels);
4425 if (info->audio_blocks_array[i].format_id == LPCM) {
4426 channel_count = info->audio_blocks_array[i].channels;
4427 if (channel_count > max_channels) {
4428 max_channels = channel_count;
4429 }
4430 }
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700[diff] [blame]4431 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4432 }
Eric Laurentb23d5282013-05-14 15:27:20 -0700[diff] [blame]4433 return max_channels;
4434}
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4435
4436static int platform_set_slowtalk(struct platform_data *my_data, bool state)
4437{
4438 int ret = 0;
4439 struct audio_device *adev = my_data->adev;
4440 struct mixer_ctl *ctl;
4441 const char *mixer_ctl_name = "Slowtalk Enable";
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]4442 long set_values[ ] = {0,
4443 ALL_SESSION_VSID};
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4444
4445 set_values[0] = state;
4446 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4447 if (!ctl) {
4448 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4449 __func__, mixer_ctl_name);
4450 ret = -EINVAL;
4451 } else {
4452 ALOGV("Setting slowtalk state: %d", state);
4453 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
4454 my_data->slowtalk = state;
4455 }
4456
Vidyakumar Athotad9d9ff32013-11-13 11:46:52 -0800[diff] [blame]4457 if (my_data->csd != NULL) {
4458 ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state);
4459 if (ret < 0) {
4460 ALOGE("%s: csd_client_disable_device, failed, error %d",
4461 __func__, ret);
4462 }
4463 }
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4464 return ret;
4465}
4466
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]4467static int set_hd_voice(struct platform_data *my_data, bool state)
4468{
4469 struct audio_device *adev = my_data->adev;
4470 struct mixer_ctl *ctl;
4471 char *mixer_ctl_name = "HD Voice Enable";
4472 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]4473 long set_values[ ] = {0,
4474 ALL_SESSION_VSID};
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]4475
4476 set_values[0] = state;
4477 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4478 if (!ctl) {
4479 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4480 __func__, mixer_ctl_name);
4481 return -EINVAL;
4482 } else {
4483 ALOGV("Setting HD Voice state: %d", state);
4484 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
4485 my_data->hd_voice = state;
4486 }
4487
4488 return ret;
4489}
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4490
4491static int update_external_device_status(struct platform_data *my_data,
4492 char* event_name, bool status)
4493{
4494 int ret = 0;
4495 struct audio_usecase *usecase;
4496 struct listnode *node;
4497
4498 ALOGD("Recieved external event switch %s", event_name);
4499
4500 if (!strcmp(event_name, EVENT_EXTERNAL_SPK_1))
4501 my_data->external_spk_1 = status;
4502 else if (!strcmp(event_name, EVENT_EXTERNAL_SPK_2))
4503 my_data->external_spk_2 = status;
4504 else if (!strcmp(event_name, EVENT_EXTERNAL_MIC))
4505 my_data->external_mic = status;
4506 else {
4507 ALOGE("The audio event type is not found");
4508 return -EINVAL;
4509 }
4510
4511 list_for_each(node, &my_data->adev->usecase_list) {
4512 usecase = node_to_item(node, struct audio_usecase, list);
4513 select_devices(my_data->adev, usecase->id);
4514 }
4515
4516 return ret;
4517}
4518
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4519static int parse_audiocal_cfg(struct str_parms *parms, acdb_audio_cal_cfg_t *cal)
4520{
4521 int err;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4522 char value[64];
4523 int ret = 0;
4524
4525 if(parms == NULL || cal == NULL)
4526 return ret;
4527
4528 err = str_parms_get_str(parms, "cal_persist", value, sizeof(value));
4529 if (err >= 0) {
4530 str_parms_del(parms, "cal_persist");
4531 cal->persist = (uint32_t) strtoul(value, NULL, 0);
4532 ret = ret | 0x1;
4533 }
4534 err = str_parms_get_str(parms, "cal_apptype", value, sizeof(value));
4535 if (err >= 0) {
4536 str_parms_del(parms, "cal_apptype");
4537 cal->app_type = (uint32_t) strtoul(value, NULL, 0);
4538 ret = ret | 0x2;
4539 }
4540 err = str_parms_get_str(parms, "cal_caltype", value, sizeof(value));
4541 if (err >= 0) {
4542 str_parms_del(parms, "cal_caltype");
4543 cal->cal_type = (uint32_t) strtoul(value, NULL, 0);
4544 ret = ret | 0x4;
4545 }
4546 err = str_parms_get_str(parms, "cal_samplerate", value, sizeof(value));
4547 if (err >= 0) {
4548 str_parms_del(parms, "cal_samplerate");
4549 cal->sampling_rate = (uint32_t) strtoul(value, NULL, 0);
4550 ret = ret | 0x8;
4551 }
4552 err = str_parms_get_str(parms, "cal_devid", value, sizeof(value));
4553 if (err >= 0) {
4554 str_parms_del(parms, "cal_devid");
4555 cal->dev_id = (uint32_t) strtoul(value, NULL, 0);
4556 ret = ret | 0x10;
4557 }
4558 err = str_parms_get_str(parms, "cal_snddevid", value, sizeof(value));
4559 if (err >= 0) {
4560 str_parms_del(parms, "cal_snddevid");
4561 cal->snd_dev_id = (uint32_t) strtoul(value, NULL, 0);
4562 ret = ret | 0x20;
4563 }
4564 err = str_parms_get_str(parms, "cal_topoid", value, sizeof(value));
4565 if (err >= 0) {
4566 str_parms_del(parms, "cal_topoid");
4567 cal->topo_id = (uint32_t) strtoul(value, NULL, 0);
4568 ret = ret | 0x40;
4569 }
4570 err = str_parms_get_str(parms, "cal_moduleid", value, sizeof(value));
4571 if (err >= 0) {
4572 str_parms_del(parms, "cal_moduleid");
4573 cal->module_id = (uint32_t) strtoul(value, NULL, 0);
4574 ret = ret | 0x80;
4575 }
4576 err = str_parms_get_str(parms, "cal_paramid", value, sizeof(value));
4577 if (err >= 0) {
4578 str_parms_del(parms, "cal_paramid");
4579 cal->param_id = (uint32_t) strtoul(value, NULL, 0);
4580 ret = ret | 0x100;
4581 }
4582 return ret;
4583}
4584
4585static void set_audiocal(void *platform, struct str_parms *parms, char *value, int len) {
4586 struct platform_data *my_data = (struct platform_data *)platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]4587 struct stream_out out;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]4588 acdb_audio_cal_cfg_t cal;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4589 uint8_t *dptr = NULL;
4590 int32_t dlen;
4591 int err, ret;
4592 if(value == NULL || platform == NULL || parms == NULL) {
4593 ALOGE("[%s] received null pointer, failed",__func__);
4594 goto done_key_audcal;
4595 }
4596
4597 /* parse audio calibration keys */
4598 ret = parse_audiocal_cfg(parms, &cal);
4599
4600 /* handle audio calibration data now */
4601 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_AUD_CALDATA, value, len);
4602 if (err >= 0) {
4603 str_parms_del(parms, AUDIO_PARAMETER_KEY_AUD_CALDATA);
4604 dlen = strlen(value);
4605 if(dlen <= 0) {
4606 ALOGE("[%s] null data received",__func__);
4607 goto done_key_audcal;
4608 }
4609 dptr = (uint8_t*) calloc(dlen, sizeof(uint8_t));
4610 if(dptr == NULL) {
4611 ALOGE("[%s] memory allocation failed for %d",__func__, dlen);
4612 goto done_key_audcal;
4613 }
4614 dlen = b64decode(value, strlen(value), dptr);
4615 if(dlen<=0) {
4616 ALOGE("[%s] data decoding failed %d", __func__, dlen);
4617 goto done_key_audcal;
4618 }
4619
4620 if(cal.dev_id) {
4621 if(audio_is_input_device(cal.dev_id)) {
4622 cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);
4623 } else {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4624 out.devices = cal.dev_id;
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]4625 out.sample_rate = cal.sampling_rate;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4626 cal.snd_dev_id = platform_get_output_snd_device(platform, &out);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4627 }
4628 }
4629 cal.acdb_dev_id = platform_get_snd_device_acdb_id(cal.snd_dev_id);
4630 ALOGD("Setting audio calibration for snd_device(%d) acdb_id(%d)",
4631 cal.snd_dev_id, cal.acdb_dev_id);
4632 if(cal.acdb_dev_id == -EINVAL) {
4633 ALOGE("[%s] Invalid acdb_device id %d for snd device id %d",
4634 __func__, cal.acdb_dev_id, cal.snd_dev_id);
4635 goto done_key_audcal;
4636 }
4637 if(my_data->acdb_set_audio_cal) {
4638 ret = my_data->acdb_set_audio_cal((void *)&cal, (void*)dptr, dlen);
4639 }
4640 }
4641done_key_audcal:
4642 if(dptr != NULL)
4643 free(dptr);
4644}
4645
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]4646static void true_32_bit_set_params(struct str_parms *parms,
4647 char *value, int len)
4648{
4649 int ret = 0;
4650
4651 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TRUE_32_BIT,
4652 value,len);
4653 if (ret >= 0) {
4654 if (value && !strncmp(value, "true", sizeof("src")))
4655 supports_true_32_bit = true;
4656 else
4657 supports_true_32_bit = false;
4658 str_parms_del(parms, AUDIO_PARAMETER_KEY_TRUE_32_BIT);
4659 }
4660
4661}
4662
4663bool platform_supports_true_32bit()
4664{
4665 return supports_true_32_bit;
4666}
4667
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]4668static void perf_lock_set_params(struct platform_data *platform,
4669 struct str_parms *parms,
4670 char *value, int len)
4671{
4672 int err = 0, i = 0, num_opts = 0;
4673 char *test_r = NULL;
4674 char *opts = NULL;
4675 char *opts_size = NULL;
4676
4677 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS,
4678 value, len);
4679 if (err >= 0) {
4680 opts_size = strtok_r(value, ", ", &test_r);
4681 if (opts_size == NULL) {
4682 ALOGE("%s: incorrect perf lock opts\n", __func__);
4683 return;
4684 }
4685 num_opts = atoi(opts_size);
4686 if (num_opts > 0) {
4687 if (num_opts > MAX_PERF_LOCK_OPTS) {
4688 ALOGD("%s: num_opts %d exceeds max %d, setting to max\n",
4689 __func__, num_opts, MAX_PERF_LOCK_OPTS);
4690 num_opts = MAX_PERF_LOCK_OPTS;
4691 }
4692 for (i = 0; i < num_opts; i++) {
4693 opts = strtok_r(NULL, ", ", &test_r);
4694 if (opts == NULL) {
4695 ALOGE("%s: incorrect perf lock opts\n", __func__);
4696 break;
4697 }
4698 platform->adev->perf_lock_opts[i] = strtoul(opts, NULL, 16);
4699 }
4700 platform->adev->perf_lock_opts_size = i;
4701 }
4702 str_parms_del(parms, AUDIO_PARAMETER_KEY_PERF_LOCK_OPTS);
4703 }
4704}
4705
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4706int platform_set_parameters(void *platform, struct str_parms *parms)
4707{
4708 struct platform_data *my_data = (struct platform_data *)platform;
Satya Krishna Pindiprolic6b0a742017-02-03 14:37:18 +0530[diff] [blame]4709 struct audio_device *adev = my_data->adev;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4710 char *value=NULL;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]4711 int len;
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]4712 int ret = 0, err;
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]4713 char *kv_pairs = str_parms_to_str(parms);
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]4714 struct listnode *node;
4715 struct meta_key_list *key_info;
4716 int key = 0;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4717
Mingming Yin7b762e72015-03-04 13:47:32 -0800[diff] [blame]4718 if(kv_pairs == NULL) {
4719 ret = -ENOMEM;
4720 ALOGE("[%s] key-value pair is NULL",__func__);
4721 goto done;
4722 }
4723
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]4724 ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4725
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4726 len = strlen(kv_pairs);
4727 value = (char*)calloc(len, sizeof(char));
4728 if(value == NULL) {
4729 ret = -ENOMEM;
4730 ALOGE("[%s] failed to allocate memory",__func__);
4731 goto done;
4732 }
4733 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SLOWTALK, value, len);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]4734 if (err >= 0) {
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]4735 bool state = false;
4736 if (!strncmp("true", value, sizeof("true"))) {
4737 state = true;
4738 }
4739
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4740 str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK);
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]4741 ret = platform_set_slowtalk(my_data, state);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4742 if (ret)
4743 ALOGE("%s: Failed to set slow talk err: %d", __func__, ret);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4744 }
4745
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4746 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HD_VOICE, value, len);
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]4747 if (err >= 0) {
4748 bool state = false;
4749 if (!strncmp("true", value, sizeof("true"))) {
4750 state = true;
4751 }
4752
4753 str_parms_del(parms, AUDIO_PARAMETER_KEY_HD_VOICE);
4754 if (my_data->hd_voice != state) {
4755 ret = set_hd_voice(my_data, state);
4756 if (ret)
4757 ALOGE("%s: Failed to set HD voice err: %d", __func__, ret);
4758 } else {
4759 ALOGV("%s: HD Voice already set to %d", __func__, state);
4760 }
4761 }
4762
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]4763 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4764 value, len);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -0800[diff] [blame]4765 if (err >= 0) {
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]4766 str_parms_del(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST);
4767
4768 if (my_data->acdb_reload_vocvoltable == NULL) {
4769 ALOGE("%s: acdb_reload_vocvoltable is NULL", __func__);
4770 } else if (!strcmp(value, "on")) {
4771 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_VOLUME_BOOST)) {
4772 my_data->voice_feature_set = 1;
4773 }
4774 } else {
4775 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_DEFAULT)) {
4776 my_data->voice_feature_set = 0;
4777 }
4778 }
4779 }
4780
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]4781 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_RELOAD_ACDB,
4782 value, len);
4783 if (err >= 0) {
4784 str_parms_del(parms, AUDIO_PARAMETER_KEY_RELOAD_ACDB);
4785
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +0530[diff] [blame]4786 if (my_data->acdb_reload_v2) {
4787 my_data->acdb_reload_v2(value, my_data->snd_card_name,
4788 my_data->cvd_version, &my_data->acdb_meta_key_list);
4789 } else if (my_data->acdb_reload) {
4790 node = list_head(&my_data->acdb_meta_key_list);
4791 key_info = node_to_item(node, struct meta_key_list, list);
4792 key = key_info->cal_info.nKey;
4793 my_data->acdb_reload(value, my_data->snd_card_name,
4794 my_data->cvd_version, key);
4795 }
Karthik Reddy Kattaeda85aa2016-05-25 12:42:39 +0530[diff] [blame]4796 }
4797
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]4798 if (hw_info_is_stereo_spkr(my_data->hw_info)) {
4799 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_MONO_SPEAKER, value, len);
4800 if (err >= 0) {
4801 if (!strncmp("left", value, sizeof("left")))
4802 my_data->mono_speaker = SPKR_1;
4803 else if (!strncmp("right", value, sizeof("right")))
4804 my_data->mono_speaker = SPKR_2;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4805
Rohit kumard3c3b912016-11-15 18:50:31 +0530[diff] [blame]4806 str_parms_del(parms, AUDIO_PARAMETER_KEY_MONO_SPEAKER);
4807 }
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]4808 }
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4809 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE,
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4810 value, len);
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4811 if (err >= 0) {
4812 char *event_name, *status_str;
4813 bool status = false;
4814 str_parms_del(parms, AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE);
4815 event_name = strtok_r(value, ",", &status_str);
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -0800[diff] [blame]4816 if (!event_name) {
4817 ret = -EINVAL;
4818 ALOGE("%s: event_name is NULL", __func__);
4819 goto done;
4820 }
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4821 ALOGV("%s: recieved update of external audio device %s %s",
4822 __func__,
4823 event_name, status_str);
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]4824 if (!strncmp(status_str, "ON", sizeof("ON")))
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4825 status = true;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame]4826 else if (!strncmp(status_str, "OFF", sizeof("OFF")))
Tanya Finkel00130052014-07-14 04:26:56 -0700[diff] [blame]4827 status = false;
4828 update_external_device_status(my_data, event_name, status);
4829 }
4830
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +0530[diff] [blame]4831 err = str_parms_get_str(parms, PLATFORM_MAX_MIC_COUNT,
4832 value, sizeof(value));
4833 if (err >= 0) {
4834 str_parms_del(parms, PLATFORM_MAX_MIC_COUNT);
4835 my_data->max_mic_count = atoi(value);
4836 ALOGV("%s: max_mic_count %d", __func__, my_data->max_mic_count);
4837 }
4838
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4839 /* handle audio calibration parameters */
4840 set_audiocal(platform, parms, value, len);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]4841 native_audio_set_params(platform, parms, value, len);
Sudheer Papothi991966d2015-07-20 21:54:36 +0530[diff] [blame]4842 audio_extn_spkr_prot_set_parameters(parms, value, len);
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]4843 audio_extn_usb_set_sidetone_gain(parms, value, len);
Satya Krishna Pindiprolic6b0a742017-02-03 14:37:18 +0530[diff] [blame]4844 audio_extn_hfp_set_parameters(adev, parms);
Sudheer Papothifa9d2282015-09-17 01:53:25 +0530[diff] [blame]4845 perf_lock_set_params(platform, parms, value, len);
Ashish Jainf1eaa582016-05-23 20:54:24 +0530[diff] [blame]4846 true_32_bit_set_params(parms, value, len);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4847done:
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4848 ALOGV("%s: exit with code(%d)", __func__, ret);
Mingming Yin7b762e72015-03-04 13:47:32 -0800[diff] [blame]4849 if(kv_pairs != NULL)
4850 free(kv_pairs);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4851 if(value != NULL)
4852 free(value);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]4853 return ret;
4854}
4855
Vidyakumar Athota2850d532013-11-19 16:02:12 -0800[diff] [blame]4856int platform_set_incall_recording_session_id(void *platform,
4857 uint32_t session_id, int rec_mode)
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]4858{
4859 int ret = 0;
4860 struct platform_data *my_data = (struct platform_data *)platform;
4861 struct audio_device *adev = my_data->adev;
4862 struct mixer_ctl *ctl;
4863 const char *mixer_ctl_name = "Voc VSID";
4864 int num_ctl_values;
4865 int i;
4866
4867 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4868 if (!ctl) {
4869 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4870 __func__, mixer_ctl_name);
4871 ret = -EINVAL;
4872 } else {
4873 num_ctl_values = mixer_ctl_get_num_values(ctl);
4874 for (i = 0; i < num_ctl_values; i++) {
4875 if (mixer_ctl_set_value(ctl, i, session_id)) {
4876 ALOGV("Error: invalid session_id: %x", session_id);
4877 ret = -EINVAL;
4878 break;
4879 }
4880 }
4881 }
4882
Vidyakumar Athota2850d532013-11-19 16:02:12 -0800[diff] [blame]4883 if (my_data->csd != NULL) {
4884 ret = my_data->csd->start_record(ALL_SESSION_VSID, rec_mode);
4885 if (ret < 0) {
4886 ALOGE("%s: csd_client_start_record failed, error %d",
4887 __func__, ret);
4888 }
4889 }
4890
4891 return ret;
4892}
4893
4894int platform_stop_incall_recording_usecase(void *platform)
4895{
4896 int ret = 0;
4897 struct platform_data *my_data = (struct platform_data *)platform;
4898
4899 if (my_data->csd != NULL) {
4900 ret = my_data->csd->stop_record(ALL_SESSION_VSID);
4901 if (ret < 0) {
4902 ALOGE("%s: csd_client_stop_record failed, error %d",
4903 __func__, ret);
4904 }
4905 }
4906
4907 return ret;
4908}
4909
4910int platform_start_incall_music_usecase(void *platform)
4911{
4912 int ret = 0;
4913 struct platform_data *my_data = (struct platform_data *)platform;
4914
4915 if (my_data->csd != NULL) {
4916 ret = my_data->csd->start_playback(ALL_SESSION_VSID);
4917 if (ret < 0) {
4918 ALOGE("%s: csd_client_start_playback failed, error %d",
4919 __func__, ret);
4920 }
4921 }
4922
4923 return ret;
4924}
4925
4926int platform_stop_incall_music_usecase(void *platform)
4927{
4928 int ret = 0;
4929 struct platform_data *my_data = (struct platform_data *)platform;
4930
4931 if (my_data->csd != NULL) {
4932 ret = my_data->csd->stop_playback(ALL_SESSION_VSID);
4933 if (ret < 0) {
4934 ALOGE("%s: csd_client_stop_playback failed, error %d",
4935 __func__, ret);
4936 }
4937 }
4938
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700[diff] [blame]4939 return ret;
4940}
4941
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]4942int platform_update_lch(void *platform, struct voice_session *session,
4943 enum voice_lch_mode lch_mode)
4944{
4945 int ret = 0;
4946 struct platform_data *my_data = (struct platform_data *)platform;
4947
4948 if ((my_data->csd != NULL) && (my_data->csd->set_lch != NULL))
4949 ret = my_data->csd->set_lch(session->vsid, lch_mode);
4950 else
4951 ret = pcm_ioctl(session->pcm_tx, SNDRV_VOICE_IOCTL_LCH, &lch_mode);
4952
4953 return ret;
4954}
4955
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4956static void get_audiocal(void *platform, void *keys, void *pReply) {
4957 struct platform_data *my_data = (struct platform_data *)platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]4958 struct stream_out out;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4959 struct str_parms *query = (struct str_parms *)keys;
4960 struct str_parms *reply=(struct str_parms *)pReply;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]4961 acdb_audio_cal_cfg_t cal;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4962 uint8_t *dptr = NULL;
4963 char value[512] = {0};
4964 char *rparms=NULL;
4965 int ret=0, err;
4966 uint32_t param_len;
4967
4968 if(query==NULL || platform==NULL || reply==NULL) {
4969 ALOGE("[%s] received null pointer",__func__);
4970 ret=-EINVAL;
4971 goto done;
4972 }
4973 /* parse audiocal configuration keys */
4974 ret = parse_audiocal_cfg(query, &cal);
4975 if(ret == 0) {
4976 /* No calibration keys found */
4977 goto done;
4978 }
4979 err = str_parms_get_str(query, AUDIO_PARAMETER_KEY_AUD_CALDATA, value, sizeof(value));
4980 if (err >= 0) {
4981 str_parms_del(query, AUDIO_PARAMETER_KEY_AUD_CALDATA);
4982 } else {
4983 goto done;
4984 }
4985
4986 if(cal.dev_id & AUDIO_DEVICE_BIT_IN) {
4987 cal.snd_dev_id = platform_get_input_snd_device(platform, cal.dev_id);
4988 } else if(cal.dev_id) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4989 out.devices = cal.dev_id;
Leena Winterrowdd7a04cd2016-01-07 11:50:02 -0800[diff] [blame]4990 out.sample_rate = cal.sampling_rate;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]4991 cal.snd_dev_id = platform_get_output_snd_device(platform, &out);
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]4992 }
4993 cal.acdb_dev_id = platform_get_snd_device_acdb_id(cal.snd_dev_id);
4994 if (cal.acdb_dev_id < 0) {
4995 ALOGE("%s: Failed. Could not find acdb id for snd device(%d)",
4996 __func__, cal.snd_dev_id);
4997 ret = -EINVAL;
4998 goto done_key_audcal;
4999 }
5000 ALOGD("[%s] Getting audio calibration for snd_device(%d) acdb_id(%d)",
5001 __func__, cal.snd_dev_id, cal.acdb_dev_id);
5002
5003 param_len = MAX_SET_CAL_BYTE_SIZE;
5004 dptr = (uint8_t*)calloc(param_len, sizeof(uint8_t));
5005 if(dptr == NULL) {
5006 ALOGE("[%s] Memory allocation failed for length %d",__func__,param_len);
5007 ret = -ENOMEM;
5008 goto done_key_audcal;
5009 }
5010 if (my_data->acdb_get_audio_cal != NULL) {
5011 ret = my_data->acdb_get_audio_cal((void*)&cal, (void*)dptr, &param_len);
5012 if (ret == 0) {
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5013 if(param_len == 0 || param_len == MAX_SET_CAL_BYTE_SIZE) {
5014 ret = -EINVAL;
5015 goto done_key_audcal;
5016 }
5017 /* Allocate memory for encoding */
5018 rparms = (char*)calloc((param_len*2), sizeof(char));
5019 if(rparms == NULL) {
5020 ALOGE("[%s] Memory allocation failed for size %d",
5021 __func__, param_len*2);
5022 ret = -ENOMEM;
5023 goto done_key_audcal;
5024 }
5025 if(cal.persist==0 && cal.module_id && cal.param_id) {
5026 err = b64encode(dptr+12, param_len-12, rparms);
5027 } else {
5028 err = b64encode(dptr, param_len, rparms);
5029 }
5030 if(err < 0) {
5031 ALOGE("[%s] failed to convert data to string", __func__);
5032 ret = -EINVAL;
5033 goto done_key_audcal;
5034 }
5035 str_parms_add_int(reply, AUDIO_PARAMETER_KEY_AUD_CALRESULT, ret);
5036 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_AUD_CALDATA, rparms);
5037 }
5038 }
5039done_key_audcal:
5040 if(ret != 0) {
5041 str_parms_add_int(reply, AUDIO_PARAMETER_KEY_AUD_CALRESULT, ret);
5042 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_AUD_CALDATA, "");
5043 }
5044done:
5045 if(dptr != NULL)
5046 free(dptr);
5047 if(rparms != NULL)
5048 free(rparms);
5049}
5050
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5051void platform_get_parameters(void *platform,
5052 struct str_parms *query,
5053 struct str_parms *reply)
5054{
5055 struct platform_data *my_data = (struct platform_data *)platform;
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5056 char value[512] = {0};
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5057 int ret;
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]5058 char *kv_pairs = NULL;
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]5059 char propValue[PROPERTY_VALUE_MAX]={0};
5060 bool prop_playback_enabled = false;
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5061
Shiv Maliyappanahalli9d899292013-11-20 14:43:01 -0800[diff] [blame]5062 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK,
5063 value, sizeof(value));
5064 if (ret >= 0) {
Vidyakumar Athota3ade2792013-12-02 11:02:20 -0800[diff] [blame]5065 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SLOWTALK,
5066 my_data->slowtalk?"true":"false");
Shiv Maliyappanahalli9d899292013-11-20 14:43:01 -0800[diff] [blame]5067 }
5068
Avinash Vaishd5fa4572014-09-15 14:41:14 +0530[diff] [blame]5069 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_HD_VOICE,
5070 value, sizeof(value));
5071 if (ret >= 0) {
5072 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_HD_VOICE,
5073 my_data->hd_voice?"true":"false");
5074 }
5075
Ben Rombergerc1dc70d2013-12-19 15:11:17 -0800[diff] [blame]5076 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
5077 value, sizeof(value));
5078 if (ret >= 0) {
5079 if (my_data->voice_feature_set == VOICE_FEATURE_SET_VOLUME_BOOST) {
5080 strlcpy(value, "on", sizeof(value));
5081 } else {
5082 strlcpy(value, "off", sizeof(value));
5083 }
5084
5085 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value);
5086 }
5087
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5088 /* Handle audio calibration keys */
5089 get_audiocal(platform, query, reply);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5090 native_audio_get_params(query, reply, value, sizeof(value));
Ben Rombergera04fabc2014-11-14 12:16:03 -0800[diff] [blame]5091
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]5092 ret = str_parms_get_str(query, AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED,
5093 value, sizeof(value));
5094 if (ret >= 0) {
5095 int isallowed = 1; /*true*/
5096
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]5097 if (property_get("vendor.voice.playback.conc.disabled", propValue, NULL)) {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]5098 prop_playback_enabled = atoi(propValue) ||
5099 !strncmp("true", propValue, 4);
5100 }
5101
Dhanalakshmi Siddania15c6792016-08-10 15:33:53 +0530[diff] [blame]5102 if ((prop_playback_enabled && (voice_is_in_call(my_data->adev))) ||
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530[diff] [blame]5103 (CARD_STATUS_OFFLINE == my_data->adev->card_status)) {
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]5104 char *decoder_mime_type = value;
5105
5106 //check if unsupported mime type or not
5107 if(decoder_mime_type) {
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]5108 unsigned int i = 0;
Sidipotu Ashok42483b62015-09-08 10:21:44 +0530[diff] [blame]5109 for (i = 0; i < sizeof(dsp_only_decoders_mime)/sizeof(dsp_only_decoders_mime[0]); i++) {
5110 if (!strncmp(decoder_mime_type, dsp_only_decoders_mime[i],
5111 strlen(dsp_only_decoders_mime[i]))) {
5112 ALOGD("Rejecting request for DSP only session from HAL during voice call/SSR state");
5113 isallowed = 0;
5114 break;
5115 }
5116 }
5117 }
5118 }
5119 str_parms_add_int(reply, AUDIO_PARAMETER_IS_HW_DECODER_SESSION_ALLOWED, isallowed);
5120 }
5121
Krishnankutty Kolathappilly061a9492014-01-31 18:12:13 -0800[diff] [blame]5122 kv_pairs = str_parms_to_str(reply);
5123 ALOGV_IF(kv_pairs != NULL, "%s: exit: returns - %s", __func__, kv_pairs);
Narsinga Rao Chellacde45d12014-02-13 11:44:31 -0800[diff] [blame]5124 free(kv_pairs);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700[diff] [blame]5125}
5126
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]5127unsigned char* platform_get_license(void *platform, int *size)
5128{
5129 struct platform_data *my_data = (struct platform_data *)platform;
5130 char value[PROPERTY_VALUE_MAX] = {0};
5131 acdb_audio_cal_cfg_t cal;
5132 unsigned char *dptr = NULL;
5133 int ret=0;
5134 uint32_t param_len;
5135
5136 if (platform == NULL) {
5137 ALOGE("[%s] received null pointer %d ",__func__, __LINE__);
5138 ret = -EINVAL;
5139 goto done;
5140 }
5141 memset(&cal, 0, sizeof(cal));
5142 cal.persist = 1;
5143 cal.cal_type = AUDIO_CORE_METAINFO_CAL_TYPE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]5144 if (!property_get("vendor.audio.qaf.acdbid", value , "") && !atoi(value)) {
5145 ALOGE("[%s] vendor.audio.qaf.acdbid is not set %d ",__func__, __LINE__);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]5146 ret = -EINVAL;
5147 goto done;
5148 }
5149 cal.acdb_dev_id = (uint32_t) atoi (value);
5150 param_len = MAX_SET_CAL_BYTE_SIZE;
Sachin Mohan Gadage64c61e2017-07-17 18:11:16 +0530[diff] [blame]5151 dptr = (unsigned char*) calloc(param_len, sizeof(unsigned char));
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +0530[diff] [blame]5152 if (dptr == NULL) {
5153 ALOGE("[%s] Memory allocation failed for length %d",__func__,param_len);
5154 ret = -ENOMEM;
5155 goto done;
5156 }
5157 if (my_data->acdb_get_audio_cal != NULL) {
5158 ret = my_data->acdb_get_audio_cal((void*)&cal, (void*)dptr, &param_len);
5159 ALOGE("%s, ret[%d], param_len[%d] line %d", __func__, ret, param_len, __LINE__);
5160 if (ret == 0) {
5161 *size = param_len;
5162 return dptr;
5163 } else {
5164 *size = 0;
5165 }
5166 }
5167done:
5168 if (dptr != NULL)
5169 free(dptr);
5170
5171 return NULL;
5172}
5173
5174/* Delay in Us */
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]5175/* Delay in Us, only to be used for PCM formats */
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]5176int64_t platform_render_latency(audio_usecase_t usecase)
5177{
5178 switch (usecase) {
5179 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
5180 return DEEP_BUFFER_PLATFORM_DELAY;
5181 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
5182 return LOW_LATENCY_PLATFORM_DELAY;
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]5183 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
5184 case USECASE_AUDIO_PLAYBACK_OFFLOAD2:
5185 return PCM_OFFLOAD_PLATFORM_DELAY;
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700[diff] [blame]5186 case USECASE_AUDIO_PLAYBACK_ULL:
5187 return ULL_PLATFORM_DELAY;
Haynes Mathew George16081042017-05-31 17:16:49 -0700[diff] [blame]5188 case USECASE_AUDIO_PLAYBACK_MMAP:
5189 return MMAP_PLATFORM_DELAY;
Haynes Mathew George7ff216f2013-09-11 19:51:41 -0700[diff] [blame]5190 default:
5191 return 0;
5192 }
5193}
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]5194
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]5195int platform_update_usecase_from_source(int source, int usecase)
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]5196{
Mingming Yinab429782013-11-07 11:16:55 -0800[diff] [blame]5197 ALOGV("%s: input source :%d", __func__, source);
Mingming Yin12125e82015-10-26 20:40:36 -0700[diff] [blame]5198 if (source == AUDIO_SOURCE_FM_TUNER)
Mingming Yine62d7842013-10-25 16:26:03 -0700[diff] [blame]5199 usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
5200 return usecase;
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700[diff] [blame]5201}
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]5202
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]5203bool platform_listen_device_needs_event(snd_device_t snd_device)
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]5204{
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]5205 bool needs_event = false;
5206
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]5207 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
5208 (snd_device < SND_DEVICE_IN_END) &&
5209 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]5210 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK) &&
5211 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1) &&
5212 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2))
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]5213 needs_event = true;
5214
5215 return needs_event;
5216}
5217
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700[diff] [blame]5218bool platform_listen_usecase_needs_event(audio_usecase_t uc_id __unused)
5219{
5220 return false;
5221}
5222
5223bool platform_sound_trigger_device_needs_event(snd_device_t snd_device)
5224{
5225 bool needs_event = false;
5226
5227 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
5228 (snd_device < SND_DEVICE_IN_END) &&
5229 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]5230 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK) &&
5231 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1) &&
5232 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2))
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700[diff] [blame]5233 needs_event = true;
5234
5235 return needs_event;
5236}
5237
Quinn Malef15123f2017-04-27 18:58:05 -0700[diff] [blame]5238bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id)
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]5239{
Quinn Malef15123f2017-04-27 18:58:05 -0700[diff] [blame]5240 bool needs_event = false;
5241
5242 switch(uc_id){
5243 /* concurrent playback usecases needs event */
5244 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
5245 case USECASE_AUDIO_PLAYBACK_MULTI_CH:
5246 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
5247 case USECASE_AUDIO_PLAYBACK_OFFLOAD2:
5248 needs_event = true;
5249 break;
5250 /* concurrent playback in low latency allowed */
5251 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
5252 break;
5253 /* concurrent playback FM needs event */
5254 case USECASE_AUDIO_PLAYBACK_FM:
5255 needs_event = true;
5256 break;
5257
5258 /* concurrent capture usecases, no event, capture handled by device
5259 * USECASE_AUDIO_RECORD:
5260 * USECASE_AUDIO_RECORD_COMPRESS:
5261 * USECASE_AUDIO_RECORD_LOW_LATENCY:
5262
5263 * USECASE_VOICE_CALL:
5264 * USECASE_VOICE2_CALL:
5265 * USECASE_VOLTE_CALL:
5266 * USECASE_QCHAT_CALL:
5267 * USECASE_VOWLAN_CALL:
5268 * USECASE_VOICEMMODE1_CALL:
5269 * USECASE_VOICEMMODE2_CALL:
5270 * USECASE_COMPRESS_VOIP_CALL:
5271 * USECASE_AUDIO_RECORD_FM_VIRTUAL:
5272 * USECASE_INCALL_REC_UPLINK:
5273 * USECASE_INCALL_REC_DOWNLINK:
5274 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK:
5275 * USECASE_INCALL_REC_UPLINK_COMPRESS:
5276 * USECASE_INCALL_REC_DOWNLINK_COMPRESS:
5277 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS:
5278 * USECASE_INCALL_MUSIC_UPLINK:
5279 * USECASE_INCALL_MUSIC_UPLINK2:
5280 * USECASE_AUDIO_SPKR_CALIB_RX:
5281 * USECASE_AUDIO_SPKR_CALIB_TX:
5282 */
5283 default:
5284 ALOGV("%s:usecase_id[%d] no need to raise event.", __func__, uc_id);
5285 }
5286 return needs_event;
Kiran Kandide144c82013-11-20 15:58:32 -0800[diff] [blame]5287}
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]5288
5289/* Read offload buffer size from a property.
5290 * If value is not power of 2 round it to
5291 * power of 2.
5292 */
5293uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info)
5294{
5295 char value[PROPERTY_VALUE_MAX] = {0};
5296 uint32_t fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]5297 if((property_get("vendor.audio.offload.buffer.size.kb", value, "")) &&
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]5298 atoi(value)) {
5299 fragment_size = atoi(value) * 1024;
5300 }
5301
vivek mehta80a44292015-08-10 12:58:10 -0700[diff] [blame]5302 /* Use incoming offload buffer size if default buffer size is less */
5303 if ((info != NULL) && (fragment_size < info->offload_buffer_size)) {
5304 ALOGI("%s:: Overwriting offload buffer size default:%d new:%d", __func__,
5305 fragment_size,
5306 info->offload_buffer_size);
5307 fragment_size = info->offload_buffer_size;
5308 }
5309
Ramjee Singh21ffaa82017-07-28 17:47:01 +0530[diff] [blame]5310 if (info != NULL) {
5311 if (info->is_streaming && info->has_video) {
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]5312 fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING;
5313 ALOGV("%s: offload fragment size reduced for AV streaming to %d",
5314 __func__, fragment_size);
5315 } else if (info->format == AUDIO_FORMAT_FLAC) {
5316 fragment_size = FLAC_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
5317 ALOGV("FLAC fragment size %d", fragment_size);
5318 } else if (info->format == AUDIO_FORMAT_DSD) {
5319 fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]5320 if((property_get("vendor.audio.native.dsd.buffer.size.kb", value, "")) &&
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +0530[diff] [blame]5321 atoi(value))
5322 fragment_size = atoi(value) * 1024;
5323 ALOGV("DSD fragment size %d", fragment_size);
5324 }
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800[diff] [blame]5325 }
5326
5327 fragment_size = ALIGN( fragment_size, 1024);
5328
5329 if(fragment_size < MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
5330 fragment_size = MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
5331 else if(fragment_size > MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
5332 fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
5333 ALOGV("%s: fragment_size %d", __func__, fragment_size);
5334 return fragment_size;
5335}
5336
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5337/*
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5338 * return backend_idx on which voice call is active
5339 */
5340static int platform_get_voice_call_backend(struct audio_device* adev)
5341{
5342 struct audio_usecase *uc = NULL;
5343 struct listnode *node;
5344 snd_device_t out_snd_device = SND_DEVICE_NONE;
5345
5346 int backend_idx = -1;
5347
5348 if (voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION) {
5349 list_for_each(node, &adev->usecase_list) {
5350 uc = node_to_item(node, struct audio_usecase, list);
5351 if (uc && (uc->type == VOICE_CALL || uc->type == VOIP_CALL) && uc->stream.out) {
5352 out_snd_device = platform_get_output_snd_device(adev->platform, uc->stream.out);
5353 backend_idx = platform_get_backend_index(out_snd_device);
5354 break;
5355 }
5356 }
5357 }
5358 return backend_idx;
5359}
5360
5361/*
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5362 * configures afe with bit width and Sample Rate
5363 */
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]5364static int platform_set_codec_backend_cfg(struct audio_device* adev,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5365 snd_device_t snd_device, struct audio_backend_cfg backend_cfg)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5366{
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5367 int ret = -EINVAL;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5368 int backend_idx = platform_get_backend_index(snd_device);
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5369 struct platform_data *my_data = (struct platform_data *)adev->platform;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5370 backend_idx = platform_get_backend_index(snd_device);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5371 unsigned int bit_width = backend_cfg.bit_width;
5372 unsigned int sample_rate = backend_cfg.sample_rate;
5373 unsigned int channels = backend_cfg.channels;
5374 audio_format_t format = backend_cfg.format;
5375 bool passthrough_enabled = backend_cfg.passthrough_enabled;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5376 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
5377
5378 /* Override the config params if client has already set them */
5379 adev_device_cfg_ptr += backend_idx;
5380 if (adev_device_cfg_ptr->use_client_dev_cfg) {
5381 ALOGV("%s::: Updating with the config set by client "
5382 "bitwidth %d, samplerate %d, channels %d format %d",
5383 __func__, adev_device_cfg_ptr->dev_cfg_params.bit_width,
5384 adev_device_cfg_ptr->dev_cfg_params.sample_rate,
5385 adev_device_cfg_ptr->dev_cfg_params.channels,
5386 adev_device_cfg_ptr->dev_cfg_params.format);
5387
5388 bit_width = adev_device_cfg_ptr->dev_cfg_params.bit_width;
5389 sample_rate = adev_device_cfg_ptr->dev_cfg_params.sample_rate;
5390 channels = adev_device_cfg_ptr->dev_cfg_params.channels;
5391 format = adev_device_cfg_ptr->dev_cfg_params.format;
5392 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5393
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]5394 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d format %d"
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5395 ", backend_idx %d device (%s)", __func__, bit_width,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]5396 sample_rate, channels, format, backend_idx,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5397 platform_get_snd_device_name(snd_device));
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5398
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +0530[diff] [blame]5399 if ((my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl) &&
5400 (bit_width != my_data->current_backend_cfg[backend_idx].bit_width)) {
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5401
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5402 struct mixer_ctl *ctl = NULL;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5403 ctl = mixer_get_ctl_by_name(adev->mixer,
5404 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5405 if (!ctl) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5406 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
5407 __func__,
5408 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5409 return -EINVAL;
5410 }
5411
5412 if (bit_width == 24) {
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]5413 if (format == AUDIO_FORMAT_PCM_24_BIT_PACKED)
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5414 ret = mixer_ctl_set_enum_by_string(ctl, "S24_3LE");
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]5415 else
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5416 ret = mixer_ctl_set_enum_by_string(ctl, "S24_LE");
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]5417 } else if (bit_width == 32) {
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]5418 ret = mixer_ctl_set_enum_by_string(ctl, "S32_LE");
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5419 } else {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5420 ret = mixer_ctl_set_enum_by_string(ctl, "S16_LE");
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5421 }
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5422 if ( ret < 0) {
5423 ALOGE("%s:becf: afe: fail for %s mixer set to %d bit for %x format", __func__,
5424 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
5425 } else {
5426 my_data->current_backend_cfg[backend_idx].bit_width = bit_width;
5427 ALOGD("%s:becf: afe: %s mixer set to %d bit for %x format", __func__,
5428 my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
5429 }
5430 /* set the ret as 0 and not pass back to upper layer */
5431 ret = 0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5432 }
5433
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5434 if ((my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl) &&
5435 (passthrough_enabled || (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate))) {
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5436 char *rate_str = NULL;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5437 struct mixer_ctl *ctl = NULL;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5438
Preetam Singh Ranawat63c02ea2017-08-10 11:53:30 +0530[diff] [blame]5439 if (backend_idx == USB_AUDIO_RX_BACKEND ||
5440 backend_idx == USB_AUDIO_TX_BACKEND) {
5441 switch (sample_rate) {
5442 case 32000:
5443 rate_str = "KHZ_32";
5444 break;
5445 case 8000:
5446 rate_str = "KHZ_8";
5447 break;
5448 case 11025:
5449 rate_str = "HZ_11P025";
5450 break;
5451 case 16000:
5452 rate_str = "KHZ_16";
5453 break;
5454 case 22050:
5455 rate_str = "KHZ_22P05";
5456 break;
5457 }
5458 }
5459
5460 if (rate_str == NULL) {
5461 switch (sample_rate) {
5462 case 32000:
5463 if (passthrough_enabled) {
5464 rate_str = "KHZ_32";
5465 break;
5466 }
5467 case 48000:
5468 rate_str = "KHZ_48";
5469 break;
5470 case 44100:
5471 rate_str = "KHZ_44P1";
5472 break;
5473 case 64000:
5474 case 96000:
5475 rate_str = "KHZ_96";
5476 break;
5477 case 88200:
5478 rate_str = "KHZ_88P2";
5479 break;
5480 case 176400:
5481 rate_str = "KHZ_176P4";
5482 break;
5483 case 192000:
5484 rate_str = "KHZ_192";
5485 break;
5486 case 352800:
5487 rate_str = "KHZ_352P8";
5488 break;
5489 case 384000:
5490 rate_str = "KHZ_384";
5491 break;
5492 case 144000:
5493 if (passthrough_enabled) {
5494 rate_str = "KHZ_144";
5495 break;
5496 }
5497 default:
5498 rate_str = "KHZ_48";
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +0530[diff] [blame]5499 break;
5500 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5501 }
5502
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5503 ctl = mixer_get_ctl_by_name(adev->mixer,
5504 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5505 if(!ctl) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5506 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
5507 __func__,
5508 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5509 return -EINVAL;
5510 }
5511
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5512 ALOGD("%s:becf: afe: %s set to %s", __func__,
5513 my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl, rate_str);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5514 mixer_ctl_set_enum_by_string(ctl, rate_str);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5515 my_data->current_backend_cfg[backend_idx].sample_rate = sample_rate;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5516 ret = 0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5517 }
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5518 if ((my_data->current_backend_cfg[backend_idx].channels_mixer_ctl) &&
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5519 (channels != my_data->current_backend_cfg[backend_idx].channels)) {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5520 struct mixer_ctl *ctl = NULL;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5521 char *channel_cnt_str = NULL;
5522
5523 switch (channels) {
5524 case 8:
5525 channel_cnt_str = "Eight"; break;
5526 case 7:
5527 channel_cnt_str = "Seven"; break;
5528 case 6:
5529 channel_cnt_str = "Six"; break;
5530 case 5:
5531 channel_cnt_str = "Five"; break;
5532 case 4:
5533 channel_cnt_str = "Four"; break;
5534 case 3:
5535 channel_cnt_str = "Three"; break;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5536 case 1:
5537 channel_cnt_str = "One"; break;
5538 case 2:
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5539 default:
5540 channel_cnt_str = "Two"; break;
5541 }
5542
5543 ctl = mixer_get_ctl_by_name(adev->mixer,
5544 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
5545 if (!ctl) {
5546 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
5547 __func__,
5548 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
5549 return -EINVAL;
5550 }
5551 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
5552 my_data->current_backend_cfg[backend_idx].channels = channels;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5553
5554 if (backend_idx == HDMI_RX_BACKEND)
5555 platform_set_edid_channels_configuration(adev->platform, channels);
5556
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5557 ALOGD("%s:becf: afe: %s set to %s ", __func__,
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]5558 my_data->current_backend_cfg[backend_idx].channels_mixer_ctl,
5559 channel_cnt_str);
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5560 ret = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5561 }
5562
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]5563 bool set_ext_disp_format = false, set_mi2s_tx_data_format = false;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5564 char *ext_disp_format = NULL;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5565
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5566 if (backend_idx == HDMI_RX_BACKEND) {
5567 ext_disp_format = "HDMI RX Format";
5568 set_ext_disp_format = true;
5569 } else if (backend_idx == DISP_PORT_RX_BACKEND) {
Garmond Leungade0f6d2017-02-03 15:56:10 -0800[diff] [blame]5570 ext_disp_format = "Display Port RX Format";
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5571 set_ext_disp_format = true;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]5572 } else if (backend_idx == HDMI_TX_BACKEND) {
5573 ext_disp_format = "QUAT MI2S TX Format";
5574 set_mi2s_tx_data_format = true;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5575 } else {
5576 ALOGV("%s: Format doesnt have to be set", __func__);
5577 }
5578
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]5579 format = format & AUDIO_FORMAT_MAIN_MASK;
5580 /* Set data format only if there is a change from PCM to compressed
5581 and vice versa */
5582 if (set_mi2s_tx_data_format && (format ^ my_data->current_backend_cfg[backend_idx].format)) {
5583 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, ext_disp_format);
5584 if (!ctl) {
5585 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
5586 __func__, ext_disp_format);
5587 return -EINVAL;
5588 }
5589 if (format == AUDIO_FORMAT_PCM) {
5590 ALOGE("%s:MI2S data format LPCM", __func__);
5591 mixer_ctl_set_enum_by_string(ctl, "LPCM");
5592 } else {
5593 ALOGE("%s:MI2S data format Compr", __func__);
5594 mixer_ctl_set_enum_by_string(ctl, "Compr");
5595 }
5596 my_data->current_backend_cfg[backend_idx].format = format;
5597 }
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5598 if (set_ext_disp_format) {
5599 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, ext_disp_format);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5600 if (!ctl) {
5601 ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5602 __func__, ext_disp_format);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5603 return -EINVAL;
5604 }
5605
5606 if (passthrough_enabled) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5607 ALOGD("%s:Ext display compress format", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5608 mixer_ctl_set_enum_by_string(ctl, "Compr");
5609 } else {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5610 ALOGD("%s: Ext display PCM format", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5611 mixer_ctl_set_enum_by_string(ctl, "LPCM");
5612 }
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5613 ret = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5614 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5615 return ret;
5616}
5617
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5618/*
Satish Babu Patakokila5933e972017-08-24 12:22:08 +0530[diff] [blame]5619 * Get the backend configuration for current snd device
5620 */
5621int platform_get_codec_backend_cfg(struct audio_device* adev,
5622 snd_device_t snd_device,
5623 struct audio_backend_cfg *backend_cfg)
5624{
5625 int backend_idx = platform_get_backend_index(snd_device);
5626 struct platform_data *my_data = (struct platform_data *)adev->platform;
5627
5628 backend_cfg->bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
5629 backend_cfg->sample_rate =
5630 my_data->current_backend_cfg[backend_idx].sample_rate;
5631 backend_cfg->channels =
5632 my_data->current_backend_cfg[backend_idx].channels;
5633 backend_cfg->format =
5634 my_data->current_backend_cfg[backend_idx].format;
5635
5636 ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d format %d"
5637 ", backend_idx %d device (%s)", __func__, backend_cfg->bit_width,
5638 backend_cfg->sample_rate, backend_cfg->channels, backend_cfg->format,
5639 backend_idx, platform_get_snd_device_name(snd_device));
5640
5641 return 0;
5642}
5643
5644/*
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5645 *Validate the selected bit_width, sample_rate and channels using the edid
5646 *of the connected sink device.
5647 */
5648static void platform_check_hdmi_backend_cfg(struct audio_device* adev,
5649 struct audio_usecase* usecase,
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5650 int backend_idx,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5651 struct audio_backend_cfg *hdmi_backend_cfg)
5652{
5653 unsigned int bit_width;
5654 unsigned int sample_rate;
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]5655 int channels, max_supported_channels = 0;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5656 struct platform_data *my_data = (struct platform_data *)adev->platform;
5657 edid_audio_info *edid_info = (edid_audio_info *)my_data->edid_info;
5658 bool passthrough_enabled = false;
5659
5660 bit_width = hdmi_backend_cfg->bit_width;
5661 sample_rate = hdmi_backend_cfg->sample_rate;
5662 channels = hdmi_backend_cfg->channels;
5663
5664
5665 ALOGI("%s:becf: HDMI: bitwidth %d, samplerate %d, channels %d"
5666 ", usecase = %d", __func__, bit_width,
5667 sample_rate, channels, usecase->id);
5668
5669 if (audio_extn_passthru_is_enabled() && audio_extn_passthru_is_active()
5670 && (usecase->stream.out->compr_config.codec->compr_passthr != 0)) {
5671 passthrough_enabled = true;
5672 ALOGI("passthrough is enabled for this stream");
5673 }
5674
5675 // For voice calls use default configuration i.e. 16b/48K, only applicable to
5676 // default backend
5677 if (!passthrough_enabled) {
5678
5679 max_supported_channels = platform_edid_get_max_channels(my_data);
5680
5681 //Check EDID info for supported samplerate
5682 if (!edid_is_supported_sr(edid_info,sample_rate)) {
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]5683 //check to see if current BE sample rate is supported by EDID
5684 //else assign the highest sample rate supported by EDID
5685 if (edid_is_supported_sr(edid_info,my_data->current_backend_cfg[backend_idx].sample_rate))
5686 sample_rate = my_data->current_backend_cfg[backend_idx].sample_rate;
5687 else
5688 sample_rate = edid_get_highest_supported_sr(edid_info);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5689 }
5690
5691 //Check EDID info for supported bit width
5692 if (!edid_is_supported_bps(edid_info,bit_width)) {
5693 //reset to current sample rate
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5694 bit_width = my_data->current_backend_cfg[backend_idx].bit_width;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5695 }
5696
5697 if (channels > max_supported_channels)
5698 channels = max_supported_channels;
5699
5700 } else {
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]5701 channels = audio_extn_passthru_get_channel_count(usecase->stream.out);
5702 if (channels <= 0) {
5703 ALOGE("%s: becf: afe: HDMI backend using defalut channel %u",
5704 __func__, DEFAULT_HDMI_OUT_CHANNELS);
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]5705 channels = DEFAULT_HDMI_OUT_CHANNELS;
Manish Dewangan37864bc2017-06-09 12:28:37 +0530[diff] [blame]5706 }
Harsh Bansal026d97f2017-08-17 17:44:49 +0530[diff] [blame]5707 if (((usecase->stream.out->format == AUDIO_FORMAT_E_AC3) ||
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]5708 (usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC) ||
Harsh Bansal026d97f2017-08-17 17:44:49 +0530[diff] [blame]5709 (usecase->stream.out->format == AUDIO_FORMAT_DOLBY_TRUEHD))
5710 && (usecase->stream.out->compr_config.codec->compr_passthr == PASSTHROUGH)) {
Naresh Tanniru3a406772017-05-10 13:09:05 -0700[diff] [blame]5711 sample_rate = sample_rate * 4;
5712 if (sample_rate > HDMI_PASSTHROUGH_MAX_SAMPLE_RATE)
5713 sample_rate = HDMI_PASSTHROUGH_MAX_SAMPLE_RATE;
5714 }
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]5715
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5716 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
5717 /* We force route so that the BE format can be set to Compr */
5718 }
5719
5720 ALOGI("%s:becf: afe: HDMI backend: passthrough %d updated bit width: %d and sample rate: %d"
5721 "channels %d", __func__, passthrough_enabled , bit_width,
5722 sample_rate, channels);
5723
5724 hdmi_backend_cfg->bit_width = bit_width;
5725 hdmi_backend_cfg->sample_rate = sample_rate;
5726 hdmi_backend_cfg->channels = channels;
5727 hdmi_backend_cfg->passthrough_enabled = passthrough_enabled;
5728}
5729
5730/*
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5731 * goes through all the current usecases and picks the highest
5732 * bitwidth & samplerate
5733 */
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]5734static bool platform_check_codec_backend_cfg(struct audio_device* adev,
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5735 struct audio_usecase* usecase,
5736 snd_device_t snd_device,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5737 struct audio_backend_cfg *backend_cfg)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5738{
5739 bool backend_change = false;
5740 struct listnode *node;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5741 unsigned int bit_width;
5742 unsigned int sample_rate;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5743 unsigned int channels;
5744 bool passthrough_enabled = false;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]5745 bool voice_call_active = false;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5746 int backend_idx = DEFAULT_CODEC_BACKEND;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5747 struct platform_data *my_data = (struct platform_data *)adev->platform;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5748 int na_mode = platform_get_native_support();
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5749 bool channels_updated = false;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5750 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5751
Ashish Jainc597d102016-12-12 10:31:34 +0530[diff] [blame]5752 /*BT devices backend is not configured from HAL hence skip*/
5753 if (snd_device == SND_DEVICE_OUT_BT_A2DP ||
5754 snd_device == SND_DEVICE_OUT_BT_SCO ||
Sachin Mohan Gadag2e4dcb12017-05-12 13:05:08 +0530[diff] [blame]5755 snd_device == SND_DEVICE_OUT_BT_SCO_WB ||
5756 snd_device == SND_DEVICE_OUT_AFE_PROXY) {
Ashish Jainc597d102016-12-12 10:31:34 +0530[diff] [blame]5757 backend_change = false;
5758 return backend_change;
5759 }
5760
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5761 backend_idx = platform_get_backend_index(snd_device);
5762
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5763 bit_width = backend_cfg->bit_width;
5764 sample_rate = backend_cfg->sample_rate;
5765 channels = backend_cfg->channels;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5766
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5767 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5768 ", backend_idx %d usecase = %d device (%s)", __func__, bit_width,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5769 sample_rate, channels, backend_idx, usecase->id,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5770 platform_get_snd_device_name(snd_device));
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5771
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -0700[diff] [blame]5772 // For voice calls use default configuration i.e. 16b/48K, only applicable to
5773 // default backend
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5774 // force routing is not required here, caller will do it anyway
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5775 if (backend_idx == platform_get_voice_call_backend(adev)) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5776 ALOGW("%s:becf: afe:Use default bw and sr for voice/voip calls ",
5777 __func__);
Narsinga Rao Chella44376cc2014-10-24 13:27:14 -0700[diff] [blame]5778 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
5779 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5780 channels = CODEC_BACKEND_DEFAULT_CHANNELS;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]5781 voice_call_active = true;
Narsinga Rao Chella44376cc2014-10-24 13:27:14 -0700[diff] [blame]5782 } else {
5783 /*
5784 * The backend should be configured at highest bit width and/or
5785 * sample rate amongst all playback usecases.
5786 * If the selected sample rate and/or bit width differ with
5787 * current backend sample rate and/or bit width, then, we set the
5788 * backend re-configuration flag.
5789 *
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5790 * 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]5791 */
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5792 int i =0;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5793 list_for_each(node, &adev->usecase_list) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5794 struct audio_usecase *uc;
5795 uc = node_to_item(node, struct audio_usecase, list);
5796 struct stream_out *out = (struct stream_out*) uc->stream.out;
5797 if (uc->type == PCM_PLAYBACK && out && usecase != uc) {
Preetam Singh Ranawataa37d3f2016-08-23 12:25:23 +0530[diff] [blame]5798 unsigned int out_channels = audio_channel_count_from_out_mask(out->channel_mask);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5799
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5800 ALOGD("%s:napb: (%d) - (%s)id (%d) sr %d bw "
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5801 "(%d) ch (%d) device %s", __func__, i++, use_case_table[uc->id],
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5802 uc->id, out->sample_rate,
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5803 out->bit_width, out_channels,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5804 platform_get_snd_device_name(uc->out_snd_device));
5805
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]5806 if (platform_check_backends_match(snd_device, uc->out_snd_device)) {
Amit Shekhar278e3362014-09-08 14:08:19 -0700[diff] [blame]5807 if (bit_width < out->bit_width)
5808 bit_width = out->bit_width;
5809 if (sample_rate < out->sample_rate)
5810 sample_rate = out->sample_rate;
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5811 if (out->sample_rate < OUTPUT_SAMPLING_RATE_44100)
5812 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5813 if (channels < out_channels)
5814 channels = out_channels;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5815 }
5816 }
5817 }
5818 }
5819
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5820 /* Native playback is preferred for Headphone/HS device over 192Khz */
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]5821 if (!voice_call_active && codec_device_supports_native_playback(usecase->devices)) {
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5822 if (audio_is_true_native_stream_active(adev)) {
5823 if (check_hdset_combo_device(snd_device)) {
5824 /*
5825 * In true native mode Tasha has a limitation that one port at 44.1 khz
5826 * cannot drive both spkr and hdset, to simiplify the solution lets
5827 * move the AFE to 48khzwhen a ring tone selects combo device.
5828 * or if NATIVE playback is not enabled.
5829 */
5830 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
5831 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ashish Jain8c930292017-03-13 16:33:12 +0530[diff] [blame]5832 ALOGD("%s:becf: afe: port to run at 48k if combo device or in voice call"
5833 , __func__);
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5834 } else {
5835 /*
5836 * in single BE mode, if native audio playback
5837 * is active then it will take priority
5838 */
5839 sample_rate = OUTPUT_SAMPLING_RATE_44100;
5840 ALOGD("%s:becf: afe: true napb active set rate to 44.1 khz",
5841 __func__);
5842 }
Ashish Jain7f25be32016-10-25 21:44:16 +0530[diff] [blame]5843 } else if (na_mode != NATIVE_AUDIO_MODE_MULTIPLE_44_1) {
5844 /*
5845 * Map native sampling rates to upper limit range
5846 * if multiple of native sampling rates are not supported.
5847 * This check also indicates that this is not tavil codec
5848 * And 32bit/384kHz is only supported on tavil
5849 * Hence reset 32b/384kHz to 24b/192kHz.
5850 */
5851 switch (sample_rate) {
5852 case 44100:
5853 sample_rate = 48000;
5854 break;
5855 case 88200:
5856 sample_rate = 96000;
5857 break;
5858 case 176400:
5859 case 352800:
5860 case 384000:
5861 sample_rate = 192000;
5862 break;
5863 }
5864 if (bit_width > 24)
5865 bit_width = 24;
5866
5867 ALOGD("%s:becf: afe: napb not active - set non fractional rate",
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5868 __func__);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5869 }
Ashish Jain6fced6e2017-01-09 14:13:22 +0530[diff] [blame]5870 }
5871
5872 /*
5873 * Check if the device is speaker or handset,assumption handset shares
5874 * backend with speaker, and these devices are restricited to 48kHz.
5875 */
5876 if (platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, snd_device)) {
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]5877
5878 if (bit_width >= 24) {
5879 bit_width = platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER);
5880 ALOGD("%s:becf: afe: reset bitwidth to %d (based on supported"
5881 " value for this platform)", __func__, bit_width);
5882 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5883 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5884 ALOGD("%s:becf: afe: playback on codec device not supporting native playback set "
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]5885 "default Sample Rate(48k)", __func__);
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5886 }
5887
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]5888 if (backend_idx == USB_AUDIO_RX_BACKEND) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]5889 audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, true);
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]5890 ALOGV("%s: USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)",
5891 __func__, bit_width, sample_rate, channels);
Ashish Jainb26edfb2016-08-25 00:10:11 +0530[diff] [blame]5892 if (channels != my_data->current_backend_cfg[backend_idx].channels)
5893 channels_updated = true;
Kuirong Wanga9f7cee2016-03-07 11:21:52 -0800[diff] [blame]5894 }
5895
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5896 if (backend_idx == HDMI_RX_BACKEND || backend_idx == DISP_PORT_RX_BACKEND) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5897 struct audio_backend_cfg hdmi_backend_cfg;
5898 hdmi_backend_cfg.bit_width = bit_width;
5899 hdmi_backend_cfg.sample_rate = sample_rate;
5900 hdmi_backend_cfg.channels = channels;
5901 hdmi_backend_cfg.passthrough_enabled = false;
5902
Ashish Jain058165c2016-09-28 23:18:48 +0530[diff] [blame]5903 /*
5904 * HDMI does not support 384Khz/32bit playback hence configure BE to 24b/192Khz
5905 * TODO: Instead have the validation against edid return the next best match
5906 */
5907 if (bit_width > 24)
5908 hdmi_backend_cfg.bit_width = 24;
5909 if (sample_rate > 192000)
5910 hdmi_backend_cfg.sample_rate = 192000;
5911
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]5912 platform_check_hdmi_backend_cfg(adev, usecase, backend_idx, &hdmi_backend_cfg);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5913
5914 bit_width = hdmi_backend_cfg.bit_width;
5915 sample_rate = hdmi_backend_cfg.sample_rate;
5916 channels = hdmi_backend_cfg.channels;
5917 passthrough_enabled = hdmi_backend_cfg.passthrough_enabled;
5918
5919 if (channels != my_data->current_backend_cfg[backend_idx].channels)
5920 channels_updated = true;
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]5921 }
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5922
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]5923 ALOGI("%s:becf: afe: Codec selected backend: %d updated bit width: %d and sample rate: %d",
5924 __func__, backend_idx , bit_width, sample_rate);
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]5925
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5926 // Force routing if the expected bitwdith or samplerate
5927 // is not same as current backend comfiguration
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5928 if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5929 (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
5930 passthrough_enabled || channels_updated) {
5931 backend_cfg->bit_width = bit_width;
5932 backend_cfg->sample_rate = sample_rate;
5933 backend_cfg->channels = channels;
5934 backend_cfg->passthrough_enabled = passthrough_enabled;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5935 backend_change = true;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5936 ALOGI("%s:becf: afe: Codec backend needs to be updated. new bit width: %d"
5937 "new sample rate: %d new channels: %d",
5938 __func__, backend_cfg->bit_width, backend_cfg->sample_rate, backend_cfg->channels);
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5939 }
5940
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]5941 // Force routing if the client sends config params for this backend
5942 adev_device_cfg_ptr += backend_idx;
5943 if (adev_device_cfg_ptr->use_client_dev_cfg) {
5944 ALOGV("%s: Codec backend needs to be updated as Client provided "
5945 "config params", __func__);
5946 backend_change = true;
5947 }
5948
Preetam Singh Ranawatdc1a3952016-11-24 17:35:51 +0530[diff] [blame]5949 if (snd_device == SND_DEVICE_OUT_HEADPHONES || snd_device ==
5950 SND_DEVICE_OUT_HEADPHONES_44_1) {
5951 if (sample_rate > 48000 ||
5952 (bit_width >= 24 && (sample_rate == 48000 || sample_rate == 44100))) {
5953 ALOGI("%s: apply HPH HQ mode\n", __func__);
5954 audio_route_apply_and_update_path(adev->audio_route, "hph-highquality-mode");
5955 } else {
5956 ALOGI("%s: apply HPH LP mode\n", __func__);
5957 audio_route_apply_and_update_path(adev->audio_route, "hph-lowpower-mode");
5958 }
5959 }
5960
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5961 return backend_change;
5962}
5963
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5964bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev,
5965 struct audio_usecase *usecase, snd_device_t snd_device)
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5966{
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5967 int backend_idx = DEFAULT_CODEC_BACKEND;
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]5968 int new_snd_devices[SND_DEVICE_OUT_END] = {0};
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]5969 int i, num_devices = 1;
5970 bool ret = false;
5971 struct platform_data *my_data = (struct platform_data *)adev->platform;
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5972 struct audio_backend_cfg backend_cfg;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5973
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -0800[diff] [blame]5974 backend_idx = platform_get_backend_index(snd_device);
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -0800[diff] [blame]5975
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]5976 if (usecase->type == TRANSCODE_LOOPBACK) {
5977 backend_cfg.bit_width = usecase->stream.inout->out_config.bit_width;
5978 backend_cfg.sample_rate = usecase->stream.inout->out_config.sample_rate;
5979 backend_cfg.format = usecase->stream.inout->out_config.format;
5980 backend_cfg.channels = audio_channel_count_from_out_mask(
5981 usecase->stream.inout->out_config.channel_mask);
5982 } else {
5983 backend_cfg.bit_width = usecase->stream.out->bit_width;
5984 backend_cfg.sample_rate = usecase->stream.out->sample_rate;
5985 backend_cfg.format = usecase->stream.out->format;
5986 backend_cfg.channels = audio_channel_count_from_out_mask(usecase->stream.out->channel_mask);
5987 }
Xiaojun Sang785b5da2017-08-03 15:52:29 +0800[diff] [blame]5988 if (audio_extn_is_dsp_bit_width_enforce_mode_supported(usecase->stream.out->flags) &&
5989 (adev->dsp_bit_width_enforce_mode > backend_cfg.bit_width))
5990 backend_cfg.bit_width = adev->dsp_bit_width_enforce_mode;
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]5991
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]5992 /*this is populated by check_codec_backend_cfg hence set default value to false*/
5993 backend_cfg.passthrough_enabled = false;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]5994
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530[diff] [blame]5995 /* Set Backend sampling rate to 176.4 for DSD64 and
5996 * 352.8Khz for DSD128.
5997 * Set Bit Width to 16
5998 */
5999 if ((backend_idx == DSD_NATIVE_BACKEND) && (backend_cfg.format == AUDIO_FORMAT_DSD)) {
6000 backend_cfg.bit_width = 16;
6001 if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD64)
6002 backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD64;
6003 else if (backend_cfg.sample_rate == INPUT_SAMPLING_RATE_DSD128)
6004 backend_cfg.sample_rate = OUTPUT_SAMPLING_RATE_DSD128;
6005 }
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6006 ALOGI("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
6007 ", backend_idx %d usecase = %d device (%s)", __func__, backend_cfg.bit_width,
6008 backend_cfg.sample_rate, backend_cfg.channels, backend_idx, usecase->id,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +0530[diff] [blame]6009 platform_get_snd_device_name(snd_device));
6010
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -0700[diff] [blame]6011 if (platform_split_snd_device(my_data, snd_device, &num_devices,
6012 new_snd_devices) < 0)
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6013 new_snd_devices[0] = snd_device;
6014
6015 for (i = 0; i < num_devices; i++) {
6016 ALOGI("%s: new_snd_devices[%d] is %d", __func__, i, new_snd_devices[i]);
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6017 if ((platform_check_codec_backend_cfg(adev, usecase, new_snd_devices[i],
6018 &backend_cfg))) {
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6019 ret = platform_set_codec_backend_cfg(adev, new_snd_devices[i],
Ashish Jaind84fd6a2016-07-27 12:33:25 +0530[diff] [blame]6020 backend_cfg);
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6021 if (!ret) {
6022 ret = true;
6023 } else {
6024 ret = false;
6025 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6026 }
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6027 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6028 return ret;
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]6029}
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6030
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6031/*
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6032 * goes through all the current usecases and picks the highest
6033 * bitwidth & samplerate
6034 */
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6035static bool platform_check_capture_codec_backend_cfg(struct audio_device* adev,
6036 int backend_idx,
6037 struct audio_backend_cfg *backend_cfg)
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6038{
6039 bool backend_change = false;
6040 unsigned int bit_width;
6041 unsigned int sample_rate;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6042 unsigned int channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6043 unsigned int format;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6044 struct platform_data *my_data = (struct platform_data *)adev->platform;
6045
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6046 bit_width = backend_cfg->bit_width;
6047 sample_rate = backend_cfg->sample_rate;
6048 channels = backend_cfg->channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6049 format = backend_cfg->format;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6050
6051 ALOGI("%s:txbecf: afe: Codec selected backend: %d current bit width: %d and "
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6052 "sample rate: %d, channels %d format %d",__func__,backend_idx, bit_width,
6053 sample_rate, channels,format);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6054
6055 // For voice calls use default configuration i.e. 16b/48K, only applicable to
6056 // default backend
6057 // force routing is not required here, caller will do it anyway
Preetam Singh Ranawatd770a362017-05-24 19:07:15 +0530[diff] [blame]6058 if ((voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION)
6059 || (my_data->is_internal_codec)) {
6060
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6061 ALOGW("%s:txbecf: afe: Use default bw and sr for voice/voip calls and "
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6062 "for unprocessed/camera source", __func__);
6063 bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
6064 sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]6065 channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
6066 } else {
6067 struct listnode *node;
6068 struct audio_usecase *uc = NULL;
6069 unsigned int uc_channels = 0;
6070 struct stream_in *in = NULL;
6071 /* update cfg against other existing capture usecases on same backend */
6072 list_for_each(node, &adev->usecase_list) {
6073 uc = node_to_item(node, struct audio_usecase, list);
Satya Krishna Pindiproli9f566672017-02-28 11:14:01 +0530[diff] [blame]6074 in = (struct stream_in *) uc->stream.in;
6075 if (in != NULL && uc->type == PCM_CAPTURE &&
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]6076 backend_idx == platform_get_backend_index(uc->in_snd_device)) {
Dhananjay Kumar9983c372016-12-09 22:00:40 +0530[diff] [blame]6077 uc_channels = audio_channel_count_from_in_mask(in->channel_mask);
6078
6079 ALOGV("%s:txbecf: uc %s, id %d, sr %d, bw %d, ch %d, device %s",
6080 __func__, use_case_table[uc->id], uc->id, in->sample_rate,
6081 in->bit_width, uc_channels,
6082 platform_get_snd_device_name(uc->in_snd_device));
6083
6084 if (sample_rate < in->sample_rate)
6085 sample_rate = in->sample_rate;
6086 if (bit_width < in->bit_width)
6087 bit_width = in->bit_width;
6088 if (channels < uc_channels)
6089 channels = uc_channels;
6090 }
6091 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6092 }
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6093 if (backend_idx == USB_AUDIO_TX_BACKEND) {
6094 audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, false);
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6095 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]6096 __func__, bit_width, sample_rate, channels);
6097 }
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6098
6099 ALOGI("%s:txbecf: afe: Codec selected backend: %d updated bit width: %d and "
6100 "sample rate: %d", __func__, backend_idx, bit_width, sample_rate);
6101 // Force routing if the expected bitwdith or samplerate
6102 // is not same as current backend comfiguration
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6103 if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
6104 (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6105 (channels != my_data->current_backend_cfg[backend_idx].channels) ||
6106 ((format & AUDIO_FORMAT_MAIN_MASK) != my_data->current_backend_cfg[backend_idx].format)) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6107 backend_cfg->bit_width = bit_width;
6108 backend_cfg->sample_rate= sample_rate;
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6109 backend_cfg->channels = channels;
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6110 backend_cfg->format = format & AUDIO_FORMAT_MAIN_MASK;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6111 backend_change = true;
6112 ALOGI("%s:txbecf: afe: Codec backend needs to be updated. new bit width: %d "
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6113 "new sample rate: %d new channel: %d new format: %d",
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6114 __func__, backend_cfg->bit_width,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6115 backend_cfg->sample_rate, backend_cfg->channels, backend_cfg->format);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6116 }
6117
6118 return backend_change;
6119}
6120
6121bool platform_check_and_set_capture_codec_backend_cfg(struct audio_device* adev,
6122 struct audio_usecase *usecase, snd_device_t snd_device)
6123{
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6124 int backend_idx = platform_get_backend_index(snd_device);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6125 int ret = 0;
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6126 struct audio_backend_cfg backend_cfg;
6127
6128 backend_cfg.passthrough_enabled = false;
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530[diff] [blame]6129
6130 if (usecase->type == TRANSCODE_LOOPBACK) {
6131 backend_cfg.bit_width = usecase->stream.inout->in_config.bit_width;
6132 backend_cfg.sample_rate = usecase->stream.inout->in_config.sample_rate;
6133 backend_cfg.format = usecase->stream.inout->in_config.format;
6134 backend_cfg.channels = audio_channel_count_from_out_mask(
6135 usecase->stream.inout->in_config.channel_mask);
6136 } else if (usecase->type == PCM_CAPTURE) {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6137 backend_cfg.sample_rate= usecase->stream.in->sample_rate;
6138 backend_cfg.bit_width= usecase->stream.in->bit_width;
6139 backend_cfg.format= usecase->stream.in->format;
6140 backend_cfg.channels = audio_channel_count_from_in_mask(usecase->stream.in->channel_mask);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6141 } else {
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6142 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
6143 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
6144 backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
6145 backend_cfg.channels = 1;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6146 }
6147
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6148 ALOGI("%s:txbecf: afe: bitwidth %d, samplerate %d, channel %d format %d"
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6149 ", backend_idx %d usecase = %d device (%s)", __func__,
6150 backend_cfg.bit_width,
6151 backend_cfg.sample_rate,
6152 backend_cfg.channels,
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6153 backend_cfg.format,
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6154 backend_idx, usecase->id,
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6155 platform_get_snd_device_name(snd_device));
Kuirong Wange9894162016-08-26 15:16:39 -0700[diff] [blame]6156 if (platform_check_capture_codec_backend_cfg(adev, backend_idx,
6157 &backend_cfg)) {
Kuirong Wang0b947f72016-09-29 11:03:09 -0700[diff] [blame]6158 ret = platform_set_codec_backend_cfg(adev, snd_device,
6159 backend_cfg);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +0530[diff] [blame]6160 if(!ret)
6161 return true;
6162 }
6163
6164 return false;
6165}
6166
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6167int platform_set_snd_device_backend(snd_device_t device, const char *backend_tag,
6168 const char * hw_interface)
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6169{
6170 int ret = 0;
6171
6172 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
6173 ALOGE("%s: Invalid snd_device = %d",
6174 __func__, device);
6175 ret = -EINVAL;
6176 goto done;
6177 }
6178
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6179 ALOGD("%s: backend_tag_table[%s]: old = %s new = %s", __func__,
6180 platform_get_snd_device_name(device),
6181 backend_tag_table[device] != NULL ? backend_tag_table[device]: "null",
6182 backend_tag);
Ashish Jaind150d4c2017-02-03 18:44:34 +0530[diff] [blame]6183
6184 if (backend_tag != NULL ) {
6185 if (backend_tag_table[device]) {
6186 free(backend_tag_table[device]);
6187 }
6188 backend_tag_table[device] = strdup(backend_tag);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6189 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6190
6191 if (hw_interface != NULL) {
6192 if (hw_interface_table[device])
6193 free(hw_interface_table[device]);
6194
6195 ALOGD("%s: hw_interface_table[%d] = %s", __func__, device, hw_interface);
6196 hw_interface_table[device] = strdup(hw_interface);
6197 }
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6198done:
6199 return ret;
6200}
6201
Naresh Tanniru6160c712017-04-17 15:43:48 +0530[diff] [blame]6202const char *platform_get_snd_device_backend_interface(snd_device_t device)
6203{
6204 const char *hw_interface_name = NULL;
6205
6206 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
6207 ALOGE("%s: Invalid snd_device = %d",
6208 __func__, device);
6209 goto done;
6210 }
6211
6212 /* Get string value of necessary backend for device */
6213 hw_interface_name = hw_interface_table[device];
6214 if (hw_interface_name == NULL)
6215 ALOGE("%s: no hw_interface set for device %d\n", __func__, device);
6216 else
6217 ALOGD("%s: hw_interface set for device %s\n", __func__, hw_interface_name);
6218done:
6219 return hw_interface_name;
6220}
6221
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]6222int platform_get_snd_device_backend_index(snd_device_t device)
6223{
6224 int i, be_dai_id;
6225 const char * hw_interface_name = NULL;
6226
6227 ALOGV("%s: enter with device %d\n", __func__, device);
6228
Aditya Bavanari701a6992017-03-30 19:17:16 +0530[diff] [blame]6229 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
Siena Richard7c2db772016-12-21 11:32:34 -0800[diff] [blame]6230 ALOGE("%s: Invalid snd_device = %d",
6231 __func__, device);
6232 be_dai_id = -EINVAL;
6233 goto done;
6234 }
6235
6236 /* Get string value of necessary backend for device */
6237 hw_interface_name = hw_interface_table[device];
6238 if (hw_interface_name == NULL) {
6239 ALOGE("%s: no hw_interface set for device %d\n", __func__, device);
6240 be_dai_id = -EINVAL;
6241 goto done;
6242 }
6243
6244 /* Check if be dai name table was retrieved successfully */
6245 if (be_dai_name_table == NULL) {
6246 ALOGE("%s: BE DAI Name Table is not present\n", __func__);
6247 be_dai_id = -EFAULT;
6248 goto done;
6249 }
6250
6251 /* Get backend ID for device specified */
6252 for (i = 0; i < max_be_dai_names; i++) {
6253 if (strcmp(hw_interface_name, be_dai_name_table[i].be_name) == 0) {
6254 be_dai_id = be_dai_name_table[i].be_id;
6255 goto done;
6256 }
6257 }
6258 ALOGE("%s: no interface matching name %s\n", __func__, hw_interface_name);
6259 be_dai_id = -EINVAL;
6260 goto done;
6261
6262done:
6263 return be_dai_id;
6264}
6265
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6266int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id)
6267{
6268 int ret = 0;
6269 if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {
6270 ALOGE("%s: invalid usecase case idx %d", __func__, usecase);
6271 ret = -EINVAL;
6272 goto done;
6273 }
6274
6275 if ((type != 0) && (type != 1)) {
6276 ALOGE("%s: invalid usecase type", __func__);
6277 ret = -EINVAL;
6278 }
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +0530[diff] [blame]6279 ALOGV("%s: pcm_device_table[%d][%d] = %d", __func__, usecase, type, pcm_id);
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]6280 pcm_device_table[usecase][type] = pcm_id;
6281done:
6282 return ret;
6283}
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]6284
6285void platform_get_device_to_be_id_map(int **device_to_be_id, int *length)
6286{
Alexy Josephb1379942016-01-29 15:49:38 -0800[diff] [blame]6287 *device_to_be_id = (int*) msm_device_to_be_id;
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700[diff] [blame]6288 *length = msm_be_id_array_len;
6289}
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6290
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6291int platform_set_stream_pan_scale_params(void *platform,
6292 int snd_id,
6293 struct mix_matrix_params mm_params)
6294{
6295 struct platform_data *my_data = (struct platform_data *)platform;
6296 struct audio_device *adev = my_data->adev;
6297 struct mixer_ctl *ctl = NULL;
6298 char mixer_ctl_name[MIXER_PATH_MAX_LENGTH] = {0};
6299 int ret = 0;
6300 int iter_i = 0;
6301 int iter_j = 0;
6302 int length = 0;
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6303 char *pan_scale_data = NULL;
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6304
6305 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
6306 "Audio Stream %d Pan Scale Control", snd_id);
6307 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
6308
6309 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6310 if (!ctl) {
6311 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6312 __func__, mixer_ctl_name);
6313 ret = -EINVAL;
6314 goto end;
6315 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6316 pan_scale_data = (char *) calloc(1, sizeof(mm_params));
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]6317 if (!pan_scale_data) {
6318 ret = -ENOMEM;
6319 goto end;
6320 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6321 memcpy(&pan_scale_data[length], &mm_params.num_output_channels,
6322 sizeof(mm_params.num_output_channels));
6323 length += sizeof(mm_params.num_output_channels);
6324 memcpy(&pan_scale_data[length], &mm_params.num_input_channels,
6325 sizeof(mm_params.num_input_channels));
6326 length += sizeof(mm_params.num_input_channels);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6327
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6328 memcpy(&pan_scale_data[length], &mm_params.has_output_channel_map,
6329 sizeof(mm_params.has_output_channel_map));
6330 length += sizeof(mm_params.has_output_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6331 if (mm_params.has_output_channel_map &&
6332 mm_params.num_output_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6333 mm_params.num_output_channels > 0) {
6334 memcpy(&pan_scale_data[length], mm_params.output_channel_map,
6335 (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0])));
6336 length += (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0]));
6337 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6338 ret = -EINVAL;
6339 goto end;
6340 }
6341
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6342 memcpy(&pan_scale_data[length], &mm_params.has_input_channel_map,
6343 sizeof(mm_params.has_input_channel_map));
6344 length += sizeof(mm_params.has_input_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6345 if (mm_params.has_input_channel_map &&
6346 mm_params.num_input_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6347 mm_params.num_input_channels > 0) {
6348 memcpy(&pan_scale_data[length], mm_params.input_channel_map,
6349 (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0])));
6350 length += (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0]));
6351 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6352 ret = -EINVAL;
6353 goto end;
6354 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6355 pan_scale_data[length] = mm_params.has_mixer_coeffs;
6356 length += sizeof(mm_params.has_mixer_coeffs);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6357 if (mm_params.has_mixer_coeffs)
6358 for (iter_i = 0; iter_i < mm_params.num_output_channels; iter_i++)
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6359 for (iter_j = 0; iter_j < mm_params.num_input_channels; iter_j++) {
6360 memcpy(&pan_scale_data[length],
6361 &mm_params.mixer_coeffs[iter_i][iter_j],
6362 (sizeof(mm_params.mixer_coeffs[0][0])));
6363 length += (sizeof(mm_params.mixer_coeffs[0][0]));
6364 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6365
6366 ret = mixer_ctl_set_array(ctl, pan_scale_data, length);
6367end:
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]6368 if (pan_scale_data)
6369 free(pan_scale_data);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6370 return ret;
6371}
6372
6373int platform_set_stream_downmix_params(void *platform,
6374 int snd_id,
6375 snd_device_t snd_device,
6376 struct mix_matrix_params mm_params)
6377{
6378 struct platform_data *my_data = (struct platform_data *)platform;
6379 struct audio_device *adev = my_data->adev;
6380 struct mixer_ctl *ctl;
6381 char mixer_ctl_name[MIXER_PATH_MAX_LENGTH] = {0};
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6382 char *downmix_param_data = NULL;
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6383 int ret = 0;
6384 int iter_i = 0;
6385 int iter_j = 0;
6386 int length = 0;
6387 int be_idx = 0;
6388
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6389 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
6390 "Audio Device %d Downmix Control", snd_id);
6391 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
6392
6393 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6394 if (!ctl) {
6395 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6396 __func__, mixer_ctl_name);
6397 ret = -EINVAL;
6398 }
6399
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6400 downmix_param_data = (char *) calloc(1, sizeof(mm_params) + sizeof(be_idx));
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]6401 if (!downmix_param_data) {
6402 ret = -ENOMEM;
6403 goto end;
6404 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6405 be_idx = platform_get_snd_device_backend_index(snd_device);
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6406 memcpy(&downmix_param_data[length], &be_idx, sizeof(be_idx));
6407 length += sizeof(be_idx);
6408 memcpy(&downmix_param_data[length], &mm_params.num_output_channels,
6409 sizeof(mm_params.num_output_channels));
6410 length += sizeof(mm_params.num_output_channels);
6411 memcpy(&downmix_param_data[length], &mm_params.num_input_channels,
6412 sizeof(mm_params.num_input_channels));
6413 length += sizeof(mm_params.num_input_channels);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6414
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6415 memcpy(&downmix_param_data[length], &mm_params.has_output_channel_map,
6416 sizeof(mm_params.has_output_channel_map));
6417 length += sizeof(mm_params.has_output_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6418 if (mm_params.has_output_channel_map &&
6419 mm_params.num_output_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6420 mm_params.num_output_channels > 0) {
6421 memcpy(&downmix_param_data[length], mm_params.output_channel_map,
6422 (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0])));
6423 length += (mm_params.num_output_channels * sizeof(mm_params.output_channel_map[0]));
6424 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6425 ret = -EINVAL;
6426 goto end;
6427 }
6428
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6429 memcpy(&downmix_param_data[length], &mm_params.has_input_channel_map,
6430 sizeof(mm_params.has_input_channel_map));
6431 length += sizeof(mm_params.has_input_channel_map);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6432 if (mm_params.has_input_channel_map &&
6433 mm_params.num_input_channels <= MAX_CHANNELS_SUPPORTED &&
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6434 mm_params.num_input_channels > 0) {
6435 memcpy(&downmix_param_data[length], mm_params.input_channel_map,
6436 (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0])));
6437 length += (mm_params.num_input_channels * sizeof(mm_params.input_channel_map[0]));
6438 } else {
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6439 ret = -EINVAL;
6440 goto end;
6441 }
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6442 memcpy(&downmix_param_data[length], &mm_params.has_mixer_coeffs,
6443 sizeof(mm_params.has_mixer_coeffs));
6444 length += sizeof(mm_params.has_mixer_coeffs);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6445 if (mm_params.has_mixer_coeffs)
6446 for (iter_i = 0; iter_i < mm_params.num_output_channels; iter_i++)
Varun Balarajf3cc95c2017-09-13 16:36:32 +0530[diff] [blame]6447 for (iter_j = 0; iter_j < mm_params.num_input_channels; iter_j++) {
6448 memcpy((uint32_t *) &downmix_param_data[length],
6449 &mm_params.mixer_coeffs[iter_i][iter_j],
6450 (sizeof(mm_params.mixer_coeffs[0][0])));
6451 length += (sizeof(mm_params.mixer_coeffs[0][0]));
6452 }
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6453
6454 ret = mixer_ctl_set_array(ctl, downmix_param_data, length);
6455end:
Nikhil Latukar2e6f6242017-08-15 13:37:07 +0530[diff] [blame]6456 if (downmix_param_data)
6457 free(downmix_param_data);
Varun Balaraje49253e2017-07-06 19:48:56 +0530[diff] [blame]6458 return ret;
6459}
6460
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6461int platform_set_stream_channel_map(void *platform, audio_channel_mask_t channel_mask,
6462 int snd_id, uint8_t *input_channel_map)
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6463{
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6464 int ret = 0, i = 0;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6465 int channels = audio_channel_count_from_out_mask(channel_mask);
6466
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6467 char channel_map[AUDIO_CHANNEL_COUNT_MAX];
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6468 memset(channel_map, 0, sizeof(channel_map));
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6469 if (*input_channel_map) {
6470 for (i = 0; i < channels; i++) {
6471 ALOGV("%s:: Channel Map channel_map[%d] - %d", __func__, i, *input_channel_map);
6472 channel_map[i] = *input_channel_map;
6473 input_channel_map++;
6474 }
6475 } else {
6476 /* Following are all most common standard WAV channel layouts
6477 overridden by channel mask if its allowed and different */
6478 switch (channels) {
6479 case 1:
6480 /* AUDIO_CHANNEL_OUT_MONO */
6481 channel_map[0] = PCM_CHANNEL_FC;
6482 break;
6483 case 2:
6484 /* AUDIO_CHANNEL_OUT_STEREO */
6485 channel_map[0] = PCM_CHANNEL_FL;
6486 channel_map[1] = PCM_CHANNEL_FR;
6487 break;
6488 case 3:
6489 /* AUDIO_CHANNEL_OUT_2POINT1 */
6490 channel_map[0] = PCM_CHANNEL_FL;
6491 channel_map[1] = PCM_CHANNEL_FR;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6492 channel_map[2] = PCM_CHANNEL_FC;
Naresh Tanniru29bce4e2017-04-27 17:54:30 +0530[diff] [blame]6493 break;
6494 case 4:
6495 /* AUDIO_CHANNEL_OUT_QUAD_SIDE */
6496 channel_map[0] = PCM_CHANNEL_FL;
6497 channel_map[1] = PCM_CHANNEL_FR;
6498 channel_map[2] = PCM_CHANNEL_LS;
6499 channel_map[3] = PCM_CHANNEL_RS;
6500 if (channel_mask == AUDIO_CHANNEL_OUT_QUAD_BACK) {
6501 channel_map[2] = PCM_CHANNEL_LB;
6502 channel_map[3] = PCM_CHANNEL_RB;
6503 }
6504 if (channel_mask == AUDIO_CHANNEL_OUT_SURROUND) {
6505 channel_map[2] = PCM_CHANNEL_FC;
6506 channel_map[3] = PCM_CHANNEL_CS;
6507 }
6508 break;
6509 case 5:
6510 /* AUDIO_CHANNEL_OUT_PENTA */
6511 channel_map[0] = PCM_CHANNEL_FL;
6512 channel_map[1] = PCM_CHANNEL_FR;
6513 channel_map[2] = PCM_CHANNEL_FC;
6514 channel_map[3] = PCM_CHANNEL_LB;
6515 channel_map[4] = PCM_CHANNEL_RB;
6516 break;
6517 case 6:
6518 /* AUDIO_CHANNEL_OUT_5POINT1 */
6519 channel_map[0] = PCM_CHANNEL_FL;
6520 channel_map[1] = PCM_CHANNEL_FR;
6521 channel_map[2] = PCM_CHANNEL_FC;
6522 channel_map[3] = PCM_CHANNEL_LFE;
6523 channel_map[4] = PCM_CHANNEL_LB;
6524 channel_map[5] = PCM_CHANNEL_RB;
6525 if (channel_mask == AUDIO_CHANNEL_OUT_5POINT1_SIDE) {
6526 channel_map[4] = PCM_CHANNEL_LS;
6527 channel_map[5] = PCM_CHANNEL_RS;
6528 }
6529 break;
6530 case 7:
6531 /* AUDIO_CHANNEL_OUT_6POINT1 */
6532 channel_map[0] = PCM_CHANNEL_FL;
6533 channel_map[1] = PCM_CHANNEL_FR;
6534 channel_map[2] = PCM_CHANNEL_FC;
6535 channel_map[3] = PCM_CHANNEL_LFE;
6536 channel_map[4] = PCM_CHANNEL_LB;
6537 channel_map[5] = PCM_CHANNEL_RB;
6538 channel_map[6] = PCM_CHANNEL_CS;
6539 break;
6540 case 8:
6541 /* AUDIO_CHANNEL_OUT_7POINT1 */
6542 channel_map[0] = PCM_CHANNEL_FL;
6543 channel_map[1] = PCM_CHANNEL_FR;
6544 channel_map[2] = PCM_CHANNEL_FC;
6545 channel_map[3] = PCM_CHANNEL_LFE;
6546 channel_map[4] = PCM_CHANNEL_LB;
6547 channel_map[5] = PCM_CHANNEL_RB;
6548 channel_map[6] = PCM_CHANNEL_LS;
6549 channel_map[7] = PCM_CHANNEL_RS;
6550 break;
6551 default:
6552 ALOGE("unsupported channels %d for setting channel map", channels);
6553 return -1;
6554 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6555 }
6556 ret = platform_set_channel_map(platform, channels, channel_map, snd_id);
6557 return ret;
6558}
6559
6560int platform_get_edid_info(void *platform)
6561{
6562 struct platform_data *my_data = (struct platform_data *)platform;
6563 struct audio_device *adev = my_data->adev;
6564 char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE];
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]6565 int ret, count;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6566 char *mix_ctl_name;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6567 struct mixer_ctl *ctl;
6568 char edid_data[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE + 1] = {0};
6569 edid_audio_info *info;
6570
6571 if (my_data->edid_valid) {
6572 /* use cached edid */
6573 return 0;
6574 }
6575
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6576 switch(my_data->ext_disp_type) {
6577 case EXT_DISPLAY_TYPE_HDMI:
6578 mix_ctl_name = "HDMI EDID";
6579 break;
6580 case EXT_DISPLAY_TYPE_DP:
6581 mix_ctl_name = "Display Port EDID";
6582 break;
6583 default:
6584 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
6585 return -EINVAL;
6586 }
6587
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6588 if (my_data->edid_info == NULL) {
6589 my_data->edid_info =
6590 (struct edid_audio_info *)calloc(1, sizeof(struct edid_audio_info));
6591 }
6592
6593 info = my_data->edid_info;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6594 ctl = mixer_get_ctl_by_name(adev->mixer, mix_ctl_name);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6595 if (!ctl) {
6596 ALOGE("%s: Could not get ctl for mixer cmd - %s",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6597 __func__, mix_ctl_name);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6598 goto fail;
6599 }
6600
6601 mixer_ctl_update(ctl);
6602
6603 count = mixer_ctl_get_num_values(ctl);
6604
6605 /* Read SAD blocks, clamping the maximum size for safety */
6606 if (count > (int)sizeof(block))
6607 count = (int)sizeof(block);
6608
6609 ret = mixer_ctl_get_array(ctl, block, count);
6610 if (ret != 0) {
6611 ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__);
6612 goto fail;
6613 }
6614 edid_data[0] = count;
6615 memcpy(&edid_data[1], block, count);
6616
6617 if (!edid_get_sink_caps(info, edid_data)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6618 ALOGE("%s: Failed to get extn disp sink capabilities", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6619 goto fail;
6620 }
6621 my_data->edid_valid = true;
6622 return 0;
6623fail:
6624 if (my_data->edid_info) {
6625 free(my_data->edid_info);
6626 my_data->edid_info = NULL;
6627 my_data->edid_valid = false;
6628 }
6629 ALOGE("%s: return -EINVAL", __func__);
6630 return -EINVAL;
6631}
6632
6633
6634int platform_set_channel_allocation(void *platform, int channel_alloc)
6635{
6636 struct mixer_ctl *ctl;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6637 char *mixer_ctl_name;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6638 int ret;
6639 struct platform_data *my_data = (struct platform_data *)platform;
6640 struct audio_device *adev = my_data->adev;
6641
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6642 switch(my_data->ext_disp_type) {
6643 case EXT_DISPLAY_TYPE_HDMI:
6644 mixer_ctl_name = "HDMI RX CA";
6645 break;
6646 case EXT_DISPLAY_TYPE_DP:
6647 mixer_ctl_name = "Display Port RX CA";
6648 break;
6649 default:
6650 ALOGE("%s: Invalid disp_type %d", __func__, my_data->ext_disp_type);
6651 return -EINVAL;
6652 }
6653
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6654 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6655 if (!ctl) {
6656 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6657 __func__, mixer_ctl_name);
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6658 return -EINVAL;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6659 }
6660 ALOGD(":%s channel allocation = 0x%x", __func__, channel_alloc);
6661 ret = mixer_ctl_set_value(ctl, 0, channel_alloc);
6662
6663 if (ret < 0) {
6664 ALOGE("%s: Could not set ctl, error:%d ", __func__, ret);
6665 }
6666
6667 return ret;
6668}
6669
6670int platform_set_channel_map(void *platform, int ch_count, char *ch_map, int snd_id)
6671{
6672 struct mixer_ctl *ctl;
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -0800[diff] [blame]6673 char mixer_ctl_name[44] = {0}; // max length of name is 44 as defined
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6674 int ret;
6675 unsigned int i;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]6676 long set_values[FCC_8] = {0};
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6677 struct platform_data *my_data = (struct platform_data *)platform;
6678 struct audio_device *adev = my_data->adev;
6679 ALOGV("%s channel_count:%d",__func__, ch_count);
Divya Narayanan Poojary21de6aa2017-01-06 12:07:19 +0530[diff] [blame]6680 if (NULL == ch_map || (ch_count < 1) || (ch_count > FCC_8)) {
6681 ALOGE("%s: Invalid channel mapping or channel count value", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6682 return -EINVAL;
6683 }
Fred Ohe0479682015-03-25 16:30:26 -0700[diff] [blame]6684
6685 /*
6686 * If snd_id is greater than 0, stream channel mapping
6687 * If snd_id is below 0, typically -1, device channel mapping
6688 */
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6689 if (snd_id >= 0) {
Fred Ohe0479682015-03-25 16:30:26 -0700[diff] [blame]6690 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Playback Channel Map%d", snd_id);
6691 } else {
6692 strlcpy(mixer_ctl_name, "Playback Device Channel Map", sizeof(mixer_ctl_name));
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6693 }
6694
6695 ALOGD("%s mixer_ctl_name:%s", __func__, mixer_ctl_name);
6696
6697 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
6698 if (!ctl) {
6699 ALOGE("%s: Could not get ctl for mixer cmd - %s",
6700 __func__, mixer_ctl_name);
6701 return -EINVAL;
6702 }
Divya Narayanan Poojary21de6aa2017-01-06 12:07:19 +0530[diff] [blame]6703 for (i = 0; i < (unsigned int)ch_count; i++) {
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6704 set_values[i] = ch_map[i];
6705 }
6706
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]6707 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]6708 set_values[0], set_values[1], set_values[2], set_values[3], set_values[4],
6709 set_values[5], set_values[6], set_values[7], ch_count);
6710
Divya Narayanan Poojary21de6aa2017-01-06 12:07:19 +0530[diff] [blame]6711 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6712 if (ret < 0) {
6713 ALOGE("%s: Could not set ctl, error:%d ch_count:%d",
6714 __func__, ret, ch_count);
6715 }
6716 return ret;
6717}
6718
6719unsigned char platform_map_to_edid_format(int audio_format)
6720{
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6721 unsigned char format;
6722 switch (audio_format & AUDIO_FORMAT_MAIN_MASK) {
6723 case AUDIO_FORMAT_AC3:
6724 ALOGV("%s: AC3", __func__);
6725 format = AC3;
6726 break;
6727 case AUDIO_FORMAT_AAC:
6728 ALOGV("%s:AAC", __func__);
6729 format = AAC;
6730 break;
Manish Dewangana6fc5442015-08-24 20:30:31 +0530[diff] [blame]6731 case AUDIO_FORMAT_AAC_ADTS:
6732 ALOGV("%s:AAC_ADTS", __func__);
6733 format = AAC;
6734 break;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6735 case AUDIO_FORMAT_E_AC3:
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +0530[diff] [blame]6736 case AUDIO_FORMAT_E_AC3_JOC:
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6737 ALOGV("%s:E_AC3", __func__);
6738 format = DOLBY_DIGITAL_PLUS;
6739 break;
Ben Romberger1aaaf862017-04-06 17:49:46 -0700[diff] [blame]6740 case AUDIO_FORMAT_DOLBY_TRUEHD:
6741 ALOGV("%s:MAT", __func__);
6742 format = MAT;
6743 break;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6744 case AUDIO_FORMAT_DTS:
6745 ALOGV("%s:DTS", __func__);
6746 format = DTS;
6747 break;
6748 case AUDIO_FORMAT_DTS_HD:
6749 ALOGV("%s:DTS_HD", __func__);
6750 format = DTS_HD;
6751 break;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6752 case AUDIO_FORMAT_PCM_16_BIT:
Ashish Jain5106d362016-05-11 19:23:33 +0530[diff] [blame]6753 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
6754 case AUDIO_FORMAT_PCM_8_24_BIT:
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6755 ALOGV("%s:PCM", __func__);
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6756 format = LPCM;
6757 break;
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]6758 case AUDIO_FORMAT_IEC61937:
6759 ALOGV("%s:IEC61937", __func__);
6760 format = 0;
6761 break;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6762 default:
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6763 format = -1;
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]6764 ALOGE("%s:invalid format: 0x%x", __func__, audio_format);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6765 break;
6766 }
6767 return format;
6768}
6769
Ashish Jaina052e572016-11-07 16:41:07 +0530[diff] [blame]6770void platform_check_and_update_copp_sample_rate(void* platform, snd_device_t snd_device,
6771 unsigned int stream_sr, int* sample_rate)
6772{
6773 struct platform_data* my_data = (struct platform_data *)platform;
6774 int backend_idx = platform_get_backend_index(snd_device);
6775 int device_sr = my_data->current_backend_cfg[backend_idx].sample_rate;
6776 /*
6777 *Check if device SR is multiple of 8K or 11.025 Khz
6778 *check if the stream SR is multiple of same base, if yes
6779 *then have copp SR equal to stream SR, this ensures that
6780 *post processing happens at stream SR, else have
6781 *copp SR equal to device SR.
6782 */
6783 if (!(((sample_rate_multiple(device_sr, SAMPLE_RATE_8000)) &&
6784 (sample_rate_multiple(stream_sr, SAMPLE_RATE_8000))) ||
6785 ((sample_rate_multiple(device_sr, SAMPLE_RATE_11025)) &&
6786 (sample_rate_multiple(stream_sr, SAMPLE_RATE_11025))))) {
6787 *sample_rate = device_sr;
6788 } else
6789 *sample_rate = stream_sr;
6790
Venugopal Nadipalli83134582017-09-21 22:34:50 +0530[diff] [blame]6791 if (snd_device == SND_DEVICE_OUT_HDMI)
6792 *sample_rate = platform_get_supported_sampling_rate_on_hdmi(stream_sr);
6793
6794 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]6795
6796}
6797
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]6798void platform_reset_edid_info(void *platform) {
6799
6800 ALOGV("%s:", __func__);
6801 struct platform_data *my_data = (struct platform_data *)platform;
6802 if (my_data->edid_info) {
6803 ALOGV("%s :free edid", __func__);
6804 free(my_data->edid_info);
6805 my_data->edid_info = NULL;
6806 }
6807}
6808
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6809bool platform_is_edid_supported_format(void *platform, int format)
6810{
6811 struct platform_data *my_data = (struct platform_data *)platform;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6812 edid_audio_info *info = NULL;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]6813 int i, ret;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6814 unsigned char format_id = platform_map_to_edid_format(format);
6815
Naresh Tanniru928f0862017-04-07 16:44:23 -0700[diff] [blame]6816 if (format == AUDIO_FORMAT_IEC61937)
6817 return true;
6818
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6819 if (format_id <= 0) {
6820 ALOGE("%s invalid edid format mappting for :%x" ,__func__, format);
6821 return false;
6822 }
6823
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6824 ret = platform_get_edid_info(platform);
6825 info = (edid_audio_info *)my_data->edid_info;
6826 if (ret == 0 && info != NULL) {
6827 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]6828 /*
6829 * To check
6830 * is there any special for CONFIG_HDMI_PASSTHROUGH_CONVERT
6831 * & DOLBY_DIGITAL_PLUS
6832 */
6833 if (info->audio_blocks_array[i].format_id == format_id) {
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6834 ALOGV("%s:returns true %x",
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]6835 __func__, format);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6836 return true;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]6837 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6838 }
6839 }
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6840 ALOGV("%s:returns false %x",
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6841 __func__, format);
6842 return false;
6843}
6844
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6845bool platform_is_edid_supported_sample_rate(void *platform, int sample_rate)
6846{
6847 struct platform_data *my_data = (struct platform_data *)platform;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6848 edid_audio_info *info = NULL;
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]6849 int ret = 0;
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6850
6851 ret = platform_get_edid_info(platform);
6852 info = (edid_audio_info *)my_data->edid_info;
6853 if (ret == 0 && info != NULL) {
Garmond Leung2f78a672016-11-07 16:27:40 -0800[diff] [blame]6854 return edid_is_supported_sr(info, sample_rate);
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6855 }
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6856
6857 return false;
6858}
6859
Naresh Tanniru3a406772017-05-10 13:09:05 -0700[diff] [blame]6860int platform_edid_get_highest_supported_sr(void *platform)
6861{
6862 struct platform_data *my_data = (struct platform_data *)platform;
6863 edid_audio_info *info = NULL;
6864 int ret = 0;
6865
6866 ret = platform_get_edid_info(platform);
6867 info = (edid_audio_info *)my_data->edid_info;
6868 if (ret == 0 && info != NULL) {
6869 return edid_get_highest_supported_sr(info);
6870 }
6871
6872 return 0;
6873}
Mingming Yin3a941d42016-02-17 18:08:05 -0800[diff] [blame]6874
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6875int platform_set_edid_channels_configuration(void *platform, int channels) {
6876
6877 struct platform_data *my_data = (struct platform_data *)platform;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6878 struct audio_device *adev = my_data->adev;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6879 edid_audio_info *info = NULL;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6880 int channel_count = 2;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +0530[diff] [blame]6881 int i, ret;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6882 char default_channelMap[MAX_CHANNELS_SUPPORTED] = {0};
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6883 struct audio_device_config_param *adev_device_cfg_ptr = adev->device_cfg_params;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6884
6885 ret = platform_get_edid_info(platform);
6886 info = (edid_audio_info *)my_data->edid_info;
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6887 adev_device_cfg_ptr += HDMI_RX_BACKEND;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6888 if(ret == 0 && info != NULL) {
6889 if (channels > 2) {
6890
6891 ALOGV("%s:able to get HDMI sink capabilities multi channel playback",
6892 __func__);
6893 for (i = 0; i < info->audio_blocks && i < MAX_EDID_BLOCKS; i++) {
6894 if (info->audio_blocks_array[i].format_id == LPCM &&
6895 info->audio_blocks_array[i].channels > channel_count &&
6896 info->audio_blocks_array[i].channels <= MAX_HDMI_CHANNEL_CNT) {
6897 channel_count = info->audio_blocks_array[i].channels;
6898 }
6899 }
6900 ALOGVV("%s:channel_count:%d", __func__, channel_count);
6901 /*
6902 * Channel map is set for supported hdmi max channel count even
6903 * though the input channel count set on adm is less than or equal to
6904 * max supported channel count
6905 */
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6906 if (adev_device_cfg_ptr->use_client_dev_cfg) {
6907 platform_set_channel_map(platform, adev_device_cfg_ptr->dev_cfg_params.channels,
6908 (char *)adev_device_cfg_ptr->dev_cfg_params.channel_map, -1);
6909 } else {
6910 platform_set_channel_map(platform, channel_count, info->channel_map, -1);
6911 }
6912
6913 if (adev_device_cfg_ptr->use_client_dev_cfg) {
6914 ALOGV("%s:: Setting client selected CA %d", __func__,
6915 adev_device_cfg_ptr->dev_cfg_params.channel_allocation);
6916 platform_set_channel_allocation(platform,
6917 adev_device_cfg_ptr->dev_cfg_params.channel_allocation);
6918 } else {
6919 platform_set_channel_allocation(platform, info->channel_allocation);
6920 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6921 } else {
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]6922 if (adev_device_cfg_ptr->use_client_dev_cfg) {
6923 default_channelMap[0] = adev_device_cfg_ptr->dev_cfg_params.channel_map[0];
6924 default_channelMap[1] = adev_device_cfg_ptr->dev_cfg_params.channel_map[1];
6925 } else {
6926 default_channelMap[0] = PCM_CHANNEL_FL;
6927 default_channelMap[1] = PCM_CHANNEL_FR;
6928 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6929 platform_set_channel_map(platform,2,default_channelMap,-1);
6930 platform_set_channel_allocation(platform,0);
6931 }
6932 }
6933
6934 return 0;
6935}
6936
6937void platform_cache_edid(void * platform)
6938{
6939 platform_get_edid_info(platform);
6940}
6941
Siddartha Shaik44dd7702017-06-14 12:13:25 +0530[diff] [blame]6942void platform_invalidate_backend_config(void * platform,snd_device_t snd_device)
6943{
6944 struct platform_data *my_data = (struct platform_data *)platform;
6945 struct audio_device *adev = my_data->adev;
6946 struct audio_backend_cfg backend_cfg;
6947 int backend_idx;
6948
6949 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
6950 backend_cfg.channels = CODEC_BACKEND_DEFAULT_CHANNELS;
6951 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
6952 backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
6953 backend_cfg.passthrough_enabled = false;
6954
6955 backend_idx = platform_get_backend_index(snd_device);
6956 platform_set_codec_backend_cfg(adev, snd_device, backend_cfg);
6957 my_data->current_backend_cfg[backend_idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
6958 my_data->current_backend_cfg[backend_idx].channels = CODEC_BACKEND_DEFAULT_CHANNELS;
6959 my_data->current_backend_cfg[backend_idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
6960 my_data->current_backend_cfg[backend_idx].format = AUDIO_FORMAT_PCM_16_BIT;
6961}
6962
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]6963void platform_invalidate_hdmi_config(void * platform)
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6964{
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6965 //reset ext display EDID info
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6966 struct platform_data *my_data = (struct platform_data *)platform;
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]6967 struct audio_device *adev = my_data->adev;
6968 struct audio_backend_cfg backend_cfg;
6969 int backend_idx;
6970 snd_device_t snd_device;
6971
6972 backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
6973 backend_cfg.channels = DEFAULT_HDMI_OUT_CHANNELS;
6974 backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
6975 backend_cfg.format = 0;
6976 backend_cfg.passthrough_enabled = false;
6977
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6978 my_data->edid_valid = false;
6979 if (my_data->edid_info) {
6980 memset(my_data->edid_info, 0, sizeof(struct edid_audio_info));
6981 }
Mingming Yinddd610b2016-01-20 17:09:32 -0800[diff] [blame]6982
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6983 if (my_data->ext_disp_type == EXT_DISPLAY_TYPE_HDMI) {
6984 //reset HDMI_RX_BACKEND to default values
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]6985 backend_idx = HDMI_RX_BACKEND;
6986 snd_device = SND_DEVICE_OUT_HDMI;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6987 } else {
6988 //reset Display port BACKEND to default values
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]6989 backend_idx = DISP_PORT_RX_BACKEND;
6990 snd_device = SND_DEVICE_OUT_DISPLAY_PORT;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6991 }
Ben Rombergere9e80ee2017-04-26 16:00:10 -0700[diff] [blame]6992 platform_set_codec_backend_cfg(adev, snd_device, backend_cfg);
6993 my_data->current_backend_cfg[backend_idx].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
6994 my_data->current_backend_cfg[backend_idx].channels = DEFAULT_HDMI_OUT_CHANNELS;
6995 my_data->current_backend_cfg[backend_idx].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700[diff] [blame]6996 my_data->ext_disp_type = EXT_DISPLAY_TYPE_NONE;
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700[diff] [blame]6997}
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]6998
6999int platform_set_mixer_control(struct stream_out *out, const char * mixer_ctl_name,
7000 const char *mixer_val)
7001{
7002 struct audio_device *adev = out->dev;
7003 struct mixer_ctl *ctl = NULL;
7004 ALOGD("setting mixer ctl %s with value %s", mixer_ctl_name, mixer_val);
7005 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
7006 if (!ctl) {
7007 ALOGE("%s: could not get ctl for mixer cmd - %s",
7008 __func__, mixer_ctl_name);
7009 return -EINVAL;
7010 }
7011
7012 return mixer_ctl_set_enum_by_string(ctl, mixer_val);
7013}
7014
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]7015int platform_set_device_params(struct stream_out *out, int param, int value)
7016{
7017 struct audio_device *adev = out->dev;
7018 struct mixer_ctl *ctl;
7019 char *mixer_ctl_name = "Device PP Params";
7020 int ret = 0;
Manish Dewangan338c50a2017-09-12 15:22:03 +0530[diff] [blame]7021 long set_values[] = {0,0};
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -0700[diff] [blame]7022
7023 set_values[0] = param;
7024 set_values[1] = value;
7025
7026 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
7027 if (!ctl) {
7028 ALOGE("%s: Could not get ctl for mixer cmd - %s",
7029 __func__, mixer_ctl_name);
7030 ret = -EINVAL;
7031 goto end;
7032 }
7033
7034 ALOGV("%s: Setting device pp params param: %d, value %d mixer ctrl:%s",
7035 __func__,param, value, mixer_ctl_name);
7036 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
7037
7038end:
7039 return ret;
7040}
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]7041
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7042bool platform_can_enable_spkr_prot_on_device(snd_device_t snd_device)
7043{
7044 bool ret = false;
7045
7046 if (snd_device == SND_DEVICE_OUT_SPEAKER ||
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]7047 snd_device == SND_DEVICE_OUT_SPEAKER_REVERSE ||
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7048 snd_device == SND_DEVICE_OUT_SPEAKER_VBAT ||
7049 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_VBAT ||
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7050 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT ||
7051 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER ||
7052 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_2) {
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7053 ret = true;
7054 }
7055
7056 return ret;
7057}
7058
7059int platform_get_spkr_prot_acdb_id(snd_device_t snd_device)
7060{
7061 int acdb_id;
7062
7063 switch(snd_device) {
7064 case SND_DEVICE_OUT_SPEAKER:
7065 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED);
7066 break;
7067 case SND_DEVICE_OUT_VOICE_SPEAKER:
7068 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED);
7069 break;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7070 case SND_DEVICE_OUT_VOICE_SPEAKER_2:
7071 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED);
7072 break;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7073 case SND_DEVICE_OUT_SPEAKER_VBAT:
7074 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT);
7075 break;
7076 case SND_DEVICE_OUT_VOICE_SPEAKER_VBAT:
7077 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT);
7078 break;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7079 case SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT:
7080 acdb_id = platform_get_snd_device_acdb_id(SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT);
7081 break;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7082 default:
7083 acdb_id = -EINVAL;
7084 break;
7085 }
7086 return acdb_id;
7087}
7088
7089int platform_get_spkr_prot_snd_device(snd_device_t snd_device)
7090{
7091 if (!audio_extn_spkr_prot_is_enabled())
7092 return snd_device;
7093
7094 switch(snd_device) {
7095 case SND_DEVICE_OUT_SPEAKER:
7096 return SND_DEVICE_OUT_SPEAKER_PROTECTED;
7097 case SND_DEVICE_OUT_VOICE_SPEAKER:
7098 return SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7099 case SND_DEVICE_OUT_VOICE_SPEAKER_2:
7100 return SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7101 case SND_DEVICE_OUT_SPEAKER_VBAT:
7102 return SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT;
7103 case SND_DEVICE_OUT_VOICE_SPEAKER_VBAT:
7104 return SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT;
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7105 case SND_DEVICE_OUT_VOICE_SPEAKER_2_VBAT:
7106 return SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT;
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7107 default:
7108 return snd_device;
7109 }
7110}
Rohit kumarf4120402016-08-05 19:19:48 +0530[diff] [blame]7111int platform_get_vi_feedback_snd_device(snd_device_t snd_device)
7112{
7113 switch(snd_device) {
7114 case SND_DEVICE_OUT_SPEAKER_PROTECTED:
7115 case SND_DEVICE_OUT_SPEAKER_PROTECTED_VBAT:
7116 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK;
7117 case SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED:
7118 case SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED_VBAT:
7119 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_1;
7120 case SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED:
7121 case SND_DEVICE_OUT_VOICE_SPEAKER_2_PROTECTED_VBAT:
7122 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK_MONO_2;
7123 default:
7124 return SND_DEVICE_IN_CAPTURE_VI_FEEDBACK;
7125 }
7126}
Xiaojun Sang040cc9f2015-08-03 19:38:28 +0800[diff] [blame]7127
Venkata Narendra Kumar Gutta7f4817f2016-01-29 14:15:53 +0530[diff] [blame]7128int platform_spkr_prot_is_wsa_analog_mode(void *adev __unused)
7129{
7130 return 0;
7131}
7132
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]7133/*
7134 * This is a lookup table to map android audio input device to audio h/w interface (backend).
7135 * The table can be extended for other input devices by adding appropriate entries.
7136 * Also the audio interface for a particular input device can be overriden by adding
7137 * corresponding entry in audio_platform_info.xml file.
7138 */
7139struct audio_device_to_audio_interface audio_device_to_interface_table[] = {
7140 {AUDIO_DEVICE_IN_BUILTIN_MIC, ENUM_TO_STRING(AUDIO_DEVICE_IN_BUILTIN_MIC), "SLIMBUS_0"},
7141 {AUDIO_DEVICE_IN_BACK_MIC, ENUM_TO_STRING(AUDIO_DEVICE_IN_BACK_MIC), "SLIMBUS_0"},
7142};
7143
7144int audio_device_to_interface_table_len =
7145 sizeof(audio_device_to_interface_table) / sizeof(audio_device_to_interface_table[0]);
7146
Karthik Reddy Katta508eca42015-05-11 13:43:18 +0530[diff] [blame]7147int platform_set_audio_device_interface(const char *device_name, const char *intf_name,
7148 const char *codec_type __unused)
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -0800[diff] [blame]7149{
7150 int ret = 0;
7151 int i;
7152
7153 if (device_name == NULL || intf_name == NULL) {
7154 ALOGE("%s: Invalid input", __func__);
7155
7156 ret = -EINVAL;
7157 goto done;
7158 }
7159
7160 ALOGD("%s: Enter, device name:%s, intf name:%s", __func__, device_name, intf_name);
7161
7162 size_t device_name_len = strlen(device_name);
7163 for (i = 0; i < audio_device_to_interface_table_len; i++) {
7164 char* name = audio_device_to_interface_table[i].device_name;
7165 size_t name_len = strlen(name);
7166 if ((name_len == device_name_len) &&
7167 (strncmp(device_name, name, name_len) == 0)) {
7168 ALOGD("%s: Matched device name:%s, overwrite intf name with %s",
7169 __func__, device_name, intf_name);
7170
7171 strlcpy(audio_device_to_interface_table[i].interface_name, intf_name,
7172 sizeof(audio_device_to_interface_table[i].interface_name));
7173 goto done;
7174 }
7175 }
7176 ALOGE("%s: Could not find matching device name %s",
7177 __func__, device_name);
7178
7179 ret = -EINVAL;
7180
7181done:
7182 return ret;
7183}
Laxminath Kasam44f49402015-05-29 18:37:11 +0530[diff] [blame]7184
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]7185int platform_set_sidetone(struct audio_device *adev,
7186 snd_device_t out_snd_device,
7187 bool enable,
7188 char *str)
7189{
7190 int ret;
Ashish Jain3e37a702016-11-25 12:27:15 +0530[diff] [blame]7191 if ((out_snd_device == SND_DEVICE_OUT_USB_HEADSET) ||
7192 (out_snd_device == SND_DEVICE_OUT_USB_HEADPHONES)) {
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700[diff] [blame]7193 if (property_get_bool("vendor.audio.usb.disable.sidetone", 0)) {
Haynes Mathew George492a6c42016-10-28 11:41:43 -0700[diff] [blame]7194 ALOGI("Debug: Disable sidetone");
7195 } else {
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]7196 ret = audio_extn_usb_enable_sidetone(out_snd_device, enable);
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]7197 if (ret) {
7198 /*fall back to AFE sidetone*/
7199 ALOGV("%s: No USB sidetone supported, switching to AFE sidetone",
7200 __func__);
7201
7202 if (enable)
7203 audio_route_apply_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
7204 else
7205 audio_route_reset_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
7206 }
Haynes Mathew George492a6c42016-10-28 11:41:43 -0700[diff] [blame]7207 }
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]7208 } else {
7209 ALOGV("%s: sidetone out device(%d) mixer cmd = %s\n",
7210 __func__, out_snd_device, str);
Laxminath Kasam44f49402015-05-29 18:37:11 +0530[diff] [blame]7211
Vikram Panduranga6e761cd2016-10-12 16:50:52 -0700[diff] [blame]7212 if (enable) {
7213 ret = audio_route_apply_and_update_path(adev->audio_route, str);
7214 if (ret) {
7215 ALOGV("%s: No device sidetone supported, switching to AFE sidetone",
7216 __func__);
7217 audio_route_apply_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
7218 }
7219 }
7220 else {
7221 ret = audio_route_reset_and_update_path(adev->audio_route, str);
7222 if (ret) {
7223 ALOGV("%s: No device sidetone supported, switching to AFE sidetone",
7224 __func__);
7225 audio_route_reset_and_update_path(adev->audio_route, AFE_SIDETONE_MIXER_PATH);
7226 }
7227 }
Kuirong Wang1cad7142016-05-24 15:21:56 -0700[diff] [blame]7228 }
7229 return 0;
7230}
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]7231
Vidyakumar Athotaea269c62016-10-31 09:05:59 -0700[diff] [blame]7232void platform_update_aanc_path(struct audio_device *adev,
7233 snd_device_t out_snd_device,
7234 bool enable,
7235 char *str)
7236{
7237 ALOGD("%s: aanc out device(%d) mixer cmd = %s, enable = %d\n",
7238 __func__, out_snd_device, str, enable);
7239
7240 if (enable)
7241 audio_route_apply_and_update_path(adev->audio_route, str);
7242 else
7243 audio_route_reset_and_update_path(adev->audio_route, str);
7244
7245 return;
7246}
7247
Weiyin Jiangaa80acd2016-09-21 16:42:11 +0800[diff] [blame]7248static void make_cal_cfg(acdb_audio_cal_cfg_t* cal, int acdb_dev_id,
7249 int acdb_device_type, int app_type, int topology_id,
7250 int sample_rate, uint32_t module_id, uint32_t param_id, bool persist)
7251{
7252 int persist_send_flags = 1;
7253
7254 if (!cal) {
7255 return;
7256 }
7257
7258 if (persist)
7259 persist_send_flags |= 0x2;
7260
7261 memset(cal, 0, sizeof(acdb_audio_cal_cfg_t));
7262
7263 cal->persist = persist;
7264 cal->app_type = app_type;
7265 cal->acdb_dev_id = acdb_dev_id;
7266 cal->sampling_rate = sample_rate;
7267 cal->topo_id = topology_id;
7268 //if module and param id is set to 0, the whole blob will be stored
7269 //or sent to the DSP
7270 cal->module_id = module_id;
7271 cal->param_id = param_id;
7272 cal->cal_type = acdb_device_type;
7273 cal->persist = persist;
7274
7275}
7276
7277int platform_send_audio_cal(void* platform, int acdb_dev_id,
7278 int acdb_device_type, int app_type, int topology_id, int sample_rate,
7279 uint32_t module_id, uint32_t param_id, void* data, int length, bool persist)
7280{
7281 int ret = 0;
7282 struct platform_data *my_data = (struct platform_data *)platform;
7283 acdb_audio_cal_cfg_t cal;
7284 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
7285
7286 if (!my_data) {
7287 ret = -EINVAL;
7288 goto ERROR_RETURN;
7289 }
7290
7291 make_cal_cfg(&cal, acdb_dev_id, acdb_device_type, app_type, topology_id,
7292 sample_rate, module_id, param_id, true);
7293
7294 if (my_data->acdb_set_audio_cal) {
7295 // persist audio cal in local cache
7296 if (persist) {
7297 ret = my_data->acdb_set_audio_cal((void*)&cal, data, (uint32_t)length);
7298 }
7299 // send audio cal to dsp
7300 if (ret == 0) {
7301 cal.persist = false;
7302 ret = my_data->acdb_set_audio_cal((void*)&cal, data, (uint32_t)length);
7303 if (persist && (ret != 0)) {
7304 ALOGV("[%s] audio cal stored with success, ignore set cal failure", __func__);
7305 ret = 0;
7306 }
7307 }
7308 }
7309
7310ERROR_RETURN:
7311 return ret;
7312}
7313
7314int platform_get_audio_cal(void* platform, int acdb_dev_id,
7315 int acdb_device_type, int app_type, int topology_id,
7316 int sample_rate, uint32_t module_id, uint32_t param_id,
7317 void* data, int* length, bool persist)
7318{
7319 int ret = 0;
7320 struct platform_data *my_data = (struct platform_data *)platform;
7321 acdb_audio_cal_cfg_t cal;
7322 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
7323
7324 if (!my_data) {
7325 ret = -EINVAL;
7326 goto ERROR_RETURN;
7327 }
7328
7329 make_cal_cfg(&cal, acdb_dev_id, acdb_device_type, app_type, topology_id,
7330 sample_rate, module_id, param_id, false);
7331
7332 if (my_data->acdb_get_audio_cal) {
7333 // get cal from dsp
7334 ret = my_data->acdb_get_audio_cal((void*)&cal, data, (uint32_t*)length);
7335 // get cached cal if prevoius attempt fails and persist flag is set
7336 if ((ret != 0) && persist) {
7337 cal.persist = true;
7338 ret = my_data->acdb_get_audio_cal((void*)&cal, data, (uint32_t*)length);
7339 }
7340 }
7341
7342ERROR_RETURN:
7343 return ret;
7344}
7345
7346int platform_store_audio_cal(void* platform, int acdb_dev_id,
7347 int acdb_device_type, int app_type, int topology_id,
7348 int sample_rate, uint32_t module_id, uint32_t param_id,
7349 void* data, int length)
7350{
7351 int ret = 0;
7352 struct platform_data *my_data = (struct platform_data *)platform;
7353 acdb_audio_cal_cfg_t cal;
7354 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
7355
7356 if (!my_data) {
7357 ret = -EINVAL;
7358 goto ERROR_RETURN;
7359 }
7360
7361 make_cal_cfg(&cal, acdb_dev_id, acdb_device_type, app_type, topology_id,
7362 sample_rate, module_id, param_id, true);
7363
7364 if (my_data->acdb_set_audio_cal) {
7365 ret = my_data->acdb_set_audio_cal((void*)&cal, data, (uint32_t)length);
7366 }
7367
7368ERROR_RETURN:
7369 return ret;
7370}
7371
7372int platform_retrieve_audio_cal(void* platform, int acdb_dev_id,
7373 int acdb_device_type, int app_type, int topology_id,
7374 int sample_rate, uint32_t module_id, uint32_t param_id,
7375 void* data, int* length)
7376{
7377 int ret = 0;
7378 struct platform_data *my_data = (struct platform_data *)platform;
7379 acdb_audio_cal_cfg_t cal;
7380 memset(&cal, 0, sizeof(acdb_audio_cal_cfg_t));
7381
7382 if (!my_data) {
7383 ret = -EINVAL;
7384 goto ERROR_RETURN;
7385 }
7386
7387 make_cal_cfg(&cal, acdb_dev_id, acdb_device_type, app_type, topology_id,
7388 sample_rate, module_id, param_id, true);
7389
7390 if (my_data->acdb_get_audio_cal) {
7391 ret = my_data->acdb_get_audio_cal((void*)&cal, data, (uint32_t*)length);
7392 }
7393
7394ERROR_RETURN:
7395 return ret;
7396}
Divya Narayanan Poojary45f19192016-09-30 18:52:13 +0530[diff] [blame]7397
7398int platform_get_max_mic_count(void *platform) {
7399 struct platform_data *my_data = (struct platform_data *)platform;
7400 return my_data->max_mic_count;
7401}
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700[diff] [blame]7402
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -0700[diff] [blame]7403#define DEFAULT_NOMINAL_SPEAKER_GAIN 20
7404int ramp_speaker_gain(struct audio_device *adev, bool ramp_up, int target_ramp_up_gain) {
7405 // backup_gain: gain to try to set in case of an error during ramp
7406 int start_gain, end_gain, step, backup_gain, i;
7407 bool error = false;
7408 const char *mixer_ctl_name_gain_left = "Left Speaker Gain";
7409 const char *mixer_ctl_name_gain_right = "Right Speaker Gain";
7410 struct mixer_ctl *ctl_left = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_left);
7411 struct mixer_ctl *ctl_right = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_right);
7412 if (!ctl_left || !ctl_right) {
7413 ALOGE("%s: Could not get ctl for mixer cmd - %s or %s, not applying speaker gain ramp",
7414 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
7415 return -EINVAL;
7416 } else if ((mixer_ctl_get_num_values(ctl_left) != 1)
7417 || (mixer_ctl_get_num_values(ctl_right) != 1)) {
7418 ALOGE("%s: Unexpected num values for mixer cmd - %s or %s, not applying speaker gain ramp",
7419 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
7420 return -EINVAL;
7421 }
7422 if (ramp_up) {
7423 start_gain = 0;
7424 end_gain = target_ramp_up_gain > 0 ? target_ramp_up_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
7425 step = +1;
7426 backup_gain = end_gain;
7427 } else {
7428 // using same gain on left and right
7429 const int left_gain = mixer_ctl_get_value(ctl_left, 0);
7430 start_gain = left_gain > 0 ? left_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
7431 end_gain = 0;
7432 step = -1;
7433 backup_gain = start_gain;
7434 }
7435 for (i = start_gain ; i != (end_gain + step) ; i += step) {
7436 if (mixer_ctl_set_value(ctl_left, 0, i)) {
7437 ALOGE("%s: error setting %s to %d during gain ramp",
7438 __func__, mixer_ctl_name_gain_left, i);
7439 error = true;
7440 break;
7441 }
7442 if (mixer_ctl_set_value(ctl_right, 0, i)) {
7443 ALOGE("%s: error setting %s to %d during gain ramp",
7444 __func__, mixer_ctl_name_gain_right, i);
7445 error = true;
7446 break;
7447 }
7448 usleep(1000);
7449 }
7450 if (error) {
7451 // an error occured during the ramp, let's still try to go back to a safe volume
7452 if (mixer_ctl_set_value(ctl_left, 0, backup_gain)) {
7453 ALOGE("%s: error restoring left gain to %d", __func__, backup_gain);
7454 }
7455 if (mixer_ctl_set_value(ctl_right, 0, backup_gain)) {
7456 ALOGE("%s: error restoring right gain to %d", __func__, backup_gain);
7457 }
7458 }
7459 return start_gain;
7460}
7461
7462int platform_set_swap_mixer(struct audio_device *adev, bool swap_channels)
7463{
7464 const char *mixer_ctl_name = "Swap channel";
7465 struct mixer_ctl *ctl;
7466 const char *mixer_path;
7467 struct platform_data *my_data = (struct platform_data *)adev->platform;
7468
7469 // forced to set to swap, but device not rotated ... ignore set
7470 if (swap_channels && !my_data->speaker_lr_swap)
7471 return 0;
7472
7473 ALOGV("%s:", __func__);
7474
7475 if (swap_channels)
7476 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_REVERSE);
7477 else
7478 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER);
7479
7480 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
7481
7482 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
7483 if (!ctl) {
7484 ALOGE("%s: Could not get ctl for mixer cmd - %s",__func__, mixer_ctl_name);
7485 return -EINVAL;
7486 }
7487
7488 if (mixer_ctl_set_value(ctl, 0, swap_channels) < 0) {
7489 ALOGE("%s: Could not set reverse cotrol %d",__func__, swap_channels);
7490 return -EINVAL;
7491 }
7492
7493 ALOGV("platfor_force_swap_channel :: Channel orientation ( %s ) ",
7494 swap_channels?"R --> L":"L --> R");
7495
7496 return 0;
7497}
7498
7499int platform_check_and_set_swap_lr_channels(struct audio_device *adev, bool swap_channels)
7500{
7501 // only update if there is active pcm playback on speaker
7502 struct platform_data *my_data = (struct platform_data *)adev->platform;
7503
7504 my_data->speaker_lr_swap = swap_channels;
7505
7506 return platform_set_swap_channels(adev, swap_channels);
7507}
7508
7509int platform_set_swap_channels(struct audio_device *adev, bool swap_channels)
7510{
7511 // only update if there is active pcm playback on speaker
7512 struct audio_usecase *usecase;
7513 struct listnode *node;
7514
7515 // do not swap channels in audio modes with concurrent capture and playback
7516 // as this may break the echo reference
7517 if ((adev->mode == AUDIO_MODE_IN_COMMUNICATION) || (adev->mode == AUDIO_MODE_IN_CALL)) {
7518 ALOGV("%s: will not swap due to audio mode %d", __func__, adev->mode);
7519 return 0;
7520 }
7521
7522 list_for_each(node, &adev->usecase_list) {
7523 usecase = node_to_item(node, struct audio_usecase, list);
7524 if (usecase->type == PCM_PLAYBACK &&
7525 usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
7526 /*
7527 * If acdb tuning is different for SPEAKER_REVERSE, it is must
7528 * to perform device switch to disable the current backend to
7529 * enable it with new acdb data.
7530 */
7531 if (acdb_device_table[SND_DEVICE_OUT_SPEAKER] !=
7532 acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE]) {
7533 const int initial_skpr_gain = ramp_speaker_gain(adev, false /*ramp_up*/, -1);
7534 select_devices(adev, usecase->id);
7535 if (initial_skpr_gain != -EINVAL)
7536 ramp_speaker_gain(adev, true /*ramp_up*/, initial_skpr_gain);
7537
7538 } else {
7539 platform_set_swap_mixer(adev, swap_channels);
7540 }
7541 break;
7542 }
7543 }
7544
7545 return 0;
7546}
7547
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700[diff] [blame]7548static struct amp_db_and_gain_table tbl_mapping[MAX_VOLUME_CAL_STEPS];
7549static int num_gain_tbl_entry = 0;
7550
7551bool platform_add_gain_level_mapping(struct amp_db_and_gain_table *tbl_entry) {
7552
7553 ALOGV("%s: enter .. add %f %f %d", __func__, tbl_entry->amp, tbl_entry->db, tbl_entry->level);
7554 if (num_gain_tbl_entry == -1) {
7555 ALOGE("%s: num entry beyond valid step levels or corrupted..rejecting custom mapping",
7556 __func__);
7557 return false;
7558 }
7559
7560 if (num_gain_tbl_entry >= MAX_VOLUME_CAL_STEPS) {
7561 ALOGE("%s: max entry reached max[%d] current index[%d] .. rejecting", __func__,
7562 MAX_VOLUME_CAL_STEPS, num_gain_tbl_entry);
7563 num_gain_tbl_entry = -1; // indicates error and no more info will be cached
7564 return false;
7565 }
7566
7567 if (num_gain_tbl_entry > 0 && tbl_mapping[num_gain_tbl_entry - 1].amp >= tbl_entry->amp) {
7568 ALOGE("%s: value not in ascending order .. rejecting custom mapping", __func__);
7569 num_gain_tbl_entry = -1; // indicates error and no more info will be cached
7570 return false;
7571 }
7572
7573 tbl_mapping[num_gain_tbl_entry] = *tbl_entry;
7574 ++num_gain_tbl_entry;
7575
7576 return true;
7577}
7578
7579int platform_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl,
7580 int table_size) {
7581 int itt = 0;
7582 ALOGV("platform_get_gain_level_mapping called ");
7583
7584 if (num_gain_tbl_entry <= 0 || num_gain_tbl_entry > MAX_VOLUME_CAL_STEPS) {
7585 ALOGD("%s: empty or currupted gain_mapping_table", __func__);
7586 return 0;
7587 }
7588
7589 for (; itt < num_gain_tbl_entry && itt <= table_size; itt++) {
7590 mapping_tbl[itt] = tbl_mapping[itt];
7591 ALOGV("%s: added amp[%f] db[%f] level[%d]", __func__,
7592 mapping_tbl[itt].amp, mapping_tbl[itt].db, mapping_tbl[itt].level);
7593 }
7594
7595 return num_gain_tbl_entry;
7596}
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +0530[diff] [blame]7597
7598int platform_get_max_codec_backend() {
7599
7600 return MAX_CODEC_BACKENDS;
7601}
Venugopal Nadipalli83134582017-09-21 22:34:50 +0530[diff] [blame]7602int platform_get_supported_sampling_rate_on_hdmi(uint32_t stream_sr)
7603{
7604 int sample_rate;
7605 switch (stream_sr){
7606 case 8000:
7607 case 11025:
7608 case 16000:
7609 case 22050:
7610 case 32000:
7611 case 48000:
7612 sample_rate = 48000;
7613 break;
7614 case 44100:
7615 sample_rate = 44100;
7616 break;
7617 case 64000:
7618 case 96000:
7619 sample_rate = 96000;
7620 break;
7621 case 88200:
7622 sample_rate = 88200;
7623 break;
7624 case 176400:
7625 sample_rate = 176400;
7626 break;
7627 case 192000:
7628 sample_rate = 192000;
7629 break;
7630 case 352800:
7631 sample_rate = 352800;
7632 break;
7633 case 384000:
7634 sample_rate = 384000;
7635 break;
7636 case 144000:
7637 default:
7638 sample_rate = 48000;
7639 break;
7640 }
7641 return sample_rate;
7642}
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]7643
Sharad Sangled39232d2017-08-08 20:27:18 +0530[diff] [blame]7644#if defined (PLATFORM_MSM8998) || (PLATFORM_SDM845) || (PLATFORM_SDM670)
Haynes Mathew Georgeef514882017-05-01 17:46:23 -0700[diff] [blame]7645int platform_get_mmap_data_fd(void *platform, int fe_dev, int dir, int *fd,
7646 uint32_t *size)
7647{
7648 struct platform_data *my_data = (struct platform_data *)platform;
7649 struct audio_device *adev = my_data->adev;
7650 int hw_fd = -1;
7651 char dev_name[128];
7652 struct snd_pcm_mmap_fd mmap_fd;
7653 memset(&mmap_fd, 0, sizeof(mmap_fd));
7654 mmap_fd.dir = dir;
7655 snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
7656 adev->snd_card, HWDEP_FE_BASE+fe_dev);
7657 hw_fd = open(dev_name, O_RDONLY);
7658 if (hw_fd < 0) {
7659 ALOGE("fe hw dep node open %d/%d failed", adev->snd_card, fe_dev);
7660 return -1;
7661 }
7662 if (ioctl(hw_fd, SNDRV_PCM_IOCTL_MMAP_DATA_FD, &mmap_fd) < 0) {
7663 ALOGE("fe hw dep node ioctl failed");
7664 close(hw_fd);
7665 return -1;
7666 }
7667 *fd = mmap_fd.fd;
7668 *size = mmap_fd.size;
7669 close(hw_fd); // mmap_fd should still be valid
7670 return 0;
7671}
7672#else
7673int platform_get_mmap_data_fd(void *platform __unused, int fe_dev __unused,
7674 int dir __unused, int *fd __unused,
7675 uint32_t *size __unused)
7676{
7677 return -1;
7678}
7679#endif
`Deeraj Soman676c2702017-09-18 19:25:53 +0530[diff] [blame]7680
7681static const char *platform_get_mixer_control(struct mixer_ctl *ctl)
7682{
7683 int id = -1;
7684 const char *id_string = NULL;
7685
7686 if (!ctl) {
7687 ALOGD("%s: mixer ctl not obtained", __func__);
7688 } else {
7689 id = mixer_ctl_get_value(ctl, 0);
7690 if (id >= 0) {
7691 id_string = mixer_ctl_get_enum_string(ctl, id);
7692 }
7693 }
7694
7695 return id_string;
7696}