Gitiles
Code Review Sign In
review.blissroms.org / platform_hardware_qcom_audio / 7176e525cf6199f4af41f31a4700308ca44d327b / . / hal / msm8916 / platform.c
blob: a7b51ab02845b3689ee3200e9ab9cd4cfa90a08d [file] [log] [blame]
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "msm8916_platform"
18/*#define LOG_NDEBUG 0*/
19#define LOG_NDDEBUG 0
20
21#include <stdlib.h>
22#include <dlfcn.h>
23#include <fcntl.h>
24#include <sys/ioctl.h>
25#include <cutils/log.h>
26#include <cutils/properties.h>
27#include <cutils/str_parms.h>
28#include <audio_hw.h>
29#include <platform_api.h>
30#include "platform.h"
31#include "audio_extn.h"
32#include "voice_extn.h"
33#include "sound/msmcal-hwdep.h"
34#include <dirent.h>
35#define MAX_MIXER_XML_PATH 100
36#define MIXER_XML_PATH "/system/etc/mixer_paths.xml"
37#define MIXER_XML_PATH_MTP "/system/etc/mixer_paths_mtp.xml"
38#define MIXER_XML_PATH_MSM8909_PM8916 "/system/etc/mixer_paths_msm8909_pm8916.xml"
39#define MIXER_XML_PATH_L9300 "/system/etc/mixer_paths_l9300.xml"
40
41#define LIB_ACDB_LOADER "libacdbloader.so"
42#define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID"
43#define CVD_VERSION_MIXER_CTL "CVD Version"
44
45/*
46 * This file will have a maximum of 38 bytes:
47 *
48 * 4 bytes: number of audio blocks
49 * 4 bytes: total length of Short Audio Descriptor (SAD) blocks
50 * Maximum 10 * 3 bytes: SAD blocks
51 */
52#define MAX_SAD_BLOCKS 10
53#define SAD_BLOCK_SIZE 3
54#define MAX_CVD_VERSION_STRING_SIZE 100
55
56/* EDID format ID for LPCM audio */
57#define EDID_FORMAT_LPCM 1
58
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]59/* fallback app type if the default app type from acdb loader fails */
60#define DEFAULT_APP_TYPE_RX_PATH 0x11130
61#define DEFAULT_APP_TYPE_TX_PATH 0x11132
62
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]63/* Retry for delay in FW loading*/
64#define RETRY_NUMBER 20
65#define RETRY_US 500000
66#define MAX_SND_CARD 8
67
68#define SAMPLE_RATE_8KHZ 8000
69#define SAMPLE_RATE_16KHZ 16000
70
71#define MAX_SET_CAL_BYTE_SIZE 65536
72
73#define MAX_CAL_NAME 20
74
75#define QMIC_FLAG 0x00000004
76
Tom Cherry6ebefdd2016-07-01 13:09:35 -0700[diff] [blame]77#define TOSTRING_(x) #x
78#define TOSTRING(x) TOSTRING_(x)
79
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]80char cal_name_info[WCD9XXX_MAX_CAL][MAX_CAL_NAME] = {
81 [WCD9XXX_MBHC_CAL] = "mbhc_cal",
82};
83
84struct audio_block_header
85{
86 int reserved;
87 int length;
88};
89
90enum {
91 CAL_MODE_SEND = 0x1,
92 CAL_MODE_PERSIST = 0x2,
93 CAL_MODE_RTAC = 0x4
94};
95
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]96enum {
97 BUFF_IDX_0 = 0,
98 BUFF_IDX_1 = 1,
99};
100
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]101#define PLATFORM_CONFIG_KEY_OPERATOR_INFO "operator_info"
102
103struct operator_info {
104 struct listnode list;
105 char *name;
106 char *mccmnc;
107};
108
109struct operator_specific_device {
110 struct listnode list;
111 char *operator;
112 char *mixer_path;
113 int acdb_id;
114};
115
116static struct listnode operator_info_list;
117static struct listnode *operator_specific_device_table[SND_DEVICE_MAX];
118
119/* Audio calibration related functions */
120typedef void (*acdb_deallocate_t)();
121typedef int (*acdb_init_v2_cvd_t)(const char *, char *, int);
122typedef void (*acdb_send_audio_cal_t)(int, int);
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]123typedef void (*acdb_send_audio_cal_v3_t)(int, int, int , int, int);
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]124typedef void (*acdb_send_voice_cal_t)(int, int);
125typedef int (*acdb_reload_vocvoltable_t)(int);
126typedef int (*acdb_loader_get_calibration_t)(char *attr, int size, void *data);
127acdb_loader_get_calibration_t acdb_loader_get_calibration;
128
129struct platform_data {
130 struct audio_device *adev;
131 bool fluence_in_spkr_mode;
132 bool fluence_in_voice_call;
133 bool fluence_in_voice_rec;
134 int fluence_type;
135 char fluence_cap[PROPERTY_VALUE_MAX];
136 int fluence_mode;
137 bool ec_ref_enabled;
138 bool gsm_mode_enabled;
139 /* Audio calibration related functions */
140 void *acdb_handle;
141 acdb_init_v2_cvd_t acdb_init;
142 acdb_deallocate_t acdb_deallocate;
143 acdb_send_audio_cal_t acdb_send_audio_cal;
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]144 acdb_send_audio_cal_v3_t acdb_send_audio_cal_v3;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]145 acdb_send_voice_cal_t acdb_send_voice_cal;
146 acdb_reload_vocvoltable_t acdb_reload_vocvoltable;
147 void *hw_info;
148 char ec_ref_mixer_path[64];
149 bool speaker_lr_swap;
Tom Cherry6ebefdd2016-07-01 13:09:35 -0700[diff] [blame]150
151 int max_vol_index;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]152};
153
154int pcm_device_table[AUDIO_USECASE_MAX][2] = {
155 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE,
156 DEEP_BUFFER_PCM_DEVICE},
157 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
158 LOWLATENCY_PCM_DEVICE},
159 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE,
160 MULTIMEDIA2_PCM_DEVICE},
161 [USECASE_AUDIO_PLAYBACK_OFFLOAD] =
162 {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE},
163 [USECASE_AUDIO_PLAYBACK_ULL] = {MULTIMEDIA3_PCM_DEVICE, MULTIMEDIA3_PCM_DEVICE},
164 [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE},
165 [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE,
166 LOWLATENCY_PCM_DEVICE},
167 [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX},
168 [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX},
169 [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE},
170 [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE},
171 [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE},
172 [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE},
173 [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE},
174 [USECASE_VOICEMMODE1_CALL] = {-1, -1}, /* pcm ids updated from platform info file */
175 [USECASE_VOICEMMODE2_CALL] = {-1, -1}, /* pcm ids updated from platform info file */
176 [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE,
177 AUDIO_RECORD_PCM_DEVICE},
178 [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
179 AUDIO_RECORD_PCM_DEVICE},
180 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
181 AUDIO_RECORD_PCM_DEVICE},
182 [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1},
183 [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE},
184 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
185 AFE_PROXY_RECORD_PCM_DEVICE},
186 [USECASE_AUDIO_RECORD_AFE_PROXY] = {AFE_PROXY_PLAYBACK_PCM_DEVICE,
187 AFE_PROXY_RECORD_PCM_DEVICE},
188};
189
190/* Array to store sound devices */
191static const char * const device_table[SND_DEVICE_MAX] = {
192 [SND_DEVICE_NONE] = "none",
193 /* Playback sound devices */
194 [SND_DEVICE_OUT_HANDSET] = "handset",
195 [SND_DEVICE_OUT_SPEAKER] = "speaker",
196 [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",
197 [SND_DEVICE_OUT_HEADPHONES] = "headphones",
198 [SND_DEVICE_OUT_LINE] = "line",
199 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
200 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = "speaker-and-line",
201 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
202 [SND_DEVICE_OUT_VOICE_HAC_HANDSET] = "voice-hac-handset",
203 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]204 [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = "voice-speaker-hfp",
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]205 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
206 [SND_DEVICE_OUT_VOICE_LINE] = "voice-line",
207 [SND_DEVICE_OUT_HDMI] = "hdmi",
208 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
209 [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
210 [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
211 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
212 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
213 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
214 [SND_DEVICE_OUT_VOICE_TX] = "voice-tx",
215 [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy",
216 [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones",
217 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
218 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
219 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = "voice-speaker-protected",
220
221 /* Capture sound devices */
222 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
223 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = "handset-mic-ext",
224 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
225 [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic",
226 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic",
227 [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire",
228 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire",
229 [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire",
230 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire",
231 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
232 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic",
233 [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic",
234 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic",
235 [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire",
236 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire",
237 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire",
238 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire",
239 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
240 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic",
241 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]242 [SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = "voice-speaker-mic-hfp",
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]243 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
244 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
245 [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
246 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = "bt-sco-mic",
247 [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
248 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = "bt-sco-mic-wb",
249 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
250 [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
251 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
252 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic",
253 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
254 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
255 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
256 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
257 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic",
258 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef",
259 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
260 [SND_DEVICE_IN_VOICE_RX] = "voice-rx",
261 [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
262 [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
263 [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
264 [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
265 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef",
266 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef",
267 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback",
268 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = "voice-speaker-dmic-broadside",
269 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = "speaker-dmic-broadside",
270 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = "speaker-dmic-broadside",
271 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = "speaker-dmic-broadside",
272 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = "speaker-dmic-broadside",
273 [SND_DEVICE_IN_HANDSET_QMIC] = "quad-mic",
274 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = "quad-mic",
275 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = "quad-mic",
276 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = "quad-mic",
277};
278
279/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
280static int acdb_device_table[SND_DEVICE_MAX] = {
281 [SND_DEVICE_NONE] = -1,
282 [SND_DEVICE_OUT_HANDSET] = 7,
283 [SND_DEVICE_OUT_SPEAKER] = 14,
284 [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,
285 [SND_DEVICE_OUT_LINE] = 10,
286 [SND_DEVICE_OUT_HEADPHONES] = 10,
287 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,
288 [SND_DEVICE_OUT_SPEAKER_AND_LINE] = 10,
289 [SND_DEVICE_OUT_VOICE_HANDSET] = 7,
290 [SND_DEVICE_OUT_VOICE_HAC_HANDSET] = 53,
291 [SND_DEVICE_OUT_VOICE_LINE] = 10,
292 [SND_DEVICE_OUT_VOICE_SPEAKER] = 14,
293 [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10,
294 [SND_DEVICE_OUT_HDMI] = 18,
295 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
296 [SND_DEVICE_OUT_BT_SCO] = 22,
297 [SND_DEVICE_OUT_BT_SCO_WB] = 39,
298 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
299 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
300 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
301 [SND_DEVICE_OUT_VOICE_TX] = 45,
302 [SND_DEVICE_OUT_AFE_PROXY] = 0,
303 [SND_DEVICE_OUT_USB_HEADSET] = 45,
304 [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
305 [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 124,
306 [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = 101,
Yamit Mehta9c50bd82016-08-17 15:24:35 +0530[diff] [blame]307 [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = 140,
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]308
309 [SND_DEVICE_IN_HANDSET_MIC] = 4,
310 [SND_DEVICE_IN_HANDSET_MIC_EXTERNAL] = 4,
311 [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106,
312 [SND_DEVICE_IN_HANDSET_MIC_NS] = 107,
313 [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108,
314 [SND_DEVICE_IN_HANDSET_DMIC] = 41,
315 [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109,
316 [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110,
317 [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111,
318 [SND_DEVICE_IN_SPEAKER_MIC] = 11,
319 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112,
320 [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113,
321 [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114,
322 [SND_DEVICE_IN_SPEAKER_DMIC] = 43,
323 [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115,
324 [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116,
325 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117,
326 [SND_DEVICE_IN_HEADSET_MIC] = 8,
327 [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47,
328 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11,
329 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
330 [SND_DEVICE_IN_HDMI_MIC] = 4,
331 [SND_DEVICE_IN_BT_SCO_MIC] = 21,
332 [SND_DEVICE_IN_BT_SCO_MIC_NREC] = 122,
333 [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
334 [SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = 123,
335 [SND_DEVICE_IN_CAMCORDER_MIC] = 4,
336 [SND_DEVICE_IN_VOICE_DMIC] = 41,
Yamit Mehta9c50bd82016-08-17 15:24:35 +0530[diff] [blame]337 [SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = 141,
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]338 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43,
339 [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19,
340 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16,
341 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
342 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
343 [SND_DEVICE_IN_VOICE_REC_MIC] = 4,
344 [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107,
345 [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34,
346 [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41,
347 [SND_DEVICE_IN_VOICE_RX] = 44,
348 [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
349 [SND_DEVICE_IN_CAPTURE_FM] = 0,
350 [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
351 [SND_DEVICE_IN_QUAD_MIC] = 46,
352 [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34,
353 [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35,
354 [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
355 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE] = 12,
356 [SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE] = 12,
357 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE] = 119,
358 [SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE] = 121,
359 [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE] = 120,
360 [SND_DEVICE_IN_HANDSET_QMIC] = 125,
361 [SND_DEVICE_IN_SPEAKER_QMIC_AEC] = 126,
362 [SND_DEVICE_IN_SPEAKER_QMIC_NS] = 127,
363 [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = 129,
364};
365
366struct name_to_index {
367 char name[100];
368 unsigned int index;
369};
370
371#define TO_NAME_INDEX(X) #X, X
372
373/* Used to get index from parsed sting */
374static struct name_to_index snd_device_name_index[SND_DEVICE_MAX] = {
375 {TO_NAME_INDEX(SND_DEVICE_OUT_HANDSET)},
376 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER)},
377 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_REVERSE)},
378 {TO_NAME_INDEX(SND_DEVICE_OUT_HEADPHONES)},
379 {TO_NAME_INDEX(SND_DEVICE_OUT_LINE)},
380 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES)},
381 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_LINE)},
382 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET)},
383 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HAC_HANDSET)},
384 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER)},
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]385 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_HFP)},
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]386 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HEADPHONES)},
387 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_LINE)},
388 {TO_NAME_INDEX(SND_DEVICE_OUT_HDMI)},
389 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
390 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
391 {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
392 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
393 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
394 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
395 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TX)},
396 {TO_NAME_INDEX(SND_DEVICE_OUT_AFE_PROXY)},
397 {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)},
398 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)},
399 {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)},
400 {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED)},
401 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC)},
402 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_EXTERNAL)},
403 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC)},
404 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_NS)},
405 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_MIC_AEC_NS)},
406 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC)},
407 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC)},
408 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_NS)},
409 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_DMIC_AEC_NS)},
410 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC)},
411 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC)},
412 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_NS)},
413 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_MIC_AEC_NS)},
414 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC)},
415 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC)},
416 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS)},
417 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS)},
418 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC)},
419 {TO_NAME_INDEX(SND_DEVICE_IN_HEADSET_MIC_FLUENCE)},
420 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC)},
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]421 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP)},
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]422 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_HEADSET_MIC)},
423 {TO_NAME_INDEX(SND_DEVICE_IN_HDMI_MIC)},
424 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC)},
425 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_NREC)},
426 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB)},
427 {TO_NAME_INDEX(SND_DEVICE_IN_BT_SCO_MIC_WB_NREC)},
428 {TO_NAME_INDEX(SND_DEVICE_IN_CAMCORDER_MIC)},
429 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_DMIC)},
430 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC)},
431 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_QMIC)},
432 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC)},
433 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC)},
434 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC)},
435 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC)},
436 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_MIC_NS)},
437 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)},
438 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)},
439 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_RX)},
440 {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)},
441 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_FM)},
442 {TO_NAME_INDEX(SND_DEVICE_IN_AANC_HANDSET_MIC)},
443 {TO_NAME_INDEX(SND_DEVICE_IN_QUAD_MIC)},
444 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_STEREO_DMIC)},
445 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_STEREO_DMIC)},
446 {TO_NAME_INDEX(SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)},
447 {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE)},
448 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_BROADSIDE)},
449 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE)},
450 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE)},
451 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE)},
452 {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_QMIC)},
453 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC)},
454 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_NS)},
455 {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)},
456};
457
458static char * backend_table[SND_DEVICE_MAX] = {0};
459static char * hw_interface_table[SND_DEVICE_MAX] = {0};
460
461static struct name_to_index usecase_name_index[AUDIO_USECASE_MAX] = {
462 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_DEEP_BUFFER)},
463 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_LOW_LATENCY)},
464 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_MULTI_CH)},
465 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_OFFLOAD)},
466 {TO_NAME_INDEX(USECASE_AUDIO_PLAYBACK_ULL)},
467 {TO_NAME_INDEX(USECASE_AUDIO_RECORD)},
468 {TO_NAME_INDEX(USECASE_AUDIO_RECORD_LOW_LATENCY)},
469 {TO_NAME_INDEX(USECASE_VOICE_CALL)},
470 {TO_NAME_INDEX(USECASE_VOICE2_CALL)},
471 {TO_NAME_INDEX(USECASE_VOLTE_CALL)},
472 {TO_NAME_INDEX(USECASE_QCHAT_CALL)},
473 {TO_NAME_INDEX(USECASE_VOWLAN_CALL)},
474 {TO_NAME_INDEX(USECASE_VOICEMMODE1_CALL)},
475 {TO_NAME_INDEX(USECASE_VOICEMMODE2_CALL)},
476 {TO_NAME_INDEX(USECASE_AUDIO_HFP_SCO)},
477 {TO_NAME_INDEX(USECASE_AUDIO_SPKR_CALIB_TX)},
478};
479
480#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
481#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
482
483static void query_platform(const char *snd_card_name,
484 char *mixer_xml_path)
485{
486 if (!strncmp(snd_card_name, "msm8x16-snd-card-mtp",
487 sizeof("msm8x16-snd-card-mtp"))) {
488 strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,
489 sizeof(MIXER_XML_PATH_MTP));
490 } else if (!strncmp(snd_card_name, "msm8909-pm8916-snd-card",
491 sizeof("msm8909-pm8916-snd-card"))) {
492 strlcpy(mixer_xml_path, MIXER_XML_PATH_MSM8909_PM8916,
493 sizeof(MIXER_XML_PATH_MSM8909_PM8916));
494 } else if (!strncmp(snd_card_name, "msm8952-snd-card-mtp",
495 sizeof("msm8952-snd-card-mtp"))) {
496 strlcpy(mixer_xml_path, MIXER_XML_PATH_MTP,
497 sizeof(MIXER_XML_PATH_MTP));
498 } else if (!strncmp(snd_card_name, "msm8952-l9300-snd-card",
499 sizeof("msm8952-l9300-snd-card"))) {
500 strlcpy(mixer_xml_path, MIXER_XML_PATH_L9300,
501 sizeof(MIXER_XML_PATH_L9300));
502 } else {
503 strlcpy(mixer_xml_path, MIXER_XML_PATH,
504 sizeof(MIXER_XML_PATH));
505 }
506}
507
508static pthread_once_t check_op_once_ctl = PTHREAD_ONCE_INIT;
509static bool is_tmus = false;
510
511static void check_operator()
512{
513 char value[PROPERTY_VALUE_MAX];
514 int mccmnc;
515 property_get("gsm.sim.operator.numeric",value,"0");
516 mccmnc = atoi(value);
517 ALOGD("%s: tmus mccmnc %d", __func__, mccmnc);
518 switch(mccmnc) {
519 /* TMUS MCC(310), MNC(490, 260, 026) */
520 case 310490:
521 case 310260:
522 case 310026:
523 /* Add new TMUS MNC(800, 660, 580, 310, 270, 250, 240, 230, 220, 210, 200, 160) */
524 case 310800:
525 case 310660:
526 case 310580:
527 case 310310:
528 case 310270:
529 case 310250:
530 case 310240:
531 case 310230:
532 case 310220:
533 case 310210:
534 case 310200:
535 case 310160:
536 is_tmus = true;
537 break;
538 }
539}
540
541bool is_operator_tmus()
542{
543 pthread_once(&check_op_once_ctl, check_operator);
544 return is_tmus;
545}
546
547static char *get_current_operator()
548{
549 struct listnode *node;
550 struct operator_info *info_item;
551 char mccmnc[PROPERTY_VALUE_MAX];
552 char *ret = NULL;
553
554 property_get("gsm.sim.operator.numeric",mccmnc,"0");
555
556 list_for_each(node, &operator_info_list) {
557 info_item = node_to_item(node, struct operator_info, list);
558 if (strstr(info_item->mccmnc, mccmnc) != NULL) {
559 ret = info_item->name;
560 }
561 }
562
563 return ret;
564}
565
566static struct operator_specific_device *get_operator_specific_device(snd_device_t snd_device)
567{
568 struct listnode *node;
569 struct operator_specific_device *ret = NULL;
570 struct operator_specific_device *device_item;
571 char *operator_name;
572
573 operator_name = get_current_operator();
574 if (operator_name == NULL)
575 return ret;
576
577 list_for_each(node, operator_specific_device_table[snd_device]) {
578 device_item = node_to_item(node, struct operator_specific_device, list);
579 if (strcmp(operator_name, device_item->operator) == 0) {
580 ret = device_item;
581 }
582 }
583
584 return ret;
585}
586
587static int get_operator_specific_device_acdb_id(snd_device_t snd_device)
588{
589 struct operator_specific_device *device;
590 int ret = acdb_device_table[snd_device];
591
592 device = get_operator_specific_device(snd_device);
593 if (device != NULL)
594 ret = device->acdb_id;
595
596 return ret;
597}
598
599static const char *get_operator_specific_device_mixer_path(snd_device_t snd_device)
600{
601 struct operator_specific_device *device;
602 const char *ret = device_table[snd_device];
603
604 device = get_operator_specific_device(snd_device);
605 if (device != NULL)
606 ret = device->mixer_path;
607
608 return ret;
609}
610
611bool platform_send_gain_dep_cal(void *platform __unused, int level __unused)
612{
vivek mehtafb4d7bd2016-04-29 03:16:47 -0700[diff] [blame]613 return true;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]614}
615
616void platform_set_echo_reference(struct audio_device *adev, bool enable,
617 audio_devices_t out_device)
618{
619 struct platform_data *my_data = (struct platform_data *)adev->platform;
620 snd_device_t snd_device = SND_DEVICE_NONE;
621
622 if (strcmp(my_data->ec_ref_mixer_path, "")) {
623 ALOGV("%s: disabling %s", __func__, my_data->ec_ref_mixer_path);
624 audio_route_reset_and_update_path(adev->audio_route,
625 my_data->ec_ref_mixer_path);
626 }
627
628 if (enable) {
629 if (out_device != AUDIO_DEVICE_NONE) {
630 snd_device = platform_get_output_snd_device(adev->platform, out_device);
631 platform_add_backend_name(adev->platform, my_data->ec_ref_mixer_path, snd_device);
632 }
633
634 strlcpy(my_data->ec_ref_mixer_path, "echo-reference",
635 sizeof(my_data->ec_ref_mixer_path));
636
637 ALOGD("%s: enabling %s", __func__, my_data->ec_ref_mixer_path);
638 audio_route_apply_and_update_path(adev->audio_route,
639 my_data->ec_ref_mixer_path);
640 }
641}
642
643static void set_platform_defaults()
644{
645 int32_t dev;
646 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
647 backend_table[dev] = NULL;
648 hw_interface_table[dev] = NULL;
649 }
650
651 // TBD - do these go to the platform-info.xml file.
652 // will help in avoiding strdups here
653 backend_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("bt-sco");
654 backend_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("bt-sco-wb");
655 backend_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("bt-sco");
656 backend_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("bt-sco-wb");
657 backend_table[SND_DEVICE_OUT_BT_SCO] = strdup("bt-sco");
658 backend_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("bt-sco-wb");
659 backend_table[SND_DEVICE_OUT_HDMI] = strdup("hdmi");
660 backend_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("speaker-and-hdmi");
661 backend_table[SND_DEVICE_OUT_VOICE_TX] = strdup("afe-proxy");
662 backend_table[SND_DEVICE_IN_VOICE_RX] = strdup("afe-proxy");
663 backend_table[SND_DEVICE_OUT_AFE_PROXY] = strdup("afe-proxy");
664 backend_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("usb-headphones");
665 backend_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] =
666 strdup("speaker-and-usb-headphones");
667 backend_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");
668 backend_table[SND_DEVICE_IN_CAPTURE_FM] = strdup("capture-fm");
669}
670
671void get_cvd_version(char *cvd_version, struct audio_device *adev)
672{
673 struct mixer_ctl *ctl;
674 int count;
675 int ret = 0;
676
677 ctl = mixer_get_ctl_by_name(adev->mixer, CVD_VERSION_MIXER_CTL);
678 if (!ctl) {
679 ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, CVD_VERSION_MIXER_CTL);
680 goto done;
681 }
682 mixer_ctl_update(ctl);
683
684 count = mixer_ctl_get_num_values(ctl);
685 if (count > MAX_CVD_VERSION_STRING_SIZE)
686 count = MAX_CVD_VERSION_STRING_SIZE -1;
687
688 ret = mixer_ctl_get_array(ctl, cvd_version, count);
689 if (ret != 0) {
690 ALOGE("%s: ERROR! mixer_ctl_get_array() failed to get CVD Version", __func__);
691 goto done;
692 }
693
694done:
695 return;
696}
697
698static int hw_util_open(int card_no)
699{
700 int fd = -1;
701 char dev_name[256];
702
703 snprintf(dev_name, sizeof(dev_name), "/dev/snd/hwC%uD%u",
704 card_no, WCD9XXX_CODEC_HWDEP_NODE);
705 ALOGD("%s Opening device %s\n", __func__, dev_name);
706 fd = open(dev_name, O_WRONLY);
707 if (fd < 0) {
708 ALOGE("%s: cannot open device '%s'\n", __func__, dev_name);
709 return fd;
710 }
711 ALOGD("%s success", __func__);
712 return fd;
713}
714
715struct param_data {
716 int use_case;
717 int acdb_id;
718 int get_size;
719 int buff_size;
720 int data_size;
721 void *buff;
722};
723
724static int send_codec_cal(acdb_loader_get_calibration_t acdb_loader_get_calibration,
725 struct platform_data *plat_data __unused, int fd)
726{
727 int ret = 0, type;
728
729 for (type = WCD9XXX_ANC_CAL; type < WCD9XXX_MAX_CAL; type++) {
730 struct wcdcal_ioctl_buffer codec_buffer;
731 struct param_data calib;
732
733 if (type != WCD9XXX_MBHC_CAL)
734 continue;
735
736 calib.get_size = 1;
737 ret = acdb_loader_get_calibration(cal_name_info[type], sizeof(struct param_data),
738 &calib);
739 if (ret < 0) {
740 ALOGE("%s get_calibration failed\n", __func__);
741 return ret;
742 }
743 calib.get_size = 0;
744 calib.buff = malloc(calib.buff_size);
745 if(calib.buff == NULL) {
746 ALOGE("%s mem allocation for %d bytes for %s failed\n"
747 , __func__, calib.buff_size, cal_name_info[type]);
748 return -1;
749 }
750 ret = acdb_loader_get_calibration(cal_name_info[type],
751 sizeof(struct param_data), &calib);
752 if (ret < 0) {
753 ALOGE("%s get_calibration failed type=%s calib.size=%d\n"
754 , __func__, cal_name_info[type], codec_buffer.size);
755 free(calib.buff);
756 return ret;
757 }
758 codec_buffer.buffer = calib.buff;
759 codec_buffer.size = calib.data_size;
760 codec_buffer.cal_type = type;
761 if (ioctl(fd, SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE, &codec_buffer) < 0)
762 ALOGE("Failed to call ioctl for %s err=%d calib.size=%d",
763 cal_name_info[type], errno, codec_buffer.size);
764 ALOGD("%s cal sent for %s calib.size=%d"
765 , __func__, cal_name_info[type], codec_buffer.size);
766 free(calib.buff);
767 }
768 return ret;
769}
770
771static void audio_hwdep_send_cal(struct platform_data *plat_data)
772{
773 int fd;
774
775 fd = hw_util_open(plat_data->adev->snd_card);
776 if (fd == -1) {
777 ALOGE("%s error open\n", __func__);
778 return;
779 }
780
781 acdb_loader_get_calibration = (acdb_loader_get_calibration_t)
782 dlsym(plat_data->acdb_handle, "acdb_loader_get_calibration");
783
784 if (acdb_loader_get_calibration == NULL) {
785 ALOGE("%s: ERROR. dlsym Error:%s acdb_loader_get_calibration", __func__,
786 dlerror());
787 return;
788 }
789 if (send_codec_cal(acdb_loader_get_calibration, plat_data, fd) < 0)
790 ALOGE("%s: Could not send anc cal", __FUNCTION__);
791}
792
793
794int platform_acdb_init(void *platform)
795{
796 struct platform_data *my_data = (struct platform_data *)platform;
797 char *cvd_version = NULL;
798 int key = 0;
799 const char *snd_card_name;
800 int result;
801 char value[PROPERTY_VALUE_MAX];
802 cvd_version = calloc(1, MAX_CVD_VERSION_STRING_SIZE);
803 if (!cvd_version)
804 ALOGE("Failed to allocate cvd version");
805 else
806 get_cvd_version(cvd_version, my_data->adev);
807
808 property_get("audio.ds1.metainfo.key",value,"0");
809 key = atoi(value);
810 snd_card_name = mixer_get_name(my_data->adev->mixer);
811
812 result = my_data->acdb_init(snd_card_name, cvd_version, key);
813
814 if (cvd_version)
815 free(cvd_version);
816 if (!result) {
817 ALOGD("ACDB initialized");
818 audio_hwdep_send_cal(my_data);
819 } else {
820 ALOGD("ACDB initialization failed");
821 }
822 return result;
823}
824
825void *platform_init(struct audio_device *adev)
826{
827 char platform[PROPERTY_VALUE_MAX] = {0};
828 char baseband[PROPERTY_VALUE_MAX] = {0};
829 char value[PROPERTY_VALUE_MAX] = {0};
830 struct platform_data *my_data = NULL;
831 int retry_num = 0, snd_card_num = 0, key = 0;
832 const char *snd_card_name;
833 char mixer_xml_path[MAX_MIXER_XML_PATH] = {0};
834 char ffspEnable[PROPERTY_VALUE_MAX] = {0};
835 char *cvd_version = NULL;
836 int idx;
837
838 my_data = calloc(1, sizeof(struct platform_data));
839 if (!my_data) {
840 ALOGE("failed to allocate platform data");
841 return NULL;
842 }
843
844 list_init(&operator_info_list);
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]845 bool card_verifed[MAX_SND_CARD] = {0};
846 const int retry_limit = property_get_int32("audio.snd_card.open.retries", RETRY_NUMBER);
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]847
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]848 for (;;) {
849 if (snd_card_num >= MAX_SND_CARD) {
850 if (retry_num++ >= retry_limit) {
851 ALOGE("%s: Unable to find correct sound card, aborting.", __func__);
852 free(my_data);
853 my_data = NULL;
854 return NULL;
855 }
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]856
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]857 snd_card_num = 0;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]858 usleep(RETRY_US);
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]859 continue;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]860 }
861
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]862 if (card_verifed[snd_card_num]) {
863 ++snd_card_num;
864 continue;
865 }
866
867 adev->mixer = mixer_open(snd_card_num);
868
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]869 if (!adev->mixer) {
870 ALOGE("%s: Unable to open the mixer card: %d", __func__,
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]871 snd_card_num);
872 ++snd_card_num;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]873 continue;
874 }
875
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]876 card_verifed[snd_card_num] = true;
877
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]878 snd_card_name = mixer_get_name(adev->mixer);
879 ALOGV("%s: snd_card_name: %s", __func__, snd_card_name);
880
881 my_data->hw_info = hw_info_init(snd_card_name);
882 if (!my_data->hw_info) {
883 ALOGE("%s: Failed to init hardware info", __func__);
884 } else {
885 query_platform(snd_card_name, mixer_xml_path);
886 ALOGD("%s: mixer path file is %s", __func__,
887 mixer_xml_path);
888 adev->audio_route = audio_route_init(snd_card_num,
889 mixer_xml_path);
890 if (!adev->audio_route) {
891 ALOGE("%s: Failed to init audio route controls, aborting.",
892 __func__);
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]893 hw_info_deinit(my_data->hw_info);
894 my_data->hw_info = NULL;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]895 free(my_data);
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]896 my_data = NULL;
897 mixer_close(adev->mixer);
898 adev->mixer = NULL;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]899 return NULL;
900 }
901 adev->snd_card = snd_card_num;
902 ALOGD("%s: Opened sound card:%d", __func__, snd_card_num);
903 break;
904 }
vivek mehtad135c312016-09-14 18:37:49 -0700[diff] [blame]905 ++snd_card_num;
906 mixer_close(adev->mixer);
907 adev->mixer = NULL;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]908 }
909
Tom Cherry6ebefdd2016-07-01 13:09:35 -0700[diff] [blame]910 //set max volume step for voice call
911 property_get("ro.config.vc_call_vol_steps", value, TOSTRING(MAX_VOL_INDEX));
912 my_data->max_vol_index = atoi(value);
913
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]914 my_data->adev = adev;
915 my_data->fluence_in_spkr_mode = false;
916 my_data->fluence_in_voice_call = false;
917 my_data->fluence_in_voice_rec = false;
918 my_data->fluence_type = FLUENCE_NONE;
919 my_data->fluence_mode = FLUENCE_ENDFIRE;
920
921 property_get("ro.qc.sdk.audio.fluencetype", my_data->fluence_cap, "");
922 if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) {
923 my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
924 } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) {
925 my_data->fluence_type = FLUENCE_DUAL_MIC;
926 } else {
927 my_data->fluence_type = FLUENCE_NONE;
928 }
929
930 if (my_data->fluence_type != FLUENCE_NONE) {
931 property_get("persist.audio.fluence.voicecall",value,"");
932 if (!strncmp("true", value, sizeof("true"))) {
933 my_data->fluence_in_voice_call = true;
934 }
935
936 property_get("persist.audio.fluence.voicerec",value,"");
937 if (!strncmp("true", value, sizeof("true"))) {
938 my_data->fluence_in_voice_rec = true;
939 }
940
941 property_get("persist.audio.fluence.speaker",value,"");
942 if (!strncmp("true", value, sizeof("true"))) {
943 my_data->fluence_in_spkr_mode = true;
944 }
945
946 property_get("persist.audio.fluence.mode",value,"");
947 if (!strncmp("broadside", value, sizeof("broadside"))) {
948 my_data->fluence_mode = FLUENCE_BROADSIDE;
949 }
950 }
951
952 property_get("persist.audio.FFSP.enable", ffspEnable, "");
953 if (!strncmp("true", ffspEnable, sizeof("true"))) {
954 acdb_device_table[SND_DEVICE_OUT_SPEAKER] = 131;
955 acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = 131;
956 acdb_device_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 131;
957 acdb_device_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 131;
958 }
959
960 my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
961 if (my_data->acdb_handle == NULL) {
962 ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER);
963 } else {
964 ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);
965 my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle,
966 "acdb_loader_deallocate_ACDB");
967 if (!my_data->acdb_deallocate)
968 ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s",
969 __func__, LIB_ACDB_LOADER);
970
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]971 my_data->acdb_send_audio_cal_v3 = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle,
972 "acdb_loader_send_audio_cal_v3");
973 if (!my_data->acdb_send_audio_cal_v3)
974 ALOGE("%s: Could not find the symbol acdb_send_audio_cal from %s",
975 __func__, LIB_ACDB_LOADER);
976
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]977 my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle,
978 "acdb_loader_send_audio_cal");
979 if (!my_data->acdb_send_audio_cal)
980 ALOGE("%s: Could not find the symbol acdb_send_audio_cal from %s",
981 __func__, LIB_ACDB_LOADER);
982
983 my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle,
984 "acdb_loader_send_voice_cal");
985 if (!my_data->acdb_send_voice_cal)
986 ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s",
987 __func__, LIB_ACDB_LOADER);
988
989 my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle,
990 "acdb_loader_reload_vocvoltable");
991 if (!my_data->acdb_reload_vocvoltable)
992 ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s",
993 __func__, LIB_ACDB_LOADER);
994
995 my_data->acdb_init = (acdb_init_v2_cvd_t)dlsym(my_data->acdb_handle,
996 "acdb_loader_init_v2");
997 if (my_data->acdb_init == NULL) {
998 ALOGE("%s: dlsym error %s for acdb_loader_init_v2", __func__, dlerror());
999 goto acdb_init_fail;
1000 }
1001 platform_acdb_init(my_data);
1002 }
1003
1004acdb_init_fail:
1005
1006 set_platform_defaults();
1007
1008 /* Initialize ACDB and PCM ID's */
1009 platform_info_init(PLATFORM_INFO_XML_PATH, my_data);
1010
1011
1012 /* Read one time ssr property */
1013 audio_extn_spkr_prot_init(adev);
1014
1015 return my_data;
1016}
1017
1018void platform_deinit(void *platform)
1019{
1020 struct platform_data *my_data = (struct platform_data *)platform;
1021
1022 int32_t dev;
1023 struct operator_info *info_item;
1024 struct operator_specific_device *device_item;
1025 struct listnode *node;
1026
1027 hw_info_deinit(my_data->hw_info);
1028
1029 for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
1030 if (backend_table[dev]) {
1031 free(backend_table[dev]);
1032 backend_table[dev]= NULL;
1033 }
1034 if (operator_specific_device_table[dev]) {
1035 while (!list_empty(operator_specific_device_table[dev])) {
1036 node = list_head(operator_specific_device_table[dev]);
1037 list_remove(node);
1038 device_item = node_to_item(node, struct operator_specific_device, list);
1039 free(device_item->operator);
1040 free(device_item->mixer_path);
1041 free(device_item);
1042 }
1043 free(operator_specific_device_table[dev]);
1044 }
1045 }
1046
1047 while (!list_empty(&operator_info_list)) {
1048 node = list_head(&operator_info_list);
1049 list_remove(node);
1050 info_item = node_to_item(node, struct operator_info, list);
1051 free(info_item->name);
1052 free(info_item->mccmnc);
1053 free(info_item);
1054 }
1055
1056 free(platform);
1057}
1058
1059const char *platform_get_snd_device_name(snd_device_t snd_device)
1060{
1061 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
1062 if (operator_specific_device_table[snd_device] != NULL) {
1063 return get_operator_specific_device_mixer_path(snd_device);
1064 }
1065 return device_table[snd_device];
1066 } else
1067 return "none";
1068}
1069
1070int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
1071 char *device_name)
1072{
1073 struct platform_data *my_data = (struct platform_data *)platform;
1074
1075 if (platform == NULL || device_name == NULL) {
1076 ALOGW("%s: something wrong, use legacy get_snd_device name", __func__);
1077 strlcpy(device_name, platform_get_snd_device_name(snd_device),
1078 DEVICE_NAME_MAX_SIZE);
1079 } else if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
1080 if (operator_specific_device_table[snd_device] != NULL) {
1081 strlcpy(device_name, get_operator_specific_device_mixer_path(snd_device),
1082 DEVICE_NAME_MAX_SIZE);
1083 } else {
1084 strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
1085 }
1086 hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
1087 } else {
1088 strlcpy(device_name, "none", DEVICE_NAME_MAX_SIZE);
1089 return -EINVAL;
1090 }
1091
1092 return 0;
1093}
1094
Yamit Mehta6b4b1272016-06-10 15:12:50 +0530[diff] [blame]1095bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev __unused,
1096 struct audio_usecase *usecase __unused,
1097 snd_device_t snd_device)
1098{
1099 return false;
1100}
1101
1102bool platform_add_gain_level_mapping(struct amp_db_and_gain_table *tbl_entry __unused)
1103{
1104 return false;
1105}
1106
1107int platform_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl __unused,
1108 int table_size __unused)
1109{
1110 return 0;
1111}
1112
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1113void platform_add_backend_name(void *platform, char *mixer_path,
1114 snd_device_t snd_device)
1115{
1116
1117 struct platform_data *my_data = (struct platform_data *)platform;
1118
1119 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
1120 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
1121 return;
1122 }
1123
1124 const char * suffix = backend_table[snd_device];
1125
1126 if (suffix != NULL) {
1127 strlcat(mixer_path, " ", MIXER_PATH_MAX_LENGTH);
1128 strlcat(mixer_path, suffix, MIXER_PATH_MAX_LENGTH);
1129 }
1130}
1131
1132bool platform_check_backends_match(snd_device_t snd_device1, snd_device_t snd_device2)
1133{
1134 bool result = true;
1135
1136 ALOGV("%s: snd_device1 = %s, snd_device2 = %s", __func__,
1137 platform_get_snd_device_name(snd_device1),
1138 platform_get_snd_device_name(snd_device2));
1139
1140 if ((snd_device1 < SND_DEVICE_MIN) || (snd_device1 >= SND_DEVICE_MAX)) {
1141 ALOGE("%s: Invalid snd_device = %s", __func__,
1142 platform_get_snd_device_name(snd_device1));
1143 return false;
1144 }
1145 if ((snd_device2 < SND_DEVICE_MIN) || (snd_device2 >= SND_DEVICE_MAX)) {
1146 ALOGE("%s: Invalid snd_device = %s", __func__,
1147 platform_get_snd_device_name(snd_device2));
1148 return false;
1149 }
1150 const char * be_itf1 = hw_interface_table[snd_device1];
1151 const char * be_itf2 = hw_interface_table[snd_device2];
1152
1153 if (NULL != be_itf1 && NULL != be_itf2) {
1154 if ((NULL == strstr(be_itf2, be_itf1)) && (NULL == strstr(be_itf1, be_itf2)))
1155 result = false;
1156 }
1157
1158 ALOGV("%s: be_itf1 = %s, be_itf2 = %s, match %d", __func__, be_itf1, be_itf2, result);
1159 return result;
1160}
1161
1162int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
1163{
1164 int device_id = -1;
1165
1166 if (device_type == PCM_PLAYBACK)
1167 device_id = pcm_device_table[usecase][0];
1168 else
1169 device_id = pcm_device_table[usecase][1];
1170 return device_id;
1171}
1172
1173static int find_index(struct name_to_index * table, int32_t len, const char * name)
1174{
1175 int ret = 0;
1176 int32_t i;
1177
1178 if (table == NULL) {
1179 ALOGE("%s: table is NULL", __func__);
1180 ret = -ENODEV;
1181 goto done;
1182 }
1183
1184 if (name == NULL) {
1185 ALOGE("null key");
1186 ret = -ENODEV;
1187 goto done;
1188 }
1189
1190 for (i=0; i < len; i++) {
1191 const char* tn = table[i].name;
1192 size_t len = strlen(tn);
1193 if (strncmp(tn, name, len) == 0) {
1194 if (strlen(name) != len) {
1195 continue; // substring
1196 }
1197 ret = table[i].index;
1198 goto done;
1199 }
1200 }
1201 ALOGE("%s: Could not find index for name = %s",
1202 __func__, name);
1203 ret = -ENODEV;
1204done:
1205 return ret;
1206}
1207
1208int platform_get_snd_device_index(char *device_name)
1209{
1210 return find_index(snd_device_name_index, SND_DEVICE_MAX, device_name);
1211}
1212
1213int platform_get_usecase_index(const char *usecase_name)
1214{
1215 return find_index(usecase_name_index, AUDIO_USECASE_MAX, usecase_name);
1216}
1217
1218void platform_add_operator_specific_device(snd_device_t snd_device,
1219 const char *operator,
1220 const char *mixer_path,
1221 unsigned int acdb_id)
1222{
1223 struct operator_specific_device *device;
1224
1225 if (operator_specific_device_table[snd_device] == NULL) {
1226 operator_specific_device_table[snd_device] =
1227 (struct listnode *)calloc(1, sizeof(struct listnode));
1228 list_init(operator_specific_device_table[snd_device]);
1229 }
1230
1231 device = (struct operator_specific_device *)calloc(1, sizeof(struct operator_specific_device));
1232
1233 device->operator = strdup(operator);
1234 device->mixer_path = strdup(mixer_path);
1235 device->acdb_id = acdb_id;
1236
1237 list_add_tail(operator_specific_device_table[snd_device], &device->list);
1238
1239 ALOGD("%s: device[%s] -> operator[%s] mixer_path[%s] acdb_id[%d]", __func__,
1240 platform_get_snd_device_name(snd_device), operator, mixer_path, acdb_id);
1241
1242}
1243
1244int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)
1245{
1246 int ret = 0;
1247
1248 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
1249 ALOGE("%s: Invalid snd_device = %d",
1250 __func__, snd_device);
1251 ret = -EINVAL;
1252 goto done;
1253 }
1254 ALOGV("%s: acdb_device_table[%s]: old = %d new = %d", __func__,
1255 platform_get_snd_device_name(snd_device), acdb_device_table[snd_device], acdb_id);
1256 acdb_device_table[snd_device] = acdb_id;
1257done:
1258 return ret;
1259}
1260
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]1261int platform_get_default_app_type_v2(void *platform, usecase_type_t type, int *app_type)
1262{
1263 ALOGV("%s: platform: %p, type: %d", __func__, platform, type);
1264 int rc = 0;
1265 if (type == PCM_CAPTURE) {
1266 *app_type = DEFAULT_APP_TYPE_TX_PATH;
1267 } else if (type == PCM_PLAYBACK) {
1268 *app_type = DEFAULT_APP_TYPE_RX_PATH;
1269 } else {
1270 rc = -EINVAL;
1271 }
1272 return rc;
1273}
1274
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1275int platform_get_snd_device_acdb_id(snd_device_t snd_device)
1276{
1277 if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
1278 ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
1279 return -EINVAL;
1280 }
1281
1282 if (operator_specific_device_table[snd_device] != NULL)
1283 return get_operator_specific_device_acdb_id(snd_device);
1284 else
1285 return acdb_device_table[snd_device];
1286}
1287
1288int platform_send_audio_calibration(void *platform, snd_device_t snd_device)
1289{
1290 struct platform_data *my_data = (struct platform_data *)platform;
1291 int acdb_dev_id, acdb_dev_type;
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]1292 int sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1293
1294 acdb_dev_id = acdb_device_table[audio_extn_get_spkr_prot_snd_device(snd_device)];
1295 if (acdb_dev_id < 0) {
1296 ALOGE("%s: Could not find acdb id for device(%d)",
1297 __func__, snd_device);
1298 return -EINVAL;
1299 }
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1300 ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
1301 __func__, snd_device, acdb_dev_id);
Yamit Mehtae3b99562016-09-16 22:44:00 +0530[diff] [blame]1302 if (snd_device >= SND_DEVICE_OUT_BEGIN && snd_device < SND_DEVICE_OUT_END)
1303 acdb_dev_type = ACDB_DEV_TYPE_OUT;
1304 else
1305 acdb_dev_type = ACDB_DEV_TYPE_IN;
1306
1307 if ((my_data->acdb_send_audio_cal_v3) && (snd_device == SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP)) {
1308 /* TX path calibration */
1309 my_data->acdb_send_audio_cal_v3(acdb_dev_id, ACDB_DEV_TYPE_IN,
1310 DEFAULT_APP_TYPE_TX_PATH, sample_rate, BUFF_IDX_0);
1311 my_data->acdb_send_audio_cal_v3(acdb_dev_id, ACDB_DEV_TYPE_OUT,
1312 DEFAULT_APP_TYPE_RX_PATH, sample_rate, BUFF_IDX_0);
1313 } else if ((my_data->acdb_send_audio_cal_v3) && (snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_HFP)) {
1314 /* RX path calibration */
1315 ALOGV("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
1316 __func__, snd_device, acdb_dev_id);
1317 my_data->acdb_send_audio_cal_v3(acdb_dev_id, ACDB_DEV_TYPE_IN,
1318 DEFAULT_APP_TYPE_TX_PATH, sample_rate, BUFF_IDX_1);
1319 my_data->acdb_send_audio_cal_v3(acdb_dev_id, ACDB_DEV_TYPE_OUT,
1320 DEFAULT_APP_TYPE_RX_PATH, sample_rate, BUFF_IDX_1);
1321 } else if (my_data->acdb_send_audio_cal) {
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1322 my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type);
1323 }
1324 return 0;
1325}
1326
1327int platform_switch_voice_call_device_pre(void *platform __unused)
1328{
1329 return 0;
1330}
1331
1332int platform_switch_voice_call_enable_device_config(void *platform __unused,
1333 snd_device_t out_snd_device __unused,
1334 snd_device_t in_snd_device __unused)
1335{
1336 return 0;
1337}
1338
1339int platform_switch_voice_call_device_post(void *platform,
1340 snd_device_t out_snd_device,
1341 snd_device_t in_snd_device)
1342{
1343 struct platform_data *my_data = (struct platform_data *)platform;
1344 int acdb_rx_id, acdb_tx_id;
1345
1346 if (my_data->acdb_send_voice_cal == NULL) {
1347 ALOGE("%s: dlsym error for acdb_send_voice_call", __func__);
1348 } else {
1349 if (out_snd_device == SND_DEVICE_OUT_VOICE_SPEAKER &&
1350 audio_extn_spkr_prot_is_enabled())
1351 out_snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED;
1352
1353 acdb_rx_id = platform_get_snd_device_acdb_id(out_snd_device);
1354 acdb_tx_id = platform_get_snd_device_acdb_id(in_snd_device);
1355
1356 if (acdb_rx_id > 0 && acdb_tx_id > 0)
1357 my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id);
1358 else
1359 ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
1360 acdb_rx_id, acdb_tx_id);
1361 }
1362
1363 return 0;
1364}
1365
1366int platform_switch_voice_call_usecase_route_post(void *platform __unused,
1367 snd_device_t out_snd_device __unused,
1368 snd_device_t in_snd_device __unused)
1369{
1370 return 0;
1371}
1372
1373int platform_start_voice_call(void *platform __unused, uint32_t vsid __unused)
1374{
1375 return 0;
1376}
1377
1378int platform_stop_voice_call(void *platform __unused, uint32_t vsid __unused)
1379{
1380 return 0;
1381}
1382
1383int platform_get_sample_rate(void *platform __unused, uint32_t *rate __unused)
1384{
1385 return 0;
1386}
1387
1388void platform_set_speaker_gain_in_combo(struct audio_device *adev __unused,
1389 snd_device_t snd_device __unused,
1390 bool enable __unused)
1391{
1392 return;
1393}
1394
1395int platform_set_voice_volume(void *platform, int volume)
1396{
1397 struct platform_data *my_data = (struct platform_data *)platform;
1398 struct audio_device *adev = my_data->adev;
1399 struct mixer_ctl *ctl;
1400 const char *mixer_ctl_name = "Voice Rx Gain";
1401 int vol_index = 0, ret = 0;
1402 uint32_t set_values[ ] = {0,
1403 ALL_SESSION_VSID,
1404 DEFAULT_VOLUME_RAMP_DURATION_MS};
1405
1406 // Voice volume levels are mapped to adsp volume levels as follows.
1407 // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0
1408 // But this values don't changed in kernel. So, below change is need.
Tom Cherry6ebefdd2016-07-01 13:09:35 -0700[diff] [blame]1409 vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, my_data->max_vol_index);
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1410 set_values[0] = vol_index;
1411
1412 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1413 if (!ctl) {
1414 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1415 __func__, mixer_ctl_name);
1416 return -EINVAL;
1417 }
1418 ALOGV("Setting voice volume index: %d", set_values[0]);
1419 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
1420
1421 return ret;
1422}
1423
1424int platform_set_mic_mute(void *platform, bool state)
1425{
1426 struct platform_data *my_data = (struct platform_data *)platform;
1427 struct audio_device *adev = my_data->adev;
1428 struct mixer_ctl *ctl;
1429 const char *mixer_ctl_name = "Voice Tx Mute";
1430 int ret = 0;
Yamit Mehtaa2bdf6e2016-11-02 12:01:02 +0530[diff] [blame]1431 uint32_t set_values[ ] = {0,
1432 ALL_SESSION_VSID,
1433 DEFAULT_MUTE_RAMP_DURATION_MS};
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1434
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]1435 if (audio_extn_hfp_is_active(adev))
Yamit Mehtabb15d172016-08-08 20:19:03 +0530[diff] [blame]1436 mixer_ctl_name = "HFP TX Mute";
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]1437
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1438 set_values[0] = state;
1439 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1440 if (!ctl) {
1441 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1442 __func__, mixer_ctl_name);
1443 return -EINVAL;
1444 }
1445 ALOGV("Setting voice mute state: %d", state);
Yamit Mehtaa2bdf6e2016-11-02 12:01:02 +0530[diff] [blame]1446 // "HFP TX mute" mixer control has xcount of 1.
1447 if (audio_extn_hfp_is_active(adev))
1448 ret = mixer_ctl_set_array(ctl, set_values, 1 /*count*/);
1449 else
1450 ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1451 return ret;
1452}
1453
1454int platform_set_device_mute(void *platform, bool state, char *dir)
1455{
1456 struct platform_data *my_data = (struct platform_data *)platform;
1457 struct audio_device *adev = my_data->adev;
1458 struct mixer_ctl *ctl;
1459 char *mixer_ctl_name = NULL;
1460 int ret = 0;
1461 uint32_t set_values[ ] = {0,
1462 ALL_SESSION_VSID,
1463 0};
1464 if(dir == NULL) {
1465 ALOGE("%s: Invalid direction:%s", __func__, dir);
1466 return -EINVAL;
1467 }
1468
1469 if (!strncmp("rx", dir, sizeof("rx"))) {
1470 mixer_ctl_name = "Voice Rx Device Mute";
1471 } else if (!strncmp("tx", dir, sizeof("tx"))) {
1472 mixer_ctl_name = "Voice Tx Device Mute";
1473 } else {
1474 return -EINVAL;
1475 }
1476
1477 set_values[0] = state;
1478 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1479 if (!ctl) {
1480 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1481 __func__, mixer_ctl_name);
1482 return -EINVAL;
1483 }
1484
1485 ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s",
1486 __func__,state, mixer_ctl_name);
1487 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
1488
1489 return ret;
1490}
1491
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1492int platform_can_split_snd_device(snd_device_t snd_device,
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1493 int *num_devices,
1494 snd_device_t *new_snd_devices)
1495{
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1496 int ret = -EINVAL;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1497
1498 if (NULL == num_devices || NULL == new_snd_devices) {
1499 ALOGE("%s: NULL pointer ..", __func__);
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1500 return -EINVAL;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1501 }
1502
1503 /*
1504 * If wired headset/headphones/line devices share the same backend
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1505 * with speaker/earpiece this routine -EINVAL.
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1506 */
1507 if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES &&
1508 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HEADPHONES)) {
1509 *num_devices = 2;
1510 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
1511 new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1512 ret = 0;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1513 } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_LINE &&
1514 !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_LINE)) {
1515 *num_devices = 2;
1516 new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
1517 new_snd_devices[1] = SND_DEVICE_OUT_LINE;
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1518 ret = 0;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1519 }
Haynes Mathew George2d809e02016-09-22 17:38:16 -0700[diff] [blame]1520 return ret;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1521}
1522
1523snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices)
1524{
1525 struct platform_data *my_data = (struct platform_data *)platform;
1526 struct audio_device *adev = my_data->adev;
1527 audio_mode_t mode = adev->mode;
1528 snd_device_t snd_device = SND_DEVICE_NONE;
1529
1530 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
1531 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
1532 int channel_count = popcount(channel_mask);
1533
1534 ALOGV("%s: enter: output devices(%#x)", __func__, devices);
1535 if (devices == AUDIO_DEVICE_NONE ||
1536 devices & AUDIO_DEVICE_BIT_IN) {
1537 ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
1538 goto exit;
1539 }
1540
1541 if (popcount(devices) == 2) {
1542 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
1543 AUDIO_DEVICE_OUT_SPEAKER)) {
1544 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
1545 } else if (devices == (AUDIO_DEVICE_OUT_LINE |
1546 AUDIO_DEVICE_OUT_SPEAKER)) {
1547 snd_device = SND_DEVICE_OUT_SPEAKER_AND_LINE;
1548 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
1549 AUDIO_DEVICE_OUT_SPEAKER)) {
1550 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
1551 } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL |
1552 AUDIO_DEVICE_OUT_SPEAKER)) {
1553 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI;
1554 } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
1555 AUDIO_DEVICE_OUT_SPEAKER)) {
1556 snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
1557 } else {
1558 ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
1559 goto exit;
1560 }
1561 if (snd_device != SND_DEVICE_NONE) {
1562 goto exit;
1563 }
1564 }
1565
1566 if (popcount(devices) != 1) {
1567 ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
1568 goto exit;
1569 }
1570
Madhuri Athota3f6051b2016-10-13 23:25:38 +0530[diff] [blame]1571 if (mode == AUDIO_MODE_IN_CALL || audio_extn_hfp_is_active(adev)) {
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1572 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1573 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
1574 devices & AUDIO_DEVICE_OUT_LINE) {
1575 if (adev->voice.tty_mode != TTY_MODE_OFF) {
1576 switch (adev->voice.tty_mode) {
1577 case TTY_MODE_FULL:
1578 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
1579 break;
1580 case TTY_MODE_VCO:
1581 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
1582 break;
1583 case TTY_MODE_HCO:
1584 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
1585 break;
1586 default:
1587 ALOGE("%s: Invalid TTY mode (%#x)",
1588 __func__, adev->voice.tty_mode);
1589 }
1590 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
1591 snd_device = SND_DEVICE_OUT_VOICE_LINE;
1592 } else {
1593 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
1594 }
1595 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
1596 if (adev->bt_wb_speech_enabled)
1597 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
1598 else
1599 snd_device = SND_DEVICE_OUT_BT_SCO;
1600 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]1601 if (audio_extn_hfp_is_active(adev))
1602 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_HFP;
1603 else
1604 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1605 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1606 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
1607 snd_device = SND_DEVICE_OUT_USB_HEADSET;
1608 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
1609 snd_device = SND_DEVICE_OUT_VOICE_HANDSET;
1610 } else if (devices & AUDIO_DEVICE_OUT_TELEPHONY_TX)
1611 snd_device = SND_DEVICE_OUT_VOICE_TX;
1612
1613 if (snd_device != SND_DEVICE_NONE) {
1614 goto exit;
1615 }
1616 }
1617
1618 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1619 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1620 snd_device = SND_DEVICE_OUT_HEADPHONES;
1621 } else if (devices & AUDIO_DEVICE_OUT_LINE) {
1622 snd_device = SND_DEVICE_OUT_LINE;
1623 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
1624 if (my_data->speaker_lr_swap)
1625 snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE;
1626 else
1627 snd_device = SND_DEVICE_OUT_SPEAKER;
1628 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
1629 if (adev->bt_wb_speech_enabled)
1630 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
1631 else
1632 snd_device = SND_DEVICE_OUT_BT_SCO;
1633 } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1634 snd_device = SND_DEVICE_OUT_HDMI ;
1635 } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1636 devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
1637 snd_device = SND_DEVICE_OUT_USB_HEADSET;
1638 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
1639 snd_device = SND_DEVICE_OUT_HANDSET;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1640 } else {
1641 ALOGE("%s: Unknown device(s) %#x", __func__, devices);
1642 }
1643exit:
1644 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
1645 return snd_device;
1646}
1647
1648snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
1649{
1650 struct platform_data *my_data = (struct platform_data *)platform;
1651 struct audio_device *adev = my_data->adev;
1652 audio_source_t source = (adev->active_input == NULL) ?
1653 AUDIO_SOURCE_DEFAULT : adev->active_input->source;
1654
1655 audio_mode_t mode = adev->mode;
1656 audio_devices_t in_device = ((adev->active_input == NULL) ?
1657 AUDIO_DEVICE_NONE : adev->active_input->device)
1658 & ~AUDIO_DEVICE_BIT_IN;
1659 audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
1660 AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
1661 snd_device_t snd_device = SND_DEVICE_NONE;
1662 int channel_count = popcount(channel_mask);
1663
1664 ALOGV("%s: enter: out_device(%#x) in_device(%#x)",
1665 __func__, out_device, in_device);
1666
1667 if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) ||
1668 audio_extn_hfp_is_active(adev))) {
1669 if (adev->voice.tty_mode != TTY_MODE_OFF) {
1670 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1671 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
1672 out_device & AUDIO_DEVICE_OUT_LINE) {
1673 switch (adev->voice.tty_mode) {
1674 case TTY_MODE_FULL:
1675 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
1676 break;
1677 case TTY_MODE_VCO:
1678 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
1679 break;
1680 case TTY_MODE_HCO:
1681 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
1682 break;
1683 default:
1684 ALOGE("%s: Invalid TTY mode (%#x)",
1685 __func__, adev->voice.tty_mode);
1686 }
1687 goto exit;
1688 }
1689 }
1690 if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
1691 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1692 out_device & AUDIO_DEVICE_OUT_LINE) {
1693 if (my_data->fluence_type == FLUENCE_NONE ||
1694 my_data->fluence_in_voice_call == false) {
1695 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1696 if (audio_extn_hfp_is_active(adev))
1697 platform_set_echo_reference(adev, true, out_device);
1698 } else {
1699 snd_device = SND_DEVICE_IN_VOICE_DMIC;
1700 adev->acdb_settings |= DMIC_FLAG;
1701 }
1702 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1703 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
1704 if (audio_extn_hfp_is_active(adev))
1705 platform_set_echo_reference(adev, true, out_device);
1706 } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) {
1707 if (adev->bt_wb_speech_enabled) {
1708 if (adev->bluetooth_nrec)
1709 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1710 else
1711 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1712 } else {
1713 if (adev->bluetooth_nrec)
1714 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1715 else
1716 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1717 }
1718 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
1719 if (my_data->fluence_type != FLUENCE_NONE &&
1720 my_data->fluence_in_voice_call &&
1721 my_data->fluence_in_spkr_mode) {
1722 if(my_data->fluence_type & FLUENCE_QUAD_MIC) {
1723 adev->acdb_settings |= QMIC_FLAG;
1724 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC;
1725 } else {
1726 adev->acdb_settings |= DMIC_FLAG;
1727 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1728 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE;
1729 else
1730 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC;
1731 }
1732 } else {
1733 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]1734 if (audio_extn_hfp_is_active(adev)) {
1735 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP;
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1736 platform_set_echo_reference(adev, true, out_device);
Devin Kim152b09a2016-06-23 13:53:04 -0700[diff] [blame]1737 } else {
1738 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
1739 }
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]1740 }
1741 } else if (out_device & AUDIO_DEVICE_OUT_TELEPHONY_TX)
1742 snd_device = SND_DEVICE_IN_VOICE_RX;
1743 } else if (source == AUDIO_SOURCE_CAMCORDER) {
1744 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
1745 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1746 if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
1747 channel_count == 2)
1748 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
1749 else
1750 snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
1751 }
1752 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1753 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1754 if (channel_count == 2) {
1755 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
1756 adev->acdb_settings |= DMIC_FLAG;
1757 } else if (adev->active_input->enable_ns)
1758 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
1759 else if (my_data->fluence_type != FLUENCE_NONE &&
1760 my_data->fluence_in_voice_rec) {
1761 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
1762 adev->acdb_settings |= DMIC_FLAG;
1763 } else {
1764 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
1765 }
1766 }
1767 } else if ((source == AUDIO_SOURCE_VOICE_COMMUNICATION) ||
1768 (mode == AUDIO_MODE_IN_COMMUNICATION)) {
1769 if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
1770 in_device = AUDIO_DEVICE_IN_BACK_MIC;
1771 if (adev->active_input) {
1772 if (my_data->fluence_type != FLUENCE_NONE &&
1773 adev->active_input->enable_aec &&
1774 adev->active_input->enable_ns) {
1775 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1776 if (my_data->fluence_in_spkr_mode) {
1777 if (my_data->fluence_type & FLUENCE_QUAD_MIC) {
1778 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS;
1779 } else if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1780 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1781 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
1782 else
1783 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
1784 }
1785 adev->acdb_settings |= DMIC_FLAG;
1786 } else
1787 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
1788 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1789 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1790 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
1791 adev->acdb_settings |= DMIC_FLAG;
1792 } else
1793 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
1794 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1795 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
1796 }
1797 platform_set_echo_reference(adev, true, out_device);
1798 } else if (my_data->fluence_type != FLUENCE_NONE &&
1799 adev->active_input->enable_aec) {
1800 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1801 if (my_data->fluence_in_spkr_mode) {
1802 if (my_data->fluence_type & FLUENCE_QUAD_MIC) {
1803 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_AEC;
1804 } else if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1805 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1806 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE;
1807 else
1808 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
1809 }
1810 adev->acdb_settings |= DMIC_FLAG;
1811 } else
1812 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
1813 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1814 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1815 snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
1816 adev->acdb_settings |= DMIC_FLAG;
1817 } else
1818 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
1819 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1820 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
1821 }
1822 platform_set_echo_reference(adev, true, out_device);
1823 } else if (my_data->fluence_type != FLUENCE_NONE &&
1824 adev->active_input->enable_ns) {
1825 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1826 if (my_data->fluence_in_spkr_mode) {
1827 if (my_data->fluence_type & FLUENCE_QUAD_MIC) {
1828 snd_device = SND_DEVICE_IN_SPEAKER_QMIC_NS;
1829 } else if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1830 if (my_data->fluence_mode == FLUENCE_BROADSIDE)
1831 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE;
1832 else
1833 snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
1834 }
1835 adev->acdb_settings |= DMIC_FLAG;
1836 } else
1837 snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
1838 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1839 if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
1840 snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
1841 adev->acdb_settings |= DMIC_FLAG;
1842 } else
1843 snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
1844 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1845 snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
1846 }
1847 platform_set_echo_reference(adev, false, out_device);
1848 } else
1849 platform_set_echo_reference(adev, false, out_device);
1850 }
1851 } else if (source == AUDIO_SOURCE_FM_TUNER) {
1852 snd_device = SND_DEVICE_IN_CAPTURE_FM;
1853 } else if (source == AUDIO_SOURCE_DEFAULT) {
1854 goto exit;
1855 }
1856
1857
1858 if (snd_device != SND_DEVICE_NONE) {
1859 goto exit;
1860 }
1861
1862 if (in_device != AUDIO_DEVICE_NONE &&
1863 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
1864 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
1865 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
1866 if (my_data->fluence_type & (FLUENCE_DUAL_MIC | FLUENCE_QUAD_MIC) &&
1867 channel_count == 2)
1868 snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
1869 else
1870 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1871 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
1872 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
1873 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
1874 snd_device = SND_DEVICE_IN_HEADSET_MIC;
1875 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
1876 if (adev->bt_wb_speech_enabled) {
1877 if (adev->bluetooth_nrec)
1878 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1879 else
1880 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1881 } else {
1882 if (adev->bluetooth_nrec)
1883 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1884 else
1885 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1886 }
1887 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
1888 snd_device = SND_DEVICE_IN_HDMI_MIC;
1889 } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
1890 in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
1891 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
1892 } else if (in_device & AUDIO_DEVICE_IN_FM_TUNER) {
1893 snd_device = SND_DEVICE_IN_CAPTURE_FM;
1894 } else {
1895 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
1896 ALOGW("%s: Using default handset-mic", __func__);
1897 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1898 }
1899 } else {
1900 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
1901 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1902 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
1903 snd_device = SND_DEVICE_IN_HEADSET_MIC;
1904 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
1905 if (channel_count > 1)
1906 snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC;
1907 else
1908 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
1909 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
1910 out_device & AUDIO_DEVICE_OUT_LINE) {
1911 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1912 } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
1913 if (adev->bt_wb_speech_enabled) {
1914 if (adev->bluetooth_nrec)
1915 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB_NREC;
1916 else
1917 snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
1918 } else {
1919 if (adev->bluetooth_nrec)
1920 snd_device = SND_DEVICE_IN_BT_SCO_MIC_NREC;
1921 else
1922 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
1923 }
1924 } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1925 snd_device = SND_DEVICE_IN_HDMI_MIC;
1926 } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
1927 out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
1928 snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
1929 } else {
1930 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
1931 ALOGW("%s: Using default handset-mic", __func__);
1932 snd_device = SND_DEVICE_IN_HANDSET_MIC;
1933 }
1934 }
1935exit:
1936 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
1937 return snd_device;
1938}
1939
1940int platform_set_hdmi_channels(void *platform, int channel_count)
1941{
1942 struct platform_data *my_data = (struct platform_data *)platform;
1943 struct audio_device *adev = my_data->adev;
1944 struct mixer_ctl *ctl;
1945 const char *channel_cnt_str = NULL;
1946 const char *mixer_ctl_name = "HDMI_RX Channels";
1947 switch (channel_count) {
1948 case 8:
1949 channel_cnt_str = "Eight"; break;
1950 case 7:
1951 channel_cnt_str = "Seven"; break;
1952 case 6:
1953 channel_cnt_str = "Six"; break;
1954 case 5:
1955 channel_cnt_str = "Five"; break;
1956 case 4:
1957 channel_cnt_str = "Four"; break;
1958 case 3:
1959 channel_cnt_str = "Three"; break;
1960 default:
1961 channel_cnt_str = "Two"; break;
1962 }
1963 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1964 if (!ctl) {
1965 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1966 __func__, mixer_ctl_name);
1967 return -EINVAL;
1968 }
1969 ALOGV("HDMI channel count: %s", channel_cnt_str);
1970 mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
1971 return 0;
1972}
1973
1974int platform_edid_get_max_channels(void *platform)
1975{
1976 struct platform_data *my_data = (struct platform_data *)platform;
1977 struct audio_device *adev = my_data->adev;
1978 char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE];
1979 char *sad = block;
1980 int num_audio_blocks;
1981 int channel_count;
1982 int max_channels = 0;
1983 int i, ret, count;
1984
1985 struct mixer_ctl *ctl;
1986
1987 ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL);
1988 if (!ctl) {
1989 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1990 __func__, AUDIO_DATA_BLOCK_MIXER_CTL);
1991 return 0;
1992 }
1993
1994 mixer_ctl_update(ctl);
1995
1996 count = mixer_ctl_get_num_values(ctl);
1997
1998 /* Read SAD blocks, clamping the maximum size for safety */
1999 if (count > (int)sizeof(block))
2000 count = (int)sizeof(block);
2001
2002 ret = mixer_ctl_get_array(ctl, block, count);
2003 if (ret != 0) {
2004 ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__);
2005 return 0;
2006 }
2007
2008 /* Calculate the number of SAD blocks */
2009 num_audio_blocks = count / SAD_BLOCK_SIZE;
2010
2011 for (i = 0; i < num_audio_blocks; i++) {
2012 /* Only consider LPCM blocks */
2013 if ((sad[0] >> 3) != EDID_FORMAT_LPCM) {
2014 sad += 3;
2015 continue;
2016 }
2017
2018 channel_count = (sad[0] & 0x7) + 1;
2019 if (channel_count > max_channels)
2020 max_channels = channel_count;
2021
2022 /* Advance to next block */
2023 sad += 3;
2024 }
2025
2026 return max_channels;
2027}
2028
2029int platform_set_incall_recording_session_id(void *platform,
2030 uint32_t session_id,
2031 int rec_mode __unused)
2032{
2033 int ret = 0;
2034 struct platform_data *my_data = (struct platform_data *)platform;
2035 struct audio_device *adev = my_data->adev;
2036 struct mixer_ctl *ctl;
2037 const char *mixer_ctl_name = "Voc VSID";
2038 int num_ctl_values;
2039 int i;
2040
2041 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
2042 if (!ctl) {
2043 ALOGE("%s: Could not get ctl for mixer cmd - %s",
2044 __func__, mixer_ctl_name);
2045 ret = -EINVAL;
2046 } else {
2047 num_ctl_values = mixer_ctl_get_num_values(ctl);
2048 for (i = 0; i < num_ctl_values; i++) {
2049 if (mixer_ctl_set_value(ctl, i, session_id)) {
2050 ALOGV("Error: invalid session_id: %x", session_id);
2051 ret = -EINVAL;
2052 break;
2053 }
2054 }
2055 }
2056 return ret;
2057}
2058
2059int platform_stop_incall_recording_usecase(void *platform __unused)
2060{
2061 return 0;
2062}
2063
2064int platform_start_incall_music_usecase(void *platform __unused)
2065{
2066 return 0;
2067}
2068
2069int platform_stop_incall_music_usecase(void *platform __unused)
2070{
2071 return 0;
2072}
2073
2074int platform_set_parameters(void *platform, struct str_parms *parms)
2075{
2076 struct platform_data *my_data = (struct platform_data *)platform;
2077 char value[128];
2078 char *kv_pairs = str_parms_to_str(parms);
2079 int ret = 0, err;
2080
2081 if (kv_pairs == NULL) {
2082 ret = -EINVAL;
2083 ALOGE("%s: key-value pair is NULL",__func__);
2084 goto done;
2085 }
2086
2087 ALOGV("%s: enter: %s", __func__, kv_pairs);
2088
2089 err = str_parms_get_str(parms, PLATFORM_CONFIG_KEY_OPERATOR_INFO,
2090 value, sizeof(value));
2091 if (err >= 0) {
2092 struct operator_info *info;
2093 char *str = value;
2094 char *name;
2095
2096 str_parms_del(parms, PLATFORM_CONFIG_KEY_OPERATOR_INFO);
2097 info = (struct operator_info *)calloc(1, sizeof(struct operator_info));
2098 name = strtok(str, ";");
2099 info->name = strdup(name);
2100 info->mccmnc = strdup(str + strlen(name) + 1);
2101
2102 list_add_tail(&operator_info_list, &info->list);
2103 ALOGV("%s: add operator[%s] mccmnc[%s]", __func__, info->name, info->mccmnc);
2104 }
Surendar karka56631b52016-07-13 15:08:39 -0700[diff] [blame]2105
2106 audio_extn_hfp_set_parameters(my_data->adev, parms);
Yamit Mehta1d2e4742016-05-18 15:25:12 +0530[diff] [blame]2107done:
2108 ALOGV("%s: exit with code(%d)", __func__, ret);
2109 if (kv_pairs != NULL)
2110 free(kv_pairs);
2111
2112 return ret;
2113}
2114
2115/* Delay in Us */
2116int64_t platform_render_latency(audio_usecase_t usecase)
2117{
2118 switch (usecase) {
2119 case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
2120 return DEEP_BUFFER_PLATFORM_DELAY;
2121 case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
2122 return LOW_LATENCY_PLATFORM_DELAY;
2123 default:
2124 return 0;
2125 }
2126}
2127
2128int platform_set_snd_device_backend(snd_device_t device, const char *backend, const char * hw_interface)
2129{
2130 int ret = 0;
2131
2132 if ((device < SND_DEVICE_MIN) || (device >= SND_DEVICE_MAX)) {
2133 ALOGE("%s: Invalid snd_device = %d",
2134 __func__, device);
2135 ret = -EINVAL;
2136 goto done;
2137 }
2138
2139 ALOGV("%s: backend_tag_table[%s]: old = %s new = %s", __func__,
2140 platform_get_snd_device_name(device),
2141 backend_table[device] != NULL ? backend_table[device]: "null", backend);
2142 if (backend_table[device]) {
2143 free(backend_table[device]);
2144 }
2145 backend_table[device] = strdup(backend);
2146
2147 if (hw_interface != NULL) {
2148 if (hw_interface_table[device])
2149 free(hw_interface_table[device]);
2150 ALOGV("%s: hw_interface_table[%d] = %s", __func__, device, hw_interface);
2151 hw_interface_table[device] = strdup(hw_interface);
2152 }
2153done:
2154 return ret;
2155}
2156
2157int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id)
2158{
2159 int ret = 0;
2160 if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {
2161 ALOGE("%s: invalid usecase case idx %d", __func__, usecase);
2162 ret = -EINVAL;
2163 goto done;
2164 }
2165
2166 if ((type != 0) && (type != 1)) {
2167 ALOGE("%s: invalid usecase type", __func__);
2168 ret = -EINVAL;
2169 }
2170 pcm_device_table[usecase][type] = pcm_id;
2171done:
2172 return ret;
2173}
2174
2175#define DEFAULT_NOMINAL_SPEAKER_GAIN 20
2176int ramp_speaker_gain(struct audio_device *adev, bool ramp_up, int target_ramp_up_gain) {
2177 // backup_gain: gain to try to set in case of an error during ramp
2178 int start_gain, end_gain, step, backup_gain, i;
2179 bool error = false;
2180 const struct mixer_ctl *ctl;
2181 const char *mixer_ctl_name_gain_left = "Left Speaker Gain";
2182 const char *mixer_ctl_name_gain_right = "Right Speaker Gain";
2183 struct mixer_ctl *ctl_left = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_left);
2184 struct mixer_ctl *ctl_right = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name_gain_right);
2185 if (!ctl_left || !ctl_right) {
2186 ALOGE("%s: Could not get ctl for mixer cmd - %s or %s, not applying speaker gain ramp",
2187 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
2188 return -EINVAL;
2189 } else if ((mixer_ctl_get_num_values(ctl_left) != 1)
2190 || (mixer_ctl_get_num_values(ctl_right) != 1)) {
2191 ALOGE("%s: Unexpected num values for mixer cmd - %s or %s, not applying speaker gain ramp",
2192 __func__, mixer_ctl_name_gain_left, mixer_ctl_name_gain_right);
2193 return -EINVAL;
2194 }
2195 if (ramp_up) {
2196 start_gain = 0;
2197 end_gain = target_ramp_up_gain > 0 ? target_ramp_up_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
2198 step = +1;
2199 backup_gain = end_gain;
2200 } else {
2201 // using same gain on left and right
2202 const int left_gain = mixer_ctl_get_value(ctl_left, 0);
2203 start_gain = left_gain > 0 ? left_gain : DEFAULT_NOMINAL_SPEAKER_GAIN;
2204 end_gain = 0;
2205 step = -1;
2206 backup_gain = start_gain;
2207 }
2208 for (i = start_gain ; i != (end_gain + step) ; i += step) {
2209 //ALOGV("setting speaker gain to %d", i);
2210 if (mixer_ctl_set_value(ctl_left, 0, i)) {
2211 ALOGE("%s: error setting %s to %d during gain ramp",
2212 __func__, mixer_ctl_name_gain_left, i);
2213 error = true;
2214 break;
2215 }
2216 if (mixer_ctl_set_value(ctl_right, 0, i)) {
2217 ALOGE("%s: error setting %s to %d during gain ramp",
2218 __func__, mixer_ctl_name_gain_right, i);
2219 error = true;
2220 break;
2221 }
2222 usleep(1000);
2223 }
2224 if (error) {
2225 // an error occured during the ramp, let's still try to go back to a safe volume
2226 if (mixer_ctl_set_value(ctl_left, 0, backup_gain)) {
2227 ALOGE("%s: error restoring left gain to %d", __func__, backup_gain);
2228 }
2229 if (mixer_ctl_set_value(ctl_right, 0, backup_gain)) {
2230 ALOGE("%s: error restoring right gain to %d", __func__, backup_gain);
2231 }
2232 }
2233 return start_gain;
2234}
2235
2236int platform_swap_lr_channels(struct audio_device *adev, bool swap_channels)
2237{
2238 // only update if there is active pcm playback on speaker
2239 struct audio_usecase *usecase;
2240 struct listnode *node;
2241 struct platform_data *my_data = (struct platform_data *)adev->platform;
2242
2243 if (my_data->speaker_lr_swap != swap_channels) {
2244 my_data->speaker_lr_swap = swap_channels;
2245
2246 list_for_each(node, &adev->usecase_list) {
2247 usecase = node_to_item(node, struct audio_usecase, list);
2248 if (usecase->type == PCM_PLAYBACK &&
2249 usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
2250 /*
2251 * If acdb tuning is different for SPEAKER_REVERSE, it is must
2252 * to perform device switch to disable the current backend to
2253 * enable it with new acdb data.
2254 */
2255 if (acdb_device_table[SND_DEVICE_OUT_SPEAKER] !=
2256 acdb_device_table[SND_DEVICE_OUT_SPEAKER_REVERSE]) {
2257 const int initial_skpr_gain = ramp_speaker_gain(adev, false /*ramp_up*/, -1);
2258 select_devices(adev, usecase->id);
2259 if (initial_skpr_gain != -EINVAL) {
2260 ramp_speaker_gain(adev, true /*ramp_up*/, initial_skpr_gain);
2261 }
2262 } else {
2263 const char *mixer_path;
2264 if (swap_channels) {
2265 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_REVERSE);
2266 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
2267 } else {
2268 mixer_path = platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER);
2269 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
2270 }
2271 }
2272 break;
2273 }
2274 }
2275 }
2276 return 0;
2277}
Haynes Mathew Georgec735fb02016-06-30 18:00:28 -0700[diff] [blame]2278
Tom Cherry8721b4d2016-07-14 16:12:23 -0700[diff] [blame]2279int platform_snd_card_update(void *platform __unused,
Haynes Mathew Georgec735fb02016-06-30 18:00:28 -0700[diff] [blame]2280 card_status_t status __unused)
2281{
2282 return -1;
2283}