Gitiles
Code Review Sign In
review.blissroms.org / platform_hardware_qcom_audio / bdf1416c29231aab5d838f1cf16f92aea1a76830 / . / hal / msm8916 / platform.c
blob: 5e71eb3d33df4450f2945237e52051b260dd9bfc [file] [log] [blame]
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1/*
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2 * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
3 * Not a Contribution.
4 *
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]5 * Copyright (C) 2013 The Android Open Source Project
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
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]20#define LOG_TAG "msm8916_platform"
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]21/*#define LOG_NDEBUG 0*/
22#define LOG_NDDEBUG 0
23
24#include <stdlib.h>
25#include <dlfcn.h>
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]26#include <sys/ioctl.h>
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]27#include <cutils/log.h>
28#include <cutils/properties.h>
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]29#include <cutils/str_parms.h>
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]30#include <audio_hw.h>
31#include <platform_api.h>
32#include "platform.h"
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]33#include "audio_extn.h"
34#include "voice_extn.h"
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]35
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]36#define MIXER_XML_PATH "/system/etc/mixer_paths.xml"
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]37#define MIXER_XML_PATH_MTP "/system/etc/mixer_paths_mtp.xml"
Walter Yang7ca90d92014-05-06 17:48:02 +0800[diff] [blame]38#define MIXER_XML_PATH_QRD_SKUH "/system/etc/mixer_paths_qrd_skuh.xml"
39#define MIXER_XML_PATH_QRD_SKUI "/system/etc/mixer_paths_qrd_skui.xml"
Walter Yang19f244a2014-06-17 13:30:08 +0800[diff] [blame]40#define MIXER_XML_PATH_QRD_SKUHF "/system/etc/mixer_paths_qrd_skuhf.xml"
Meng Wangf00485b2014-06-03 19:44:38 +0800[diff] [blame]41#define MIXER_XML_PATH_SKUK "/system/etc/mixer_paths_skuk.xml"
42#define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml"
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]43#define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml"
Asish Bhattacharyacb8e6d02014-06-19 12:32:25 +0530[diff] [blame]44#define MIXER_XML_PATH_WCD9306 "/system/etc/mixer_paths_wcd9306.xml"
Aviral Gupta8ed0eec2014-08-25 10:22:11 +0530[diff] [blame]45#define MIXER_XML_PATH_WCD9330 "/system/etc/mixer_paths_wcd9330.xml"
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]46#define PLATFORM_INFO_XML_PATH "/system/etc/audio_platform_info.xml"
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]47#define LIB_ACDB_LOADER "libacdbloader.so"
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]48#define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID"
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]49#define CVD_VERSION_MIXER_CTL "CVD Version"
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]50
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]51#define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)
52#define MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024)
53#define COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING (2 * 1024)
54#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
55/* Used in calculating fragment size for pcm offload */
56#define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV 2000 /* 2 secs */
57#define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING 100 /* 100 millisecs */
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]58
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]59/* MAX PCM fragment size cannot be increased further due
60 * to flinger's cblk size of 1mb,and it has to be a multiple of
61 * 24 - lcm of channels supported by DSP
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]62 */
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]63#define MAX_PCM_OFFLOAD_FRAGMENT_SIZE (240 * 1024)
64#define MIN_PCM_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]65
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]66#define ALIGN( num, to ) (((num) + (to-1)) & (~(to-1)))
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]67/*
68 * This file will have a maximum of 38 bytes:
69 *
70 * 4 bytes: number of audio blocks
71 * 4 bytes: total length of Short Audio Descriptor (SAD) blocks
72 * Maximum 10 * 3 bytes: SAD blocks
73 */
74#define MAX_SAD_BLOCKS 10
75#define SAD_BLOCK_SIZE 3
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]76#define MAX_CVD_VERSION_STRING_SIZE 100
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]77
78/* EDID format ID for LPCM audio */
79#define EDID_FORMAT_LPCM 1
80
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]81/* fallback app type if the default app type from acdb loader fails */
82#define DEFAULT_APP_TYPE 0x11130
83
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]84/* Retry for delay in FW loading*/
85#define RETRY_NUMBER 20
86#define RETRY_US 500000
87#define MAX_SND_CARD 8
88
89#define SAMPLE_RATE_8KHZ 8000
90#define SAMPLE_RATE_16KHZ 16000
91
92#define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence"
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]93#define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable"
94#define AUDIO_PARAMETER_KEY_VOLUME_BOOST "volume_boost"
95
96enum {
97 VOICE_FEATURE_SET_DEFAULT,
98 VOICE_FEATURE_SET_VOLUME_BOOST
99};
100
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]101struct audio_block_header
102{
103 int reserved;
104 int length;
105};
106
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]107/* Audio calibration related functions */
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]108typedef void (*acdb_deallocate_t)();
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]109typedef int (*acdb_init_t)(char *, char *);
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]110typedef void (*acdb_send_audio_cal_t)(int, int, int, int);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]111typedef void (*acdb_send_voice_cal_t)(int, int);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]112typedef int (*acdb_reload_vocvoltable_t)(int);
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]113typedef int (*acdb_get_default_app_type_t)(void);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]114
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]115struct platform_data {
116 struct audio_device *adev;
117 bool fluence_in_spkr_mode;
118 bool fluence_in_voice_call;
119 bool fluence_in_voice_rec;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]120 bool fluence_in_audio_rec;
121 int fluence_type;
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]122 char fluence_cap[PROPERTY_VALUE_MAX];
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]123 int fluence_mode;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]124 bool slowtalk;
125 /* Audio calibration related functions */
126 void *acdb_handle;
127 int voice_feature_set;
128 acdb_init_t acdb_init;
129 acdb_deallocate_t acdb_deallocate;
130 acdb_send_audio_cal_t acdb_send_audio_cal;
131 acdb_send_voice_cal_t acdb_send_voice_cal;
132 acdb_reload_vocvoltable_t acdb_reload_vocvoltable;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]133 acdb_get_default_app_type_t acdb_get_default_app_type;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]134
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]135 void *hw_info;
136 struct csd_data *csd;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]137};
138
139static const int pcm_device_table[AUDIO_USECASE_MAX][2] = {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]140 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE,
141 DEEP_BUFFER_PCM_DEVICE},
142 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
143 LOWLATENCY_PCM_DEVICE},
144 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE,
145 MULTIMEDIA2_PCM_DEVICE},
146 [USECASE_AUDIO_PLAYBACK_OFFLOAD] =
147 {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE},
148 [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE},
149 [USECASE_AUDIO_RECORD_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, COMPRESS_CAPTURE_DEVICE},
150 [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
151 LOWLATENCY_PCM_DEVICE},
152 [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE,
153 MULTIMEDIA2_PCM_DEVICE},
154 [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE},
155 [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX},
156 [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX},
157 [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE},
158 [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE},
159 [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE},
160 [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE},
Karthik Reddy Katta3b0a60c2014-04-06 14:52:37 +0530[diff] [blame]161 [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE},
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]162 [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE},
163 [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE,
164 AUDIO_RECORD_PCM_DEVICE},
165 [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
166 AUDIO_RECORD_PCM_DEVICE},
167 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
168 AUDIO_RECORD_PCM_DEVICE},
169 [USECASE_INCALL_REC_UPLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
170 COMPRESS_CAPTURE_DEVICE},
171 [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
172 COMPRESS_CAPTURE_DEVICE},
173 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE,
174 COMPRESS_CAPTURE_DEVICE},
175 [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE,
176 INCALL_MUSIC_UPLINK_PCM_DEVICE},
177 [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE,
178 INCALL_MUSIC_UPLINK2_PCM_DEVICE},
179 [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1},
180 [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE},
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]181};
182
183/* Array to store sound devices */
184static const char * const device_table[SND_DEVICE_MAX] = {
185 [SND_DEVICE_NONE] = "none",
186 /* Playback sound devices */
187 [SND_DEVICE_OUT_HANDSET] = "handset",
188 [SND_DEVICE_OUT_SPEAKER] = "speaker",
189 [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",
190 [SND_DEVICE_OUT_HEADPHONES] = "headphones",
191 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
192 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
193 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
194 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
195 [SND_DEVICE_OUT_HDMI] = "hdmi",
196 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
197 [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]198 [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]199 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
200 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
201 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]202 [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy",
203 [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones",
204 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
205 [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm",
206 [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones",
207 [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones",
208 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones",
209 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones",
210 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones",
211 [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset",
212 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]213
214 /* Capture sound devices */
215 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]216 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]217 [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic",
218 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic",
219 [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire",
220 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire",
221 [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire",
222 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire",
223 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
224 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic",
225 [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic",
226 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic",
227 [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire",
228 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire",
229 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire",
230 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire",
231 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
232 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]233 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
234 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
235 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
236 [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]237 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = "bt-sco-mic",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]238 [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]239 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = "bt-sco-mic-wb",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]240 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]241 [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
242 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
243 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]244 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
245 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
246 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
247 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]248 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic",
249 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef",
250 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
251 [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
252 [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
253 [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
254 [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
255 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef",
256 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef",
257 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback",
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]258 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = "voice-speaker-dmic-broadside",
259 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = "speaker-dmic-broadside",
260 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = "speaker-dmic-broadside",
261 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = "speaker-dmic-broadside",
262 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = "speaker-dmic-broadside",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]263};
264
265/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]266static int acdb_device_table[SND_DEVICE_MAX] = {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]267 [SND_DEVICE_NONE] = -1,
268 [SND_DEVICE_OUT_HANDSET] = 7,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]269 [SND_DEVICE_OUT_SPEAKER] = 14,
270 [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]271 [SND_DEVICE_OUT_HEADPHONES] = 10,
272 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,
273 [SND_DEVICE_OUT_VOICE_HANDSET] = 7,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]274 [SND_DEVICE_OUT_VOICE_SPEAKER] = 14,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]275 [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10,
276 [SND_DEVICE_OUT_HDMI] = 18,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]277 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]278 [SND_DEVICE_OUT_BT_SCO] = 22,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]279 [SND_DEVICE_OUT_BT_SCO_WB] = 39,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]280 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
281 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
282 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]283 [SND_DEVICE_OUT_AFE_PROXY] = 0,
284 [SND_DEVICE_OUT_USB_HEADSET] = 45,
285 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
286 [SND_DEVICE_OUT_TRANSMISSION_FM] = 0,
287 [SND_DEVICE_OUT_ANC_HEADSET] = 26,
288 [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27,
289 [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26,
290 [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27,
291 [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26,
292 [SND_DEVICE_OUT_ANC_HANDSET] = 103,
293 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 101,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]294
295 [SND_DEVICE_IN_HANDSET_MIC] = 4,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]296 [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106,
297 [SND_DEVICE_IN_HANDSET_MIC_NS] = 107,
298 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108,
299 [SND_DEVICE_IN_HANDSET_DMIC] = 41,
300 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109,
301 [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110,
302 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111,
303 [SND_DEVICE_IN_SPEAKER_MIC] = 11,
304 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112,
305 [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113,
306 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114,
307 [SND_DEVICE_IN_SPEAKER_DMIC] = 43,
308 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115,
309 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116,
310 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]311 [SND_DEVICE_IN_HEADSET_MIC] = 8,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]312 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]313 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11,
314 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
315 [SND_DEVICE_IN_HDMI_MIC] = 4,
316 [SND_DEVICE_IN_BT_SCO_MIC] = 21,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]317 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = 122,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]318 [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]319 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = 123,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]320 [SND_DEVICE_IN_CAMCORDER_MIC] = 4,
321 [SND_DEVICE_IN_VOICE_DMIC] = 41,
322 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43,
323 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]324 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16,
325 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
326 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]327 [SND_DEVICE_IN_VOICE_REC_MIC] = 4,
328 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107,
329 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34,
330 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41,
331 [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
332 [SND_DEVICE_IN_CAPTURE_FM] = 0,
333 [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
334 [SND_DEVICE_IN_QUAD_MIC] = 46,
335 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34,
336 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35,
337 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]338 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = 12,
339 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = 12,
340 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = 119,
341 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = 121,
342 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120,
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]343};
344
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]345struct snd_device_index {
346 char name[100];
347 unsigned int index;
348};
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]349
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]350#define TO_NAME_INDEX(X) #X, X
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]351
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]352/* Used to get index from parsed sting */
353struct snd_device_index snd_device_name_index[SND_DEVICE_MAX] = {
354 {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)},
355 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)},
356 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},
357 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},
358 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},
359 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET)},
360 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER)},
361 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HEADPHONES)},
362 {TO_NAME_INDEX(SND_DEVICE_OUT_HDMI)},
363 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
364 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
365 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
366 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
367 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
368 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
369 {TO_NAME_INDEX(SND_DEVICE_OUT_AFE_PROXY)},
370 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)},
371 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)},
372 {TO_NAME_INDEX(SND_DEVICE_OUT_TRANSMISSION_FM)},
373 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HEADSET)},
374 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_FB_HEADSET)},
375 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_HEADSET)},
376 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET)},
377 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET)},
378 {TO_NAME_INDEX(SND_DEVICE_OUT_ANC_HANDSET)},
379 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)},
380 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC)},
381 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC)},
382 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_NS)},
383 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)},
384 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC)},
385 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC)},
386 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_NS)},
387 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)},
388 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC)},
389 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC)},
390 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_NS)},
391 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)},
392 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC)},
393 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC)},
394 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS)},
395 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)},
396 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC)},
397 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_FLUENCE)},
398 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC)},
399 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_HEADSET_MIC)},
400 {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_MIC)},
401 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]402 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_NREC)},
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]403 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB)},
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]404 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)},
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]405 {TO_NAME_INDEX(SND_DEVICE_IN_CAMCORDER_MIC)},
406 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC)},
407 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC)},
408 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_QMIC)},
409 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC)},
410 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC)},
411 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC)},
412 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC)},
413 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_NS)},
414 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)},
415 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)},
416 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)},
417 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_FM)},
418 {TO_NAME_INDEX(SND_DEVICE_IN_AANC_HANDSET_MIC)},
419 {TO_NAME_INDEX(SND_DEVICE_IN_QUAD_MIC)},
420 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_STEREO_DMIC)},
421 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_STEREO_DMIC)},
422 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)},
423};
424
425#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
426#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]427
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]428static void query_platform(const char *snd_card_name,
429 char *mixer_xml_path)
430{
431 if (!strncmp(snd_card_name, "msm8x16-snd-card-mtp",
432 sizeof("msm8x16-snd-card-mtp"))) {
433 strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,
434 sizeof(MIXER_XML_PATH_MTP));
Walter Yang7ca90d92014-05-06 17:48:02 +0800[diff] [blame]435 } else if (!strncmp(snd_card_name, "msm8x16-skuh-snd-card",
436 sizeof("msm8x16-skuh-snd-card"))) {
437 strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUH,
438 sizeof(MIXER_XML_PATH_QRD_SKUH));
439 } else if (!strncmp(snd_card_name, "msm8x16-skui-snd-card",
440 sizeof("msm8x16-skui-snd-card"))) {
441 strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUI,
442 sizeof(MIXER_XML_PATH_QRD_SKUI));
Walter Yang19f244a2014-06-17 13:30:08 +0800[diff] [blame]443 } else if (!strncmp(snd_card_name, "msm8x16-skuhf-snd-card",
444 sizeof("msm8x16-skuhf-snd-card"))) {
445 strlcpy(mixer_xml_path, MIXER_XML_PATH_QRD_SKUHF,
446 sizeof(MIXER_XML_PATH_QRD_SKUHF));
Walter Yangc899d572014-05-27 21:52:17 +0800[diff] [blame]447 } else if (!strncmp(snd_card_name, "msm8939-snd-card-mtp",
Yamit Mehtac6003e22014-05-19 10:26:02 +0530[diff] [blame]448 sizeof("msm8939-snd-card-mtp"))) {
Aravind Kumar71ba22b2014-06-23 15:18:50 +0530[diff] [blame]449 strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,
450 sizeof(MIXER_XML_PATH_MTP));
Meng Wangf00485b2014-06-03 19:44:38 +0800[diff] [blame]451 } else if (!strncmp(snd_card_name, "msm8939-snd-card-skuk",
452 sizeof("msm8939-snd-card-skuk"))) {
453 strlcpy(mixer_xml_path, MIXER_XML_PATH_SKUK,
454 sizeof(MIXER_XML_PATH_SKUK));
Asish Bhattacharyacb8e6d02014-06-19 12:32:25 +0530[diff] [blame]455 } else if (!strncmp(snd_card_name, "msm8939-tapan-snd-card",
456 sizeof("msm8939-tapan-snd-card"))) {
457 strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9306,
458 sizeof(MIXER_XML_PATH_WCD9306));
459 } else if (!strncmp(snd_card_name, "msm8939-tapan9302-snd-card",
460 sizeof("msm8939-tapan9302-snd-card"))) {
461 strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9306,
462 sizeof(MIXER_XML_PATH_WCD9306));
Aviral Gupta8ed0eec2014-08-25 10:22:11 +0530[diff] [blame]463 } else if (!strncmp(snd_card_name, "msm8939-tomtom9330-snd-card",
464 sizeof("msm8939-tomtom9330-snd-card"))) {
465 strlcpy(mixer_xml_path, MIXER_XML_PATH_WCD9330,
466 sizeof(MIXER_XML_PATH_WCD9330));
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]467 } else {
468 strlcpy(mixer_xml_path, MIXER_XML_PATH,
469 sizeof(MIXER_XML_PATH));
470 }
471}
472
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]473static void set_echo_reference(struct audio_device *adev, bool enable)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]474{
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]475 int ret = 0;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]476
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]477 if (enable)
478 ret = audio_route_apply_and_update_path(adev->audio_route, "echo-reference");
479 else
480 ret = audio_route_reset_and_update_path(adev->audio_route, "echo-reference");
481
482 ALOGV("Setting EC Reference: %d ret: %d", enable, ret);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]483}
484
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]485static struct csd_data *open_csd_client()
486{
487 struct csd_data *csd = calloc(1, sizeof(struct csd_data));
488
489 csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW);
490 if (csd->csd_client == NULL) {
491 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT);
492 goto error;
493 } else {
494 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT);
495
496 csd->deinit = (deinit_t)dlsym(csd->csd_client,
497 "csd_client_deinit");
498 if (csd->deinit == NULL) {
499 ALOGE("%s: dlsym error %s for csd_client_deinit", __func__,
500 dlerror());
501 goto error;
502 }
503 csd->disable_device = (disable_device_t)dlsym(csd->csd_client,
504 "csd_client_disable_device");
505 if (csd->disable_device == NULL) {
506 ALOGE("%s: dlsym error %s for csd_client_disable_device",
507 __func__, dlerror());
508 goto error;
509 }
510 csd->enable_device_config = (enable_device_config_t)dlsym(csd->csd_client,
511 "csd_client_enable_device_config");
512 if (csd->enable_device_config == NULL) {
513 ALOGE("%s: dlsym error %s for csd_client_enable_device_config",
514 __func__, dlerror());
515 goto error;
516 }
517 csd->enable_device = (enable_device_t)dlsym(csd->csd_client,
518 "csd_client_enable_device");
519 if (csd->enable_device == NULL) {
520 ALOGE("%s: dlsym error %s for csd_client_enable_device",
521 __func__, dlerror());
522 goto error;
523 }
524 csd->start_voice = (start_voice_t)dlsym(csd->csd_client,
525 "csd_client_start_voice");
526 if (csd->start_voice == NULL) {
527 ALOGE("%s: dlsym error %s for csd_client_start_voice",
528 __func__, dlerror());
529 goto error;
530 }
531 csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client,
532 "csd_client_stop_voice");
533 if (csd->stop_voice == NULL) {
534 ALOGE("%s: dlsym error %s for csd_client_stop_voice",
535 __func__, dlerror());
536 goto error;
537 }
538 csd->volume = (volume_t)dlsym(csd->csd_client,
539 "csd_client_volume");
540 if (csd->volume == NULL) {
541 ALOGE("%s: dlsym error %s for csd_client_volume",
542 __func__, dlerror());
543 goto error;
544 }
545 csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client,
546 "csd_client_mic_mute");
547 if (csd->mic_mute == NULL) {
548 ALOGE("%s: dlsym error %s for csd_client_mic_mute",
549 __func__, dlerror());
550 goto error;
551 }
552 csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client,
553 "csd_client_slow_talk");
554 if (csd->slow_talk == NULL) {
555 ALOGE("%s: dlsym error %s for csd_client_slow_talk",
556 __func__, dlerror());
557 goto error;
558 }
559 csd->start_playback = (start_playback_t)dlsym(csd->csd_client,
560 "csd_client_start_playback");
561 if (csd->start_playback == NULL) {
562 ALOGE("%s: dlsym error %s for csd_client_start_playback",
563 __func__, dlerror());
564 goto error;
565 }
566 csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client,
567 "csd_client_stop_playback");
568 if (csd->stop_playback == NULL) {
569 ALOGE("%s: dlsym error %s for csd_client_stop_playback",
570 __func__, dlerror());
571 goto error;
572 }
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]573 csd->set_lch = (set_lch_t)dlsym(csd->csd_client, "csd_client_set_lch");
574 if (csd->set_lch == NULL) {
575 ALOGE("%s: dlsym error %s for csd_client_set_lch",
576 __func__, dlerror());
577 /* Ignore the error as this is not mandatory function for
578 * basic voice call to work.
579 */
580 }
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]581 csd->start_record = (start_record_t)dlsym(csd->csd_client,
582 "csd_client_start_record");
583 if (csd->start_record == NULL) {
584 ALOGE("%s: dlsym error %s for csd_client_start_record",
585 __func__, dlerror());
586 goto error;
587 }
588 csd->stop_record = (stop_record_t)dlsym(csd->csd_client,
589 "csd_client_stop_record");
590 if (csd->stop_record == NULL) {
591 ALOGE("%s: dlsym error %s for csd_client_stop_record",
592 __func__, dlerror());
593 goto error;
594 }
595 csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init");
596
597 if (csd->init == NULL) {
598 ALOGE("%s: dlsym error %s for csd_client_init",
599 __func__, dlerror());
600 goto error;
601 } else {
602 csd->init();
603 }
604 }
605 return csd;
606
607error:
608 free(csd);
609 csd = NULL;
610 return csd;
611}
612
613void close_csd_client(struct csd_data *csd)
614{
615 if (csd != NULL) {
616 csd->deinit();
617 dlclose(csd->csd_client);
618 free(csd);
619 csd = NULL;
620 }
621}
622
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]623void get_cvd_version(char *cvd_version, struct audio_device *adev)
624{
625 struct mixer_ctl *ctl;
626 int count;
627 int ret = 0;
628
629 ctl = mixer_get_ctl_by_name(adev->mixer, CVD_VERSION_MIXER_CTL);
630 if (!ctl) {
631 ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, CVD_VERSION_MIXER_CTL);
632 goto done;
633 }
634 mixer_ctl_update(ctl);
635
636 count = mixer_ctl_get_num_values(ctl);
637 if (count > MAX_CVD_VERSION_STRING_SIZE)
638 count = MAX_CVD_VERSION_STRING_SIZE;
639
640 ret = mixer_ctl_get_array(ctl, cvd_version, count);
641 if (ret != 0) {
642 ALOGE("%s: ERROR! mixer_ctl_get_array() failed to get CVD Version", __func__);
643 goto done;
644 }
645
646done:
647 return;
648}
649
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]650void *platform_init(struct audio_device *adev)
651{
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]652 char platform[PROPERTY_VALUE_MAX];
653 char baseband[PROPERTY_VALUE_MAX];
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]654 char value[PROPERTY_VALUE_MAX];
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]655 struct platform_data *my_data = NULL;
656 int retry_num = 0, snd_card_num = 0;
657 const char *snd_card_name;
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]658 char mixer_xml_path[100];
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]659 char *cvd_version = NULL;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]660
661 my_data = calloc(1, sizeof(struct platform_data));
662
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]663 while (snd_card_num < MAX_SND_CARD) {
664 adev->mixer = mixer_open(snd_card_num);
665
666 while (!adev->mixer && retry_num < RETRY_NUMBER) {
667 usleep(RETRY_US);
668 adev->mixer = mixer_open(snd_card_num);
669 retry_num++;
670 }
671
672 if (!adev->mixer) {
673 ALOGE("%s: Unable to open the mixer card: %d", __func__,
674 snd_card_num);
675 retry_num = 0;
676 snd_card_num++;
677 continue;
678 }
679
680 snd_card_name = mixer_get_name(adev->mixer);
681 ALOGV("%s: snd_card_name: %s", __func__, snd_card_name);
682
683 my_data->hw_info = hw_info_init(snd_card_name);
684 if (!my_data->hw_info) {
685 ALOGE("%s: Failed to init hardware info", __func__);
686 } else {
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]687 query_platform(snd_card_name, mixer_xml_path);
688 ALOGD("%s: mixer path file is %s", __func__,
689 mixer_xml_path);
690 if (audio_extn_read_xml(adev, snd_card_num, mixer_xml_path,
691 MIXER_XML_PATH_AUXPCM) == -ENOSYS) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]692 adev->audio_route = audio_route_init(snd_card_num,
Asish Bhattacharya4ff24802014-04-24 17:46:54 +0530[diff] [blame]693 mixer_xml_path);
694 }
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]695 if (!adev->audio_route) {
696 ALOGE("%s: Failed to init audio route controls, aborting.",
697 __func__);
698 free(my_data);
699 return NULL;
700 }
701 adev->snd_card = snd_card_num;
702 ALOGD("%s: Opened sound card:%d", __func__, snd_card_num);
703 break;
704 }
705 retry_num = 0;
706 snd_card_num++;
707 }
708
709 if (snd_card_num >= MAX_SND_CARD) {
710 ALOGE("%s: Unable to find correct sound card, aborting.", __func__);
711 free(my_data);
712 return NULL;
713 }
714
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]715 my_data->adev = adev;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]716 my_data->fluence_in_spkr_mode = false;
717 my_data->fluence_in_voice_call = false;
718 my_data->fluence_in_voice_rec = false;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]719 my_data->fluence_in_audio_rec = false;
720 my_data->fluence_type = FLUENCE_NONE;
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]721 my_data->fluence_mode = FLUENCE_ENDFIRE;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]722
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]723 property_get("ro.qc.sdk.audio.fluencetype", my_data->fluence_cap, "");
724 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]725 my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]726 } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]727 my_data->fluence_type = FLUENCE_DUAL_MIC;
728 } else {
729 my_data->fluence_type = FLUENCE_NONE;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]730 }
731
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]732 if (my_data->fluence_type != FLUENCE_NONE) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]733 property_get("persist.audio.fluence.voicecall",value,"");
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]734 if (!strncmp("true", value, sizeof("true"))) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]735 my_data->fluence_in_voice_call = true;
736 }
737
738 property_get("persist.audio.fluence.voicerec",value,"");
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]739 if (!strncmp("true", value, sizeof("true"))) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]740 my_data->fluence_in_voice_rec = true;
741 }
742
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]743 property_get("persist.audio.fluence.audiorec",value,"");
744 if (!strncmp("true", value, sizeof("true"))) {
745 my_data->fluence_in_audio_rec = true;
746 }
747
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]748 property_get("persist.audio.fluence.speaker",value,"");
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]749 if (!strncmp("true", value, sizeof("true"))) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]750 my_data->fluence_in_spkr_mode = true;
751 }
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]752
753 property_get("persist.audio.fluence.mode",value,"");
754 if (!strncmp("broadside", value, sizeof("broadside"))) {
755 my_data->fluence_mode = FLUENCE_BROADSIDE;
756 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]757 }
758
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]759 my_data->voice_feature_set = VOICE_FEATURE_SET_DEFAULT;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]760 my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
761 if (my_data->acdb_handle == NULL) {
762 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER);
763 } else {
764 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);
765 my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle,
766 "acdb_loader_deallocate_ACDB");
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]767 if (!my_data->acdb_deallocate)
768 ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s",
769 __func__, LIB_ACDB_LOADER);
770
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]771 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]772 "acdb_loader_send_audio_cal_v2");
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]773 if (!my_data->acdb_send_audio_cal)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]774 ALOGE("%s: Could not find the symbol acdb_send_audio_cal from %s",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]775 __func__, LIB_ACDB_LOADER);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]776
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]777 my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle,
778 "acdb_loader_send_voice_cal");
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]779 if (!my_data->acdb_send_voice_cal)
780 ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s",
781 __func__, LIB_ACDB_LOADER);
782
783 my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle,
784 "acdb_loader_reload_vocvoltable");
785 if (!my_data->acdb_reload_vocvoltable)
786 ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s",
787 __func__, LIB_ACDB_LOADER);
788
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]789 my_data->acdb_get_default_app_type = (acdb_get_default_app_type_t)dlsym(
790 my_data->acdb_handle,
791 "acdb_loader_get_default_app_type");
792 if (!my_data->acdb_get_default_app_type)
793 ALOGE("%s: Could not find the symbol acdb_get_default_app_type from %s",
794 __func__, LIB_ACDB_LOADER);
795
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]796 my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle,
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]797 "acdb_loader_init_v2");
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]798 if (my_data->acdb_init == NULL) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]799 ALOGE("%s: dlsym error %s for acdb_loader_init_v2", __func__, dlerror());
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]800 goto acdb_init_fail;
801 }
802
803 cvd_version = calloc(1, MAX_CVD_VERSION_STRING_SIZE);
804 if (!cvd_version)
805 ALOGE("Failed to allocate cvd version");
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]806 else
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]807 get_cvd_version(cvd_version, adev);
808
809 my_data->acdb_init(snd_card_name, cvd_version);
810 if (cvd_version)
811 free(cvd_version);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]812 }
813
Avinash Vaish71c066d2014-08-27 12:32:35 +0530[diff] [blame]814acdb_init_fail:
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]815 /* Initialize ACDB ID's */
816 platform_info_init(PLATFORM_INFO_XML_PATH);
817
818 /* init usb */
819 audio_extn_usb_init(adev);
820 /* update sound cards appropriately */
821 audio_extn_usb_set_proxy_sound_card(adev->snd_card);
822
823 /* Read one time ssr property */
824 audio_extn_ssr_update_enabled();
825 audio_extn_spkr_prot_init(adev);
Dhananjay Kumar89ea3bd2014-04-29 15:45:57 +0530[diff] [blame]826
827 audio_extn_dolby_set_license(adev);
828
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]829 return my_data;
830}
831
832void platform_deinit(void *platform)
833{
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]834 struct platform_data *my_data = (struct platform_data *)platform;
835
836 hw_info_deinit(my_data->hw_info);
837 close_csd_client(my_data->csd);
838
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]839 free(platform);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]840 /* deinit usb */
841 audio_extn_usb_deinit();
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]842}
843
844const char *platform_get_snd_device_name(snd_device_t snd_device)
845{
846 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX)
847 return device_table[snd_device];
848 else
849 return "";
850}
851
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]852int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
853 char *device_name)
854{
855 struct platform_data *my_data = (struct platform_data *)platform;
856
857 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
858 strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
859 hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
860 } else {
861 strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE);
862 return -EINVAL;
863 }
864
865 return 0;
866}
867
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]868void platform_add_backend_name(char *mixer_path, snd_device_t snd_device)
869{
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]870 if ((snd_device == SND_DEVICE_IN_BT_SCO_MIC) ||
871 (snd_device == SND_DEVICE_IN_BT_SCO_MIC_NREC))
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]872 strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]873 else if ((snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB) ||
874 (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB_NREC))
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]875 strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]876 else if(snd_device == SND_DEVICE_OUT_BT_SCO)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]877 strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);
878 else if(snd_device == SND_DEVICE_OUT_BT_SCO_WB)
879 strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]880 else if (snd_device == SND_DEVICE_OUT_HDMI)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]881 strlcat(mixer_path, " hdmi", MIXER_PATH_MAX_LENGTH);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]882 else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]883 strlcat(mixer_path, " speaker-and-hdmi", MIXER_PATH_MAX_LENGTH);
884 else if (snd_device == SND_DEVICE_OUT_AFE_PROXY)
885 strlcat(mixer_path, " afe-proxy", MIXER_PATH_MAX_LENGTH);
886 else if (snd_device == SND_DEVICE_OUT_USB_HEADSET)
887 strlcat(mixer_path, " usb-headphones", MIXER_PATH_MAX_LENGTH);
888 else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)
889 strlcat(mixer_path, " speaker-and-usb-headphones",
890 MIXER_PATH_MAX_LENGTH);
891 else if (snd_device == SND_DEVICE_IN_USB_HEADSET_MIC)
892 strlcat(mixer_path, " usb-headset-mic", MIXER_PATH_MAX_LENGTH);
893 else if (snd_device == SND_DEVICE_IN_CAPTURE_FM)
894 strlcat(mixer_path, " capture-fm", MIXER_PATH_MAX_LENGTH);
895 else if (snd_device == SND_DEVICE_OUT_TRANSMISSION_FM)
896 strlcat(mixer_path, " transmission-fm", MIXER_PATH_MAX_LENGTH);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]897}
898
899int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
900{
901 int device_id;
902 if (device_type == PCM_PLAYBACK)
903 device_id = pcm_device_table[usecase][0];
904 else
905 device_id = pcm_device_table[usecase][1];
906 return device_id;
907}
908
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]909int platform_get_snd_device_index(char *snd_device_index_name)
910{
911 int ret = 0;
912 int i;
913
914 if (snd_device_index_name == NULL) {
915 ALOGE("%s: snd_device_index_name is NULL", __func__);
916 ret = -ENODEV;
917 goto done;
918 }
919
920 for (i=0; i < SND_DEVICE_MAX; i++) {
921 if(strcmp(snd_device_name_index[i].name, snd_device_index_name) == 0) {
922 ret = snd_device_name_index[i].index;
923 goto done;
924 }
925 }
926 ALOGE("%s: Could not find index for snd_device_index_name = %s",
927 __func__, snd_device_index_name);
928 ret = -ENODEV;
929done:
930 return ret;
931}
932
Venkata Narendra Kumar Gutta88fd0bc2014-03-27 19:47:56 +0530[diff] [blame]933int platform_set_fluence_type(void *platform, char *value)
934{
935 int ret = 0;
936 int fluence_type = FLUENCE_NONE;
937 int fluence_flag = NONE_FLAG;
938 struct platform_data *my_data = (struct platform_data *)platform;
939 struct audio_device *adev = my_data->adev;
940
941 ALOGV("%s: fluence type:%d", __func__, my_data->fluence_type);
942
943 /* only dual mic turn on and off is supported as of now through setparameters */
944 if (!strncmp(AUDIO_PARAMETER_VALUE_DUALMIC,value, sizeof(AUDIO_PARAMETER_VALUE_DUALMIC))) {
945 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro")) ||
946 !strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
947 ALOGV("fluence dualmic feature enabled \n");
948 fluence_type = FLUENCE_DUAL_MIC;
949 fluence_flag = DMIC_FLAG;
950 } else {
951 ALOGE("%s: Failed to set DUALMIC", __func__);
952 ret = -1;
953 goto done;
954 }
955 } else if (!strncmp(AUDIO_PARAMETER_KEY_NO_FLUENCE, value, sizeof(AUDIO_PARAMETER_KEY_NO_FLUENCE))) {
956 ALOGV("fluence disabled");
957 fluence_type = FLUENCE_NONE;
958 } else {
959 ALOGE("Invalid fluence value : %s",value);
960 ret = -1;
961 goto done;
962 }
963
964 if (fluence_type != my_data->fluence_type) {
965 ALOGV("%s: Updating fluence_type to :%d", __func__, fluence_type);
966 my_data->fluence_type = fluence_type;
967 adev->acdb_settings = (adev->acdb_settings & FLUENCE_MODE_CLEAR) | fluence_flag;
968 }
969done:
970 return ret;
971}
972
973int platform_get_fluence_type(void *platform, char *value, uint32_t len)
974{
975 int ret = 0;
976 struct platform_data *my_data = (struct platform_data *)platform;
977
978 if (my_data->fluence_type == FLUENCE_QUAD_MIC) {
979 strlcpy(value, "quadmic", len);
980 } else if (my_data->fluence_type == FLUENCE_DUAL_MIC) {
981 strlcpy(value, "dualmic", len);
982 } else if (my_data->fluence_type == FLUENCE_NONE) {
983 strlcpy(value, "none", len);
984 } else
985 ret = -1;
986
987 return ret;
988}
989
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]990int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)
991{
992 int ret = 0;
993
994 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
995 ALOGE("%s: Invalid snd_device = %d",
996 __func__, snd_device);
997 ret = -EINVAL;
998 goto done;
999 }
1000
1001 acdb_device_table[snd_device] = acdb_id;
1002done:
1003 return ret;
1004}
1005
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]1006int platform_get_default_app_type(void *platform)
1007{
1008 struct platform_data *my_data = (struct platform_data *)platform;
1009
1010 if (my_data->acdb_get_default_app_type)
1011 return my_data->acdb_get_default_app_type();
1012 else
1013 return DEFAULT_APP_TYPE;
1014}
1015
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -0700[diff] [blame]1016int platform_get_snd_device_acdb_id(snd_device_t snd_device)
1017{
1018 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
1019 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
1020 return -EINVAL;
1021 }
1022 return acdb_device_table[snd_device];
1023}
1024
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]1025int platform_send_audio_calibration(void *platform, snd_device_t snd_device,
1026 int app_type, int sample_rate)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1027{
1028 struct platform_data *my_data = (struct platform_data *)platform;
1029 int acdb_dev_id, acdb_dev_type;
1030
1031 acdb_dev_id = acdb_device_table[snd_device];
1032 if (acdb_dev_id < 0) {
1033 ALOGE("%s: Could not find acdb id for device(%d)",
1034 __func__, snd_device);
1035 return -EINVAL;
1036 }
1037 if (my_data->acdb_send_audio_cal) {
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]1038 ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1039 __func__, snd_device, acdb_dev_id);
1040 if (snd_device >= SND_DEVICE_OUT_BEGIN &&
1041 snd_device < SND_DEVICE_OUT_END)
1042 acdb_dev_type = ACDB_DEV_TYPE_OUT;
1043 else
1044 acdb_dev_type = ACDB_DEV_TYPE_IN;
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -0700[diff] [blame]1045 my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type, app_type,
1046 sample_rate);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1047 }
1048 return 0;
1049}
1050
1051int platform_switch_voice_call_device_pre(void *platform)
1052{
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1053 struct platform_data *my_data = (struct platform_data *)platform;
1054 int ret = 0;
1055
1056 if (my_data->csd != NULL &&
1057 my_data->adev->mode == AUDIO_MODE_IN_CALL) {
1058 /* This must be called before disabling mixer controls on APQ side */
1059 ret = my_data->csd->disable_device();
1060 if (ret < 0) {
1061 ALOGE("%s: csd_client_disable_device, failed, error %d",
1062 __func__, ret);
1063 }
1064 }
1065 return ret;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1066}
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1067int platform_switch_voice_call_enable_device_config(void *platform,
1068 snd_device_t out_snd_device,
1069 snd_device_t in_snd_device)
1070{
1071 struct platform_data *my_data = (struct platform_data *)platform;
1072 int acdb_rx_id, acdb_tx_id;
1073 int ret = 0;
1074
1075 acdb_rx_id = acdb_device_table[out_snd_device];
1076 acdb_tx_id = acdb_device_table[in_snd_device];
1077
1078 if (my_data->csd != NULL) {
1079 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
1080 ret = my_data->csd->enable_device_config(acdb_rx_id, acdb_tx_id);
1081 if (ret < 0) {
1082 ALOGE("%s: csd_enable_device_config, failed, error %d",
1083 __func__, ret);
1084 }
1085 } else {
1086 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
1087 acdb_rx_id, acdb_tx_id);
1088 }
1089 }
1090 return ret;
1091}
1092
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1093
1094int platform_switch_voice_call_device_post(void *platform,
1095 snd_device_t out_snd_device,
1096 snd_device_t in_snd_device)
1097{
1098 struct platform_data *my_data = (struct platform_data *)platform;
1099 int acdb_rx_id, acdb_tx_id;
1100
1101 if (my_data->acdb_send_voice_cal == NULL) {
1102 ALOGE("%s: dlsym error for acdb_send_voice_call", __func__);
1103 } else {
1104 acdb_rx_id = acdb_device_table[out_snd_device];
1105 acdb_tx_id = acdb_device_table[in_snd_device];
1106
1107 if (acdb_rx_id > 0 && acdb_tx_id > 0)
1108 my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id);
1109 else
1110 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
1111 acdb_rx_id, acdb_tx_id);
1112 }
1113
1114 return 0;
1115}
1116
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1117int platform_switch_voice_call_usecase_route_post(void *platform,
1118 snd_device_t out_snd_device,
1119 snd_device_t in_snd_device)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1120{
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1121 struct platform_data *my_data = (struct platform_data *)platform;
1122 int acdb_rx_id, acdb_tx_id;
1123 int ret = 0;
1124
1125 acdb_rx_id = acdb_device_table[out_snd_device];
1126 acdb_tx_id = acdb_device_table[in_snd_device];
1127
1128 if (my_data->csd != NULL) {
1129 if (acdb_rx_id > 0 && acdb_tx_id > 0) {
1130 ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id,
1131 my_data->adev->acdb_settings);
1132 if (ret < 0) {
1133 ALOGE("%s: csd_enable_device, failed, error %d",
1134 __func__, ret);
1135 }
1136 } else {
1137 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
1138 acdb_rx_id, acdb_tx_id);
1139 }
1140 }
1141 return ret;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1142}
1143
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1144int platform_start_voice_call(void *platform, uint32_t vsid)
1145{
1146 struct platform_data *my_data = (struct platform_data *)platform;
1147 int ret = 0;
1148
1149 if (my_data->csd != NULL) {
1150 ret = my_data->csd->start_voice(vsid);
1151 if (ret < 0) {
1152 ALOGE("%s: csd_start_voice error %d\n", __func__, ret);
1153 }
1154 }
1155 return ret;
1156}
1157
1158int platform_stop_voice_call(void *platform, uint32_t vsid)
1159{
1160 struct platform_data *my_data = (struct platform_data *)platform;
1161 int ret = 0;
1162
1163 if (my_data->csd != NULL) {
1164 ret = my_data->csd->stop_voice(vsid);
1165 if (ret < 0) {
1166 ALOGE("%s: csd_stop_voice error %d\n", __func__, ret);
1167 }
1168 }
1169 return ret;
1170}
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame^]1171
1172int platform_get_sample_rate(void *platform __unused, uint32_t *rate __unused)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1173{
1174 return 0;
1175}
1176
1177int platform_set_voice_volume(void *platform, int volume)
1178{
1179 struct platform_data *my_data = (struct platform_data *)platform;
1180 struct audio_device *adev = my_data->adev;
1181 struct mixer_ctl *ctl;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1182 const char *mixer_ctl_name = "Voice Rx Gain";
1183 int vol_index = 0, ret = 0;
1184 uint32_t set_values[ ] = {0,
1185 ALL_SESSION_VSID,
1186 DEFAULT_VOLUME_RAMP_DURATION_MS};
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1187
1188 // Voice volume levels are mapped to adsp volume levels as follows.
1189 // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0
1190 // But this values don't changed in kernel. So, below change is need.
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1191 vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX);
1192 set_values[0] = vol_index;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1193
1194 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1195 if (!ctl) {
1196 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1197 __func__, mixer_ctl_name);
1198 return -EINVAL;
1199 }
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1200 ALOGV("Setting voice volume index: %d", set_values[0]);
1201 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1202
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1203 if (my_data->csd != NULL) {
1204 ret = my_data->csd->volume(ALL_SESSION_VSID, volume);
1205 if (ret < 0) {
1206 ALOGE("%s: csd_volume error %d", __func__, ret);
1207 }
1208 }
1209 return ret;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1210}
1211
1212int platform_set_mic_mute(void *platform, bool state)
1213{
1214 struct platform_data *my_data = (struct platform_data *)platform;
1215 struct audio_device *adev = my_data->adev;
1216 struct mixer_ctl *ctl;
1217 const char *mixer_ctl_name = "Voice Tx Mute";
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1218 int ret = 0;
1219 uint32_t set_values[ ] = {0,
1220 ALL_SESSION_VSID,
1221 DEFAULT_VOLUME_RAMP_DURATION_MS};
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1222
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1223 set_values[0] = state;
1224 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1225 if (!ctl) {
1226 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1227 __func__, mixer_ctl_name);
1228 return -EINVAL;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1229 }
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1230 ALOGV("Setting voice mute state: %d", state);
1231 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1232
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1233 if (my_data->csd != NULL) {
1234 ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state);
1235 if (ret < 0) {
1236 ALOGE("%s: csd_mic_mute error %d", __func__, ret);
1237 }
1238 }
1239 return ret;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1240}
1241
Shiv Maliyappanahallic6fd8ee2014-03-07 15:31:55 -0800[diff] [blame]1242int platform_set_device_mute(void *platform, bool state, char *dir)
1243{
1244 struct platform_data *my_data = (struct platform_data *)platform;
1245 struct audio_device *adev = my_data->adev;
1246 struct mixer_ctl *ctl;
1247 char *mixer_ctl_name = NULL;
1248 int ret = 0;
1249 uint32_t set_values[ ] = {0,
1250 ALL_SESSION_VSID,
1251 0};
1252 if(dir == NULL) {
1253 ALOGE("%s: Invalid direction:%s", __func__, dir);
1254 return -EINVAL;
1255 }
1256
1257 if (!strncmp("rx", dir, sizeof("rx"))) {
1258 mixer_ctl_name = "Voice Rx Device Mute";
1259 } else if (!strncmp("tx", dir, sizeof("tx"))) {
1260 mixer_ctl_name = "Voice Tx Device Mute";
1261 } else {
1262 return -EINVAL;
1263 }
1264
1265 set_values[0] = state;
1266 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1267 if (!ctl) {
1268 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1269 __func__, mixer_ctl_name);
1270 return -EINVAL;
1271 }
1272
1273 ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s",
1274 __func__,state, mixer_ctl_name);
1275 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
1276
1277 return ret;
1278}
1279
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1280snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices)
1281{
1282 struct platform_data *my_data = (struct platform_data *)platform;
1283 struct audio_device *adev = my_data->adev;
1284 audio_mode_t mode = adev->mode;
1285 snd_device_t snd_device = SND_DEVICE_NONE;
1286
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1287 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
1288 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
1289 int channel_count = popcount(channel_mask);
1290
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1291 ALOGV("%s: enter: output devices(%#x)", __func__, devices);
1292 if (devices == AUDIO_DEVICE_NONE ||
1293 devices & AUDIO_DEVICE_BIT_IN) {
1294 ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
1295 goto exit;
1296 }
1297
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1298 if (popcount(devices) == 2) {
1299 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
1300 AUDIO_DEVICE_OUT_SPEAKER)) {
1301 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
1302 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
1303 AUDIO_DEVICE_OUT_SPEAKER)) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1304 if (audio_extn_get_anc_enabled())
1305 snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET;
1306 else
1307 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1308 } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL |
1309 AUDIO_DEVICE_OUT_SPEAKER)) {
1310 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1311 } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
1312 AUDIO_DEVICE_OUT_SPEAKER)) {
1313 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1314 } else {
1315 ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
1316 goto exit;
1317 }
1318 if (snd_device != SND_DEVICE_NONE) {
1319 goto exit;
1320 }
1321 }
1322
1323 if (popcount(devices) != 1) {
1324 ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
1325 goto exit;
1326 }
1327
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1328 if ((mode == AUDIO_MODE_IN_CALL) ||
1329 voice_extn_compress_voip_is_active(adev)) {
1330 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1331 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1332 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
1333 !voice_extn_compress_voip_is_active(adev)) {
1334 switch (adev->voice.tty_mode) {
1335 case TTY_MODE_FULL:
1336 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
1337 break;
1338 case TTY_MODE_VCO:
1339 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
1340 break;
1341 case TTY_MODE_HCO:
1342 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
1343 break;
1344 default:
1345 ALOGE("%s: Invalid TTY mode (%#x)",
1346 __func__, adev->voice.tty_mode);
1347 }
1348 } else if (audio_extn_get_anc_enabled()) {
1349 if (audio_extn_should_use_fb_anc())
1350 snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET;
1351 else
1352 snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET;
1353 } else {
1354 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
1355 }
1356 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]1357 if (adev->bt_wb_speech_enabled)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1358 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
1359 else
1360 snd_device = SND_DEVICE_OUT_BT_SCO;
1361 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
1362 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
1363 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1364 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
1365 snd_device = SND_DEVICE_OUT_USB_HEADSET;
1366 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
1367 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
1368 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
1369 if (audio_extn_should_use_handset_anc(channel_count))
1370 snd_device = SND_DEVICE_OUT_ANC_HANDSET;
1371 else
1372 snd_device = SND_DEVICE_OUT_VOICE_HANDSET;
1373 }
1374 if (snd_device != SND_DEVICE_NONE) {
1375 goto exit;
1376 }
1377 }
1378
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1379 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1380 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1381 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET
1382 && audio_extn_get_anc_enabled()) {
1383 if (audio_extn_should_use_fb_anc())
1384 snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET;
1385 else
1386 snd_device = SND_DEVICE_OUT_ANC_HEADSET;
1387 }
1388 else
1389 snd_device = SND_DEVICE_OUT_HEADPHONES;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1390 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
1391 if (adev->speaker_lr_swap)
1392 snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE;
1393 else
1394 snd_device = SND_DEVICE_OUT_SPEAKER;
1395 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
Mingming Yin514a8bc2014-07-29 15:22:21 -0700[diff] [blame]1396 if (adev->bt_wb_speech_enabled)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1397 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
1398 else
1399 snd_device = SND_DEVICE_OUT_BT_SCO;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1400 } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1401 snd_device = SND_DEVICE_OUT_HDMI ;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1402 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1403 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]1404 ALOGD("%s: setting USB hadset channel capability(2) for Proxy", __func__);
1405 audio_extn_set_afe_proxy_channel_mixer(adev, 2);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1406 snd_device = SND_DEVICE_OUT_USB_HEADSET;
1407 } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
1408 snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1409 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
1410 snd_device = SND_DEVICE_OUT_HANDSET;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1411 } else if (devices & AUDIO_DEVICE_OUT_PROXY) {
Mingming Yin5a7c5d62014-03-05 17:45:03 -0800[diff] [blame]1412 channel_count = audio_extn_get_afe_proxy_channel_count();
1413 ALOGD("%s: setting sink capability(%d) for Proxy", __func__, channel_count);
1414 audio_extn_set_afe_proxy_channel_mixer(adev, channel_count);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1415 snd_device = SND_DEVICE_OUT_AFE_PROXY;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1416 } else {
1417 ALOGE("%s: Unknown device(s) %#x", __func__, devices);
1418 }
1419exit:
1420 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
1421 return snd_device;
1422}
1423
1424snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
1425{
1426 struct platform_data *my_data = (struct platform_data *)platform;
1427 struct audio_device *adev = my_data->adev;
1428 audio_source_t source = (adev->active_input == NULL) ?
1429 AUDIO_SOURCE_DEFAULT : adev->active_input->source;
1430
1431 audio_mode_t mode = adev->mode;
1432 audio_devices_t in_device = ((adev->active_input == NULL) ?
1433 AUDIO_DEVICE_NONE : adev->active_input->device)
1434 & ~AUDIO_DEVICE_BIT_IN;
1435 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
1436 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
1437 snd_device_t snd_device = SND_DEVICE_NONE;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1438 int channel_count = popcount(channel_mask);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1439
1440 ALOGV("%s: enter: out_device(%#x) in_device(%#x)",
1441 __func__, out_device, in_device);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1442 if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) ||
Satya Krishna Pindiproli2aaa6152014-05-21 15:05:22 +0530[diff] [blame]1443 voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1444 if ((adev->voice.tty_mode != TTY_MODE_OFF) &&
1445 !voice_extn_compress_voip_is_active(adev)) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1446 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1447 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1448 switch (adev->voice.tty_mode) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1449 case TTY_MODE_FULL:
1450 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
1451 break;
1452 case TTY_MODE_VCO:
1453 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
1454 break;
1455 case TTY_MODE_HCO:
1456 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
1457 break;
1458 default:
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1459 ALOGE("%s: Invalid TTY mode (%#x)",
1460 __func__, adev->voice.tty_mode);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1461 }
1462 goto exit;
1463 }
1464 }
1465 if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
1466 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1467 if (out_device & AUDIO_DEVICE_OUT_EARPIECE &&
1468 audio_extn_should_use_handset_anc(channel_count)) {
1469 snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC;
1470 } else if (my_data->fluence_type == FLUENCE_NONE ||
1471 my_data->fluence_in_voice_call == false) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1472 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1473 set_echo_reference(adev, true);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1474 } else {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1475 snd_device = SND_DEVICE_IN_VOICE_DMIC;
1476 adev->acdb_settings |= DMIC_FLAG;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1477 }
1478 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1479 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1480 set_echo_reference(adev, true);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1481 } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]1482 if (adev->bt_wb_speech_enabled) {
1483 if (adev->bluetooth_nrec)
1484 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1485 else
1486 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1487 } else {
1488 if (adev->bluetooth_nrec)
1489 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1490 else
1491 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1492 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1493 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1494 if (my_data->fluence_type != FLUENCE_NONE &&
1495 my_data->fluence_in_voice_call &&
1496 my_data->fluence_in_spkr_mode) {
1497 if(my_data->fluence_type & FLUENCE_QUAD_MIC) {
1498 adev->acdb_settings |= QMIC_FLAG;
1499 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC;
1500 } else {
1501 adev->acdb_settings |= DMIC_FLAG;
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]1502 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1503 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE;
1504 else
1505 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1506 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1507 } else {
1508 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1509 set_echo_reference(adev, true);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1510 }
1511 }
1512 } else if (source == AUDIO_SOURCE_CAMCORDER) {
1513 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
1514 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
kunleiz18a33302014-05-30 09:52:25 +0800[diff] [blame]1515 if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
1516 channel_count == 2)
kunleiz8f7e9e22014-06-24 15:12:02 +0800[diff] [blame]1517 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
kunleiz18a33302014-05-30 09:52:25 +0800[diff] [blame]1518 else
1519 snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1520 }
1521 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1522 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1523 if (channel_count == 2) {
1524 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
1525 adev->acdb_settings |= DMIC_FLAG;
1526 } else if (adev->active_input->enable_ns)
1527 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
1528 else if (my_data->fluence_type != FLUENCE_NONE &&
1529 my_data->fluence_in_voice_rec) {
1530 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
1531 adev->acdb_settings |= DMIC_FLAG;
1532 } else {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1533 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
1534 }
1535 }
1536 } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
1537 if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
1538 in_device = AUDIO_DEVICE_IN_BACK_MIC;
1539 if (adev->active_input) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1540 if (adev->active_input->enable_aec &&
1541 adev->active_input->enable_ns) {
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1542 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1543 if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
1544 my_data->fluence_in_spkr_mode) {
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]1545 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1546 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
1547 else
1548 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1549 adev->acdb_settings |= DMIC_FLAG;
1550 } else
1551 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1552 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1553 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1554 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
1555 adev->acdb_settings |= DMIC_FLAG;
1556 } else
1557 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1558 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1559 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1560 }
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1561 set_echo_reference(adev, true);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1562 } else if (adev->active_input->enable_aec) {
1563 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]1564 if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
1565 my_data->fluence_in_spkr_mode) {
1566 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1567 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE;
1568 else
1569 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1570 adev->acdb_settings |= DMIC_FLAG;
1571 } else
1572 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
1573 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1574 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1575 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
1576 adev->acdb_settings |= DMIC_FLAG;
1577 } else
1578 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
1579 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1580 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
1581 }
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1582 set_echo_reference(adev, true);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1583 } else if (adev->active_input->enable_ns) {
1584 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
Karthik Reddy Kattad9fff862014-07-21 21:07:21 +0530[diff] [blame]1585 if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
1586 my_data->fluence_in_spkr_mode) {
1587 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1588 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE;
1589 else
1590 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1591 adev->acdb_settings |= DMIC_FLAG;
1592 } else
1593 snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
1594 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1595 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1596 snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
1597 adev->acdb_settings |= DMIC_FLAG;
1598 } else
1599 snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
1600 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1601 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
1602 }
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1603 set_echo_reference(adev, false);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1604 } else
Venkata Narendra Kumar Gutta3fa54c72014-08-18 18:02:21 +0530[diff] [blame]1605 set_echo_reference(adev, false);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1606 }
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1607 } else if (source == AUDIO_SOURCE_MIC) {
1608 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC &&
1609 channel_count == 1 ) {
1610 if(my_data->fluence_type & FLUENCE_DUAL_MIC &&
1611 my_data->fluence_in_audio_rec)
1612 snd_device = SND_DEVICE_IN_HANDSET_DMIC;
1613 }
1614 } else if (source == AUDIO_SOURCE_FM_RX ||
1615 source == AUDIO_SOURCE_FM_RX_A2DP) {
1616 snd_device = SND_DEVICE_IN_CAPTURE_FM;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1617 } else if (source == AUDIO_SOURCE_DEFAULT) {
1618 goto exit;
1619 }
1620
1621
1622 if (snd_device != SND_DEVICE_NONE) {
1623 goto exit;
1624 }
1625
1626 if (in_device != AUDIO_DEVICE_NONE &&
1627 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
1628 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
1629 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1630 if (audio_extn_ssr_get_enabled() && channel_count == 6)
1631 snd_device = SND_DEVICE_IN_QUAD_MIC;
1632 else if (channel_count == 2)
1633 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
1634 else
1635 snd_device = SND_DEVICE_IN_HANDSET_MIC;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1636 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1637 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
1638 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1639 snd_device = SND_DEVICE_IN_HEADSET_MIC;
1640 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]1641 if (adev->bt_wb_speech_enabled) {
1642 if (adev->bluetooth_nrec)
1643 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1644 else
1645 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1646 } else {
1647 if (adev->bluetooth_nrec)
1648 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1649 else
1650 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1651 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1652 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
1653 snd_device = SND_DEVICE_IN_HDMI_MIC;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1654 } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
1655 in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
1656 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
1657 } else if (in_device & AUDIO_DEVICE_IN_FM_RX) {
1658 snd_device = SND_DEVICE_IN_CAPTURE_FM;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1659 } else {
1660 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
1661 ALOGW("%s: Using default handset-mic", __func__);
1662 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1663 }
1664 } else {
1665 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
1666 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1667 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1668 snd_device = SND_DEVICE_IN_HEADSET_MIC;
1669 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1670 if (channel_count > 1)
1671 snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC;
1672 else
1673 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1674 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
1675 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1676 } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -0700[diff] [blame]1677 if (adev->bt_wb_speech_enabled) {
1678 if (adev->bluetooth_nrec)
1679 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1680 else
1681 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1682 } else {
1683 if (adev->bluetooth_nrec)
1684 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1685 else
1686 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1687 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1688 } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1689 snd_device = SND_DEVICE_IN_HDMI_MIC;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1690 } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1691 out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
1692 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1693 } else {
1694 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
1695 ALOGW("%s: Using default handset-mic", __func__);
1696 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1697 }
1698 }
1699exit:
1700 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
1701 return snd_device;
1702}
1703
1704int platform_set_hdmi_channels(void *platform, int channel_count)
1705{
1706 struct platform_data *my_data = (struct platform_data *)platform;
1707 struct audio_device *adev = my_data->adev;
1708 struct mixer_ctl *ctl;
1709 const char *channel_cnt_str = NULL;
1710 const char *mixer_ctl_name = "HDMI_RX Channels";
1711 switch (channel_count) {
1712 case 8:
1713 channel_cnt_str = "Eight"; break;
1714 case 7:
1715 channel_cnt_str = "Seven"; break;
1716 case 6:
1717 channel_cnt_str = "Six"; break;
1718 case 5:
1719 channel_cnt_str = "Five"; break;
1720 case 4:
1721 channel_cnt_str = "Four"; break;
1722 case 3:
1723 channel_cnt_str = "Three"; break;
1724 default:
1725 channel_cnt_str = "Two"; break;
1726 }
1727 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1728 if (!ctl) {
1729 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1730 __func__, mixer_ctl_name);
1731 return -EINVAL;
1732 }
1733 ALOGV("HDMI channel count: %s", channel_cnt_str);
1734 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
1735 return 0;
1736}
1737
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1738int platform_edid_get_max_channels(void *platform)
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1739{
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1740 struct platform_data *my_data = (struct platform_data *)platform;
1741 struct audio_device *adev = my_data->adev;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1742 char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE];
1743 char *sad = block;
1744 int num_audio_blocks;
1745 int channel_count;
1746 int max_channels = 0;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1747 int i, ret, count;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1748
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1749 struct mixer_ctl *ctl;
1750
1751 ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL);
1752 if (!ctl) {
1753 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1754 __func__, AUDIO_DATA_BLOCK_MIXER_CTL);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1755 return 0;
1756 }
1757
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1758 mixer_ctl_update(ctl);
1759
1760 count = mixer_ctl_get_num_values(ctl);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1761
1762 /* Read SAD blocks, clamping the maximum size for safety */
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1763 if (count > (int)sizeof(block))
1764 count = (int)sizeof(block);
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1765
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1766 ret = mixer_ctl_get_array(ctl, block, count);
1767 if (ret != 0) {
1768 ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__);
1769 return 0;
1770 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1771
1772 /* Calculate the number of SAD blocks */
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1773 num_audio_blocks = count / SAD_BLOCK_SIZE;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1774
1775 for (i = 0; i < num_audio_blocks; i++) {
1776 /* Only consider LPCM blocks */
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1777 if ((sad[0] >> 3) != EDID_FORMAT_LPCM) {
1778 sad += 3;
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1779 continue;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1780 }
Naresh Tannirue3b18452014-03-04 14:44:27 +0530[diff] [blame]1781
1782 channel_count = (sad[0] & 0x7) + 1;
1783 if (channel_count > max_channels)
1784 max_channels = channel_count;
1785
1786 /* Advance to next block */
1787 sad += 3;
1788 }
1789
1790 return max_channels;
1791}
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1792
1793static int platform_set_slowtalk(struct platform_data *my_data, bool state)
1794{
1795 int ret = 0;
1796 struct audio_device *adev = my_data->adev;
1797 struct mixer_ctl *ctl;
1798 const char *mixer_ctl_name = "Slowtalk Enable";
1799 uint32_t set_values[ ] = {0,
1800 ALL_SESSION_VSID};
1801
1802 set_values[0] = state;
1803 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1804 if (!ctl) {
1805 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1806 __func__, mixer_ctl_name);
1807 ret = -EINVAL;
1808 } else {
1809 ALOGV("Setting slowtalk state: %d", state);
1810 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
1811 my_data->slowtalk = state;
1812 }
1813
1814 if (my_data->csd != NULL) {
1815 ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state);
1816 if (ret < 0) {
1817 ALOGE("%s: csd_client_disable_device, failed, error %d",
1818 __func__, ret);
1819 }
1820 }
1821 return ret;
1822}
1823
1824int platform_set_parameters(void *platform, struct str_parms *parms)
1825{
1826 struct platform_data *my_data = (struct platform_data *)platform;
1827 char *str;
1828 char value[256] = {0};
1829 int val;
1830 int ret = 0, err;
1831
1832 ALOGV("%s: enter: %s", __func__, str_parms_to_str(parms));
1833
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1834 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SLOWTALK, value, sizeof(value));
1835 if (err >= 0) {
1836 bool state = false;
1837 if (!strncmp("true", value, sizeof("true"))) {
1838 state = true;
1839 }
1840
1841 str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK);
1842 ret = platform_set_slowtalk(my_data, state);
1843 if (ret)
1844 ALOGE("%s: Failed to set slow talk err: %d", __func__, ret);
1845 }
1846
1847 err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
1848 value, sizeof(value));
1849 if (err >= 0) {
1850 str_parms_del(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST);
1851
1852 if (my_data->acdb_reload_vocvoltable == NULL) {
1853 ALOGE("%s: acdb_reload_vocvoltable is NULL", __func__);
1854 } else if (!strcmp(value, "on")) {
1855 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_VOLUME_BOOST)) {
1856 my_data->voice_feature_set = 1;
1857 }
1858 } else {
1859 if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_DEFAULT)) {
1860 my_data->voice_feature_set = 0;
1861 }
1862 }
1863 }
1864
1865 ALOGV("%s: exit with code(%d)", __func__, ret);
1866 return ret;
1867}
1868
1869int platform_set_incall_recording_session_id(void *platform,
1870 uint32_t session_id, int rec_mode)
1871{
1872 int ret = 0;
1873 struct platform_data *my_data = (struct platform_data *)platform;
1874 struct audio_device *adev = my_data->adev;
1875 struct mixer_ctl *ctl;
1876 const char *mixer_ctl_name = "Voc VSID";
1877 int num_ctl_values;
1878 int i;
1879
1880 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1881 if (!ctl) {
1882 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1883 __func__, mixer_ctl_name);
1884 ret = -EINVAL;
1885 } else {
1886 num_ctl_values = mixer_ctl_get_num_values(ctl);
1887 for (i = 0; i < num_ctl_values; i++) {
1888 if (mixer_ctl_set_value(ctl, i, session_id)) {
1889 ALOGV("Error: invalid session_id: %x", session_id);
1890 ret = -EINVAL;
1891 break;
1892 }
1893 }
1894 }
1895
1896 if (my_data->csd != NULL) {
1897 ret = my_data->csd->start_record(ALL_SESSION_VSID, rec_mode);
1898 if (ret < 0) {
1899 ALOGE("%s: csd_client_start_record failed, error %d",
1900 __func__, ret);
1901 }
1902 }
1903
1904 return ret;
1905}
1906
1907int platform_stop_incall_recording_usecase(void *platform)
1908{
1909 int ret = 0;
1910 struct platform_data *my_data = (struct platform_data *)platform;
1911
1912 if (my_data->csd != NULL) {
1913 ret = my_data->csd->stop_record(ALL_SESSION_VSID);
1914 if (ret < 0) {
1915 ALOGE("%s: csd_client_stop_record failed, error %d",
1916 __func__, ret);
1917 }
1918 }
1919
1920 return ret;
1921}
1922
1923int platform_start_incall_music_usecase(void *platform)
1924{
1925 int ret = 0;
1926 struct platform_data *my_data = (struct platform_data *)platform;
1927
1928 if (my_data->csd != NULL) {
1929 ret = my_data->csd->start_playback(ALL_SESSION_VSID);
1930 if (ret < 0) {
1931 ALOGE("%s: csd_client_start_playback failed, error %d",
1932 __func__, ret);
1933 }
1934 }
1935
1936 return ret;
1937}
1938
1939int platform_stop_incall_music_usecase(void *platform)
1940{
1941 int ret = 0;
1942 struct platform_data *my_data = (struct platform_data *)platform;
1943
1944 if (my_data->csd != NULL) {
1945 ret = my_data->csd->stop_playback(ALL_SESSION_VSID);
1946 if (ret < 0) {
1947 ALOGE("%s: csd_client_stop_playback failed, error %d",
1948 __func__, ret);
1949 }
1950 }
1951
1952 return ret;
1953}
1954
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -0700[diff] [blame]1955int platform_update_lch(void *platform, struct voice_session *session,
1956 enum voice_lch_mode lch_mode)
1957{
1958 int ret = 0;
1959 struct platform_data *my_data = (struct platform_data *)platform;
1960
1961 if ((my_data->csd != NULL) && (my_data->csd->set_lch != NULL))
1962 ret = my_data->csd->set_lch(session->vsid, lch_mode);
1963 else
1964 ret = pcm_ioctl(session->pcm_tx, SNDRV_VOICE_IOCTL_LCH, &lch_mode);
1965
1966 return ret;
1967}
1968
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1969void platform_get_parameters(void *platform,
1970 struct str_parms *query,
1971 struct str_parms *reply)
1972{
1973 struct platform_data *my_data = (struct platform_data *)platform;
1974 char *str = NULL;
1975 char value[256] = {0};
1976 int ret;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1977
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]1978 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK,
1979 value, sizeof(value));
1980 if (ret >= 0) {
1981 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SLOWTALK,
1982 my_data->slowtalk?"true":"false");
1983 }
1984
1985 ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOLUME_BOOST,
1986 value, sizeof(value));
1987 if (ret >= 0) {
1988 if (my_data->voice_feature_set == VOICE_FEATURE_SET_VOLUME_BOOST) {
1989 strlcpy(value, "on", sizeof(value));
1990 } else {
1991 strlcpy(value, "off", sizeof(value));
1992 }
1993
1994 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value);
1995 }
1996
1997 ALOGV("%s: exit: returns - %s", __func__, str_parms_to_str(reply));
1998}
1999
2000/* Delay in Us */
2001int64_t platform_render_latency(audio_usecase_t usecase)
2002{
2003 switch (usecase) {
2004 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
2005 return DEEP_BUFFER_PLATFORM_DELAY;
2006 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
2007 return LOW_LATENCY_PLATFORM_DELAY;
2008 default:
2009 return 0;
2010 }
2011}
2012
2013int platform_update_usecase_from_source(int source, int usecase)
2014{
2015 ALOGV("%s: input source :%d", __func__, source);
2016 if(source == AUDIO_SOURCE_FM_RX_A2DP)
2017 usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
2018 return usecase;
2019}
2020
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]2021bool platform_listen_device_needs_event(snd_device_t snd_device)
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2022{
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]2023 bool needs_event = false;
2024
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2025 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
2026 (snd_device < SND_DEVICE_IN_END) &&
2027 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
2028 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK))
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530[diff] [blame]2029 needs_event = true;
2030
2031 return needs_event;
2032}
2033
2034bool platform_listen_usecase_needs_event(audio_usecase_t uc_id)
2035{
2036 bool needs_event = false;
2037
2038 switch(uc_id){
2039 /* concurrent playback usecases needs event */
2040 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
2041 case USECASE_AUDIO_PLAYBACK_MULTI_CH:
2042 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
2043 needs_event = true;
2044 break;
2045 /* concurrent playback in low latency allowed */
2046 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
2047 break;
2048 /* concurrent playback FM needs event */
2049 case USECASE_AUDIO_PLAYBACK_FM:
2050 needs_event = true;
2051 break;
2052
2053 /* concurrent capture usecases, no event, capture handled by device
2054 * USECASE_AUDIO_RECORD:
2055 * USECASE_AUDIO_RECORD_COMPRESS:
2056 * USECASE_AUDIO_RECORD_LOW_LATENCY:
2057
2058 * USECASE_VOICE_CALL:
2059 * USECASE_VOICE2_CALL:
2060 * USECASE_VOLTE_CALL:
2061 * USECASE_QCHAT_CALL:
2062 * USECASE_VOWLAN_CALL:
2063 * USECASE_COMPRESS_VOIP_CALL:
2064 * USECASE_AUDIO_RECORD_FM_VIRTUAL:
2065 * USECASE_INCALL_REC_UPLINK:
2066 * USECASE_INCALL_REC_DOWNLINK:
2067 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK:
2068 * USECASE_INCALL_REC_UPLINK_COMPRESS:
2069 * USECASE_INCALL_REC_DOWNLINK_COMPRESS:
2070 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS:
2071 * USECASE_INCALL_MUSIC_UPLINK:
2072 * USECASE_INCALL_MUSIC_UPLINK2:
2073 * USECASE_AUDIO_SPKR_CALIB_RX:
2074 * USECASE_AUDIO_SPKR_CALIB_TX:
2075 */
2076 default:
2077 ALOGV("%s:usecase_id[%d} no need to raise event.", __func__, uc_id);
2078 }
2079 return needs_event;
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2080}
2081
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700[diff] [blame]2082bool platform_sound_trigger_device_needs_event(snd_device_t snd_device)
2083{
2084 bool needs_event = false;
2085
2086 if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
2087 (snd_device < SND_DEVICE_IN_END) &&
2088 (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
2089 (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK))
2090 needs_event = true;
2091
2092 return needs_event;
2093}
2094
2095bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id)
2096{
2097 bool needs_event = false;
2098
2099 switch(uc_id){
2100 /* concurrent playback usecases needs event */
2101 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
2102 case USECASE_AUDIO_PLAYBACK_MULTI_CH:
2103 case USECASE_AUDIO_PLAYBACK_OFFLOAD:
2104 needs_event = true;
2105 break;
2106 /* concurrent playback in low latency allowed */
2107 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
2108 break;
2109 /* concurrent playback FM needs event */
2110 case USECASE_AUDIO_PLAYBACK_FM:
2111 needs_event = true;
2112 break;
2113
2114 /* concurrent capture usecases, no event, capture handled by device
2115 * USECASE_AUDIO_RECORD:
2116 * USECASE_AUDIO_RECORD_COMPRESS:
2117 * USECASE_AUDIO_RECORD_LOW_LATENCY:
2118
2119 * USECASE_VOICE_CALL:
2120 * USECASE_VOICE2_CALL:
2121 * USECASE_VOLTE_CALL:
2122 * USECASE_QCHAT_CALL:
2123 * USECASE_VOWLAN_CALL:
2124 * USECASE_COMPRESS_VOIP_CALL:
2125 * USECASE_AUDIO_RECORD_FM_VIRTUAL:
2126 * USECASE_INCALL_REC_UPLINK:
2127 * USECASE_INCALL_REC_DOWNLINK:
2128 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK:
2129 * USECASE_INCALL_REC_UPLINK_COMPRESS:
2130 * USECASE_INCALL_REC_DOWNLINK_COMPRESS:
2131 * USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS:
2132 * USECASE_INCALL_MUSIC_UPLINK:
2133 * USECASE_INCALL_MUSIC_UPLINK2:
2134 * USECASE_AUDIO_SPKR_CALIB_RX:
2135 * USECASE_AUDIO_SPKR_CALIB_TX:
2136 */
2137 default:
2138 ALOGV("%s:usecase_id[%d] no need to raise event.", __func__, uc_id);
2139 }
2140 return needs_event;
2141}
2142
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2143/* Read offload buffer size from a property.
2144 * If value is not power of 2 round it to
2145 * power of 2.
2146 */
2147uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info)
2148{
2149 char value[PROPERTY_VALUE_MAX] = {0};
2150 uint32_t fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2151 if((property_get("audio.offload.buffer.size.kb", value, "")) &&
2152 atoi(value)) {
2153 fragment_size = atoi(value) * 1024;
2154 }
2155
2156 if (info != NULL && info->has_video && info->is_streaming) {
2157 fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING;
2158 ALOGV("%s: offload fragment size reduced for AV streaming to %d",
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -0700[diff] [blame]2159 __func__, fragment_size);
Naresh Tannirudb72d1e2014-03-05 17:33:47 +0530[diff] [blame]2160 }
2161
2162 fragment_size = ALIGN( fragment_size, 1024);
2163
2164 if(fragment_size < MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
2165 fragment_size = MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2166 else if(fragment_size > MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE)
2167 fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2168 ALOGV("%s: fragment_size %d", __func__, fragment_size);
2169 return fragment_size;
2170}
2171
2172uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info)
2173{
2174 uint32_t fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE;
2175 uint32_t bits_per_sample = 16;
2176
2177 if (info->format == AUDIO_FORMAT_PCM_24_BIT_OFFLOAD) {
2178 bits_per_sample = 32;
2179 }
2180
2181 if (!info->has_video) {
2182 fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE;
2183
2184 } else if (info->has_video && info->is_streaming) {
2185 fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING
2186 * info->sample_rate
2187 * bits_per_sample
2188 * popcount(info->channel_mask))/1000;
2189
2190 } else if (info->has_video) {
2191 fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV
2192 * info->sample_rate
2193 * bits_per_sample
2194 * popcount(info->channel_mask))/1000;
2195 }
2196
2197 fragment_size = ALIGN( fragment_size, 1024);
2198
2199 if(fragment_size < MIN_PCM_OFFLOAD_FRAGMENT_SIZE)
2200 fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE;
2201 else if(fragment_size > MAX_PCM_OFFLOAD_FRAGMENT_SIZE)
2202 fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE;
2203
2204 ALOGV("%s: fragment_size %d", __func__, fragment_size);
2205 return fragment_size;
2206}
2207
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]2208bool platform_check_24_bit_support() {
2209 return false;
2210}
2211
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -0700[diff] [blame^]2212bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev __unused,
2213 struct audio_usecase *usecase __unused)
2214{
Mingming Yin3ee55c62014-08-04 14:23:35 -0700[diff] [blame]2215 return false;
2216}
Haynes Mathew Georgef4da6fe2014-06-20 19:14:25 -0700[diff] [blame]2217
2218int platform_get_usecase_index(const char * usecase __unused)
2219{
2220 return -ENOSYS;
2221}
2222
2223int platform_set_usecase_pcm_id(audio_usecase_t usecase __unused, int32_t type __unused,
2224 int32_t pcm_id __unused)
2225{
2226 return -ENOSYS;
2227}
2228
2229int platform_set_snd_device_backend(snd_device_t snd_device __unused,
2230 const char * backend __unused)
2231{
2232 return -ENOSYS;
2233}
2234