Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1 | /* |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 2 | * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 3 | * Not a Contribution. |
| 4 | * |
Shiv Maliyappanahalli | 8911f28 | 2014-01-10 15:56:19 -0800 | [diff] [blame] | 5 | * Copyright (C) 2013 The Android Open Source Project |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 8 | * you may not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
| 18 | */ |
| 19 | |
| 20 | #define LOG_TAG "msm8974_platform" |
| 21 | /*#define LOG_NDEBUG 0*/ |
| 22 | #define LOG_NDDEBUG 0 |
| 23 | |
| 24 | #include <stdlib.h> |
| 25 | #include <dlfcn.h> |
| 26 | #include <cutils/log.h> |
| 27 | #include <cutils/properties.h> |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 28 | #include <cutils/str_parms.h> |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 29 | #include <audio_hw.h> |
| 30 | #include <platform_api.h> |
| 31 | #include "platform.h" |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 32 | #include "audio_extn.h" |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 33 | #include "voice_extn.h" |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 34 | #include "sound/compress_params.h" |
Ben Romberger | a167371 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 35 | #include "platform_parser.h" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 36 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 37 | #define MIXER_XML_PATH "/system/etc/mixer_paths.xml" |
Damir Didjusto | f1d46c7 | 2013-11-06 17:59:04 -0800 | [diff] [blame] | 38 | #define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 39 | #define LIB_ACDB_LOADER "libacdbloader.so" |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 40 | #define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 41 | |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 42 | #define MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024) |
| 43 | #define MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE (2 * 1024) |
| 44 | #define COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING (2 * 1024) |
| 45 | #define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024) |
| 46 | |
| 47 | /* Used in calculating fragment size for pcm offload */ |
ApurupaPattapu | 0c097d5 | 2014-04-08 10:41:07 -0700 | [diff] [blame] | 48 | #define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV 1000 /* 1 sec */ |
| 49 | #define PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING 80 /* 80 millisecs */ |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 50 | |
| 51 | /* MAX PCM fragment size cannot be increased further due |
| 52 | * to flinger's cblk size of 1mb,and it has to be a multiple of |
| 53 | * 24 - lcm of channels supported by DSP |
| 54 | */ |
| 55 | #define MAX_PCM_OFFLOAD_FRAGMENT_SIZE (240 * 1024) |
ApurupaPattapu | 0c097d5 | 2014-04-08 10:41:07 -0700 | [diff] [blame] | 56 | #define MIN_PCM_OFFLOAD_FRAGMENT_SIZE (4 * 1024) |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 57 | |
| 58 | #define ALIGN( num, to ) (((num) + (to-1)) & (~(to-1))) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 59 | /* |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 60 | * This file will have a maximum of 38 bytes: |
| 61 | * |
| 62 | * 4 bytes: number of audio blocks |
| 63 | * 4 bytes: total length of Short Audio Descriptor (SAD) blocks |
| 64 | * Maximum 10 * 3 bytes: SAD blocks |
| 65 | */ |
| 66 | #define MAX_SAD_BLOCKS 10 |
| 67 | #define SAD_BLOCK_SIZE 3 |
| 68 | |
| 69 | /* EDID format ID for LPCM audio */ |
| 70 | #define EDID_FORMAT_LPCM 1 |
| 71 | |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 72 | /* Retry for delay in FW loading*/ |
| 73 | #define RETRY_NUMBER 10 |
| 74 | #define RETRY_US 500000 |
Apoorv Raghuvanshi | 84fa2fe | 2013-12-04 11:57:47 -0800 | [diff] [blame] | 75 | #define MAX_SND_CARD 8 |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 76 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 77 | #define SAMPLE_RATE_8KHZ 8000 |
| 78 | #define SAMPLE_RATE_16KHZ 16000 |
| 79 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 80 | #define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence" |
| 81 | #define AUDIO_PARAMETER_KEY_BTSCO "bt_samplerate" |
| 82 | #define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable" |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 83 | #define AUDIO_PARAMETER_KEY_VOLUME_BOOST "volume_boost" |
| 84 | |
| 85 | enum { |
| 86 | VOICE_FEATURE_SET_DEFAULT, |
| 87 | VOICE_FEATURE_SET_VOLUME_BOOST |
| 88 | }; |
sangwoo | 53b2cf0 | 2013-07-25 19:18:44 -0700 | [diff] [blame] | 89 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 90 | struct audio_block_header |
| 91 | { |
| 92 | int reserved; |
| 93 | int length; |
| 94 | }; |
| 95 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 96 | /* Audio calibration related functions */ |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 97 | typedef void (*acdb_deallocate_t)(); |
| 98 | typedef int (*acdb_init_t)(); |
| 99 | typedef void (*acdb_send_audio_cal_t)(int, int); |
| 100 | typedef void (*acdb_send_voice_cal_t)(int, int); |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 101 | typedef int (*acdb_reload_vocvoltable_t)(int); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 102 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 103 | struct platform_data { |
| 104 | struct audio_device *adev; |
| 105 | bool fluence_in_spkr_mode; |
| 106 | bool fluence_in_voice_call; |
| 107 | bool fluence_in_voice_rec; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 108 | bool fluence_in_audio_rec; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 109 | int fluence_type; |
Venkata Narendra Kumar Gutta | 9c38b18 | 2014-03-27 17:39:57 +0530 | [diff] [blame] | 110 | char fluence_cap[PROPERTY_VALUE_MAX]; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 111 | int btsco_sample_rate; |
| 112 | bool slowtalk; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 113 | /* Audio calibration related functions */ |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 114 | void *acdb_handle; |
| 115 | int voice_feature_set; |
| 116 | acdb_init_t acdb_init; |
| 117 | acdb_deallocate_t acdb_deallocate; |
| 118 | acdb_send_audio_cal_t acdb_send_audio_cal; |
| 119 | acdb_send_voice_cal_t acdb_send_voice_cal; |
| 120 | acdb_reload_vocvoltable_t acdb_reload_vocvoltable; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 121 | |
| 122 | void *hw_info; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 123 | struct csd_data *csd; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 124 | }; |
| 125 | |
| 126 | static const int pcm_device_table[AUDIO_USECASE_MAX][2] = { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 127 | [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE, |
| 128 | DEEP_BUFFER_PCM_DEVICE}, |
| 129 | [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE, |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 130 | LOWLATENCY_PCM_DEVICE}, |
| 131 | [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE, |
| 132 | MULTIMEDIA2_PCM_DEVICE}, |
Krishnankutty Kolathappilly | a43f96e | 2013-11-01 12:17:53 -0700 | [diff] [blame] | 133 | [USECASE_AUDIO_PLAYBACK_OFFLOAD] = |
| 134 | {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE}, |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 135 | [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE}, |
Mingming Yin | e62d784 | 2013-10-25 16:26:03 -0700 | [diff] [blame] | 136 | [USECASE_AUDIO_RECORD_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, COMPRESS_CAPTURE_DEVICE}, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 137 | [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE, |
| 138 | LOWLATENCY_PCM_DEVICE}, |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 139 | [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE, |
| 140 | MULTIMEDIA2_PCM_DEVICE}, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 141 | [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE}, |
Vimal Puthanveed | 5b4d3f1 | 2013-11-05 15:57:39 -0800 | [diff] [blame] | 142 | [USECASE_AUDIO_HFP_SCO] = {HFP_PCM_RX, HFP_SCO_RX}, |
Vimal Puthanveed | 47e6485 | 2013-12-20 13:23:39 -0800 | [diff] [blame] | 143 | [USECASE_AUDIO_HFP_SCO_WB] = {HFP_PCM_RX, HFP_SCO_RX}, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 144 | [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE}, |
| 145 | [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE}, |
| 146 | [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE}, |
| 147 | [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE}, |
Vicky Sehrawat | 111aeb3 | 2014-02-12 17:58:59 -0800 | [diff] [blame] | 148 | [USECASE_VOWLAN_CALL] = {VOWLAN_CALL_PCM_DEVICE, VOWLAN_CALL_PCM_DEVICE}, |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 149 | [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE}, |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 150 | [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 151 | AUDIO_RECORD_PCM_DEVICE}, |
| 152 | [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 153 | AUDIO_RECORD_PCM_DEVICE}, |
| 154 | [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 155 | AUDIO_RECORD_PCM_DEVICE}, |
Helen Zeng | e56b485 | 2013-12-03 16:54:40 -0800 | [diff] [blame] | 156 | [USECASE_INCALL_REC_UPLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, |
| 157 | COMPRESS_CAPTURE_DEVICE}, |
| 158 | [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, |
| 159 | COMPRESS_CAPTURE_DEVICE}, |
| 160 | [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = {COMPRESS_CAPTURE_DEVICE, |
| 161 | COMPRESS_CAPTURE_DEVICE}, |
Shiv Maliyappanahalli | f3b9a42 | 2013-10-22 16:38:08 -0700 | [diff] [blame] | 162 | [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE, |
| 163 | INCALL_MUSIC_UPLINK_PCM_DEVICE}, |
| 164 | [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE, |
| 165 | INCALL_MUSIC_UPLINK2_PCM_DEVICE}, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 166 | [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1}, |
| 167 | [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE}, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 168 | }; |
| 169 | |
| 170 | /* Array to store sound devices */ |
| 171 | static const char * const device_table[SND_DEVICE_MAX] = { |
| 172 | [SND_DEVICE_NONE] = "none", |
| 173 | /* Playback sound devices */ |
| 174 | [SND_DEVICE_OUT_HANDSET] = "handset", |
| 175 | [SND_DEVICE_OUT_SPEAKER] = "speaker", |
| 176 | [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse", |
| 177 | [SND_DEVICE_OUT_HEADPHONES] = "headphones", |
| 178 | [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones", |
| 179 | [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset", |
| 180 | [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker", |
| 181 | [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones", |
| 182 | [SND_DEVICE_OUT_HDMI] = "hdmi", |
| 183 | [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi", |
| 184 | [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset", |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 185 | [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 186 | [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones", |
| 187 | [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones", |
| 188 | [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset", |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 189 | [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy", |
| 190 | [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones", |
| 191 | [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones", |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 192 | [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm", |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 193 | [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones", |
| 194 | [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones", |
| 195 | [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones", |
| 196 | [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones", |
| 197 | [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones", |
| 198 | [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset", |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 199 | [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 200 | |
| 201 | /* Capture sound devices */ |
| 202 | [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 203 | [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic", |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 204 | [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic", |
| 205 | [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic", |
| 206 | [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 207 | [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire", |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 208 | [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire", |
| 209 | [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire", |
| 210 | [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 211 | [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic", |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 212 | [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic", |
| 213 | [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic", |
| 214 | [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 215 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire", |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 216 | [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire", |
| 217 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire", |
| 218 | [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic", |
| 219 | [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 220 | [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic", |
| 221 | [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic", |
| 222 | [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic", |
| 223 | [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic", |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 224 | [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 225 | [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 226 | [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 227 | [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef", |
Vidyakumar Athota | adfe4e3 | 2013-12-13 14:51:26 -0800 | [diff] [blame] | 228 | [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = "voice-speaker-qmic", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 229 | [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic", |
| 230 | [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic", |
| 231 | [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic", |
| 232 | [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic", |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 233 | [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 234 | [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 235 | [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence", |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 236 | [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic", |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 237 | [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm", |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 238 | [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic", |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 239 | [SND_DEVICE_IN_QUAD_MIC] = "quad-mic", |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 240 | [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef", |
| 241 | [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef", |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 242 | [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 243 | }; |
| 244 | |
| 245 | /* ACDB IDs (audio DSP path configuration IDs) for each sound device */ |
Ben Romberger | a167371 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 246 | static int acdb_device_table[SND_DEVICE_MAX] = { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 247 | [SND_DEVICE_NONE] = -1, |
| 248 | [SND_DEVICE_OUT_HANDSET] = 7, |
Vidyakumar Athota | c29d4ab | 2013-11-14 16:58:02 -0800 | [diff] [blame] | 249 | [SND_DEVICE_OUT_SPEAKER] = 14, |
| 250 | [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 251 | [SND_DEVICE_OUT_HEADPHONES] = 10, |
| 252 | [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10, |
| 253 | [SND_DEVICE_OUT_VOICE_HANDSET] = 7, |
Vidyakumar Athota | c29d4ab | 2013-11-14 16:58:02 -0800 | [diff] [blame] | 254 | [SND_DEVICE_OUT_VOICE_SPEAKER] = 14, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 255 | [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10, |
| 256 | [SND_DEVICE_OUT_HDMI] = 18, |
Vidyakumar Athota | c29d4ab | 2013-11-14 16:58:02 -0800 | [diff] [blame] | 257 | [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 258 | [SND_DEVICE_OUT_BT_SCO] = 22, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 259 | [SND_DEVICE_OUT_BT_SCO_WB] = 39, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 260 | [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17, |
| 261 | [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17, |
| 262 | [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37, |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 263 | [SND_DEVICE_OUT_AFE_PROXY] = 0, |
| 264 | [SND_DEVICE_OUT_USB_HEADSET] = 0, |
| 265 | [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 266 | [SND_DEVICE_OUT_TRANSMISSION_FM] = 0, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 267 | [SND_DEVICE_OUT_ANC_HEADSET] = 26, |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 268 | [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 269 | [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26, |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 270 | [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 271 | [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26, |
| 272 | [SND_DEVICE_OUT_ANC_HANDSET] = 103, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 273 | [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 101, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 274 | |
| 275 | [SND_DEVICE_IN_HANDSET_MIC] = 4, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 276 | [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106, |
| 277 | [SND_DEVICE_IN_HANDSET_MIC_NS] = 107, |
| 278 | [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 279 | [SND_DEVICE_IN_HANDSET_DMIC] = 41, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 280 | [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109, |
| 281 | [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110, |
| 282 | [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 283 | [SND_DEVICE_IN_SPEAKER_MIC] = 11, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 284 | [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112, |
| 285 | [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113, |
| 286 | [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 287 | [SND_DEVICE_IN_SPEAKER_DMIC] = 43, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 288 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115, |
| 289 | [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116, |
| 290 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 291 | [SND_DEVICE_IN_HEADSET_MIC] = 8, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 292 | [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 293 | [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11, |
| 294 | [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8, |
| 295 | [SND_DEVICE_IN_HDMI_MIC] = 4, |
| 296 | [SND_DEVICE_IN_BT_SCO_MIC] = 21, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 297 | [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 298 | [SND_DEVICE_IN_CAMCORDER_MIC] = 4, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 299 | [SND_DEVICE_IN_VOICE_DMIC] = 41, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 300 | [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43, |
Vidyakumar Athota | adfe4e3 | 2013-12-13 14:51:26 -0800 | [diff] [blame] | 301 | [SND_DEVICE_IN_VOICE_SPEAKER_QMIC] = 19, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 302 | [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16, |
| 303 | [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36, |
| 304 | [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 305 | [SND_DEVICE_IN_VOICE_REC_MIC] = 4, |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 306 | [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 307 | [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34, |
| 308 | [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41, |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 309 | [SND_DEVICE_IN_USB_HEADSET_MIC] = 44, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 310 | [SND_DEVICE_IN_CAPTURE_FM] = 0, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 311 | [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104, |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 312 | [SND_DEVICE_IN_QUAD_MIC] = 46, |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 313 | [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34, |
| 314 | [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 315 | [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 316 | }; |
| 317 | |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 318 | #define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL) |
| 319 | #define LOW_LATENCY_PLATFORM_DELAY (13*1000LL) |
| 320 | |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 321 | static void set_echo_reference(struct audio_device *adev, bool enable) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 322 | { |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 323 | if (enable) |
| 324 | audio_route_apply_and_update_path(adev->audio_route, "echo-reference"); |
| 325 | else |
| 326 | audio_route_reset_and_update_path(adev->audio_route, "echo-reference"); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 327 | |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 328 | ALOGV("Setting EC Reference: %d", enable); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 329 | } |
| 330 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 331 | static struct csd_data *open_csd_client() |
| 332 | { |
| 333 | struct csd_data *csd = calloc(1, sizeof(struct csd_data)); |
| 334 | |
| 335 | csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW); |
| 336 | if (csd->csd_client == NULL) { |
| 337 | ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT); |
| 338 | goto error; |
| 339 | } else { |
| 340 | ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT); |
| 341 | |
| 342 | csd->deinit = (deinit_t)dlsym(csd->csd_client, |
| 343 | "csd_client_deinit"); |
| 344 | if (csd->deinit == NULL) { |
| 345 | ALOGE("%s: dlsym error %s for csd_client_deinit", __func__, |
| 346 | dlerror()); |
| 347 | goto error; |
| 348 | } |
| 349 | csd->disable_device = (disable_device_t)dlsym(csd->csd_client, |
| 350 | "csd_client_disable_device"); |
| 351 | if (csd->disable_device == NULL) { |
| 352 | ALOGE("%s: dlsym error %s for csd_client_disable_device", |
| 353 | __func__, dlerror()); |
| 354 | goto error; |
| 355 | } |
| 356 | csd->enable_device = (enable_device_t)dlsym(csd->csd_client, |
| 357 | "csd_client_enable_device"); |
| 358 | if (csd->enable_device == NULL) { |
| 359 | ALOGE("%s: dlsym error %s for csd_client_enable_device", |
| 360 | __func__, dlerror()); |
| 361 | goto error; |
| 362 | } |
| 363 | csd->start_voice = (start_voice_t)dlsym(csd->csd_client, |
| 364 | "csd_client_start_voice"); |
| 365 | if (csd->start_voice == NULL) { |
| 366 | ALOGE("%s: dlsym error %s for csd_client_start_voice", |
| 367 | __func__, dlerror()); |
| 368 | goto error; |
| 369 | } |
| 370 | csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client, |
| 371 | "csd_client_stop_voice"); |
| 372 | if (csd->stop_voice == NULL) { |
| 373 | ALOGE("%s: dlsym error %s for csd_client_stop_voice", |
| 374 | __func__, dlerror()); |
| 375 | goto error; |
| 376 | } |
| 377 | csd->volume = (volume_t)dlsym(csd->csd_client, |
| 378 | "csd_client_volume"); |
| 379 | if (csd->volume == NULL) { |
| 380 | ALOGE("%s: dlsym error %s for csd_client_volume", |
| 381 | __func__, dlerror()); |
| 382 | goto error; |
| 383 | } |
| 384 | csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client, |
| 385 | "csd_client_mic_mute"); |
| 386 | if (csd->mic_mute == NULL) { |
| 387 | ALOGE("%s: dlsym error %s for csd_client_mic_mute", |
| 388 | __func__, dlerror()); |
| 389 | goto error; |
| 390 | } |
| 391 | csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client, |
| 392 | "csd_client_slow_talk"); |
| 393 | if (csd->slow_talk == NULL) { |
| 394 | ALOGE("%s: dlsym error %s for csd_client_slow_talk", |
| 395 | __func__, dlerror()); |
| 396 | goto error; |
| 397 | } |
| 398 | csd->start_playback = (start_playback_t)dlsym(csd->csd_client, |
| 399 | "csd_client_start_playback"); |
| 400 | if (csd->start_playback == NULL) { |
| 401 | ALOGE("%s: dlsym error %s for csd_client_start_playback", |
| 402 | __func__, dlerror()); |
| 403 | goto error; |
| 404 | } |
| 405 | csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client, |
| 406 | "csd_client_stop_playback"); |
| 407 | if (csd->stop_playback == NULL) { |
| 408 | ALOGE("%s: dlsym error %s for csd_client_stop_playback", |
| 409 | __func__, dlerror()); |
| 410 | goto error; |
| 411 | } |
| 412 | csd->start_record = (start_record_t)dlsym(csd->csd_client, |
| 413 | "csd_client_start_record"); |
| 414 | if (csd->start_record == NULL) { |
| 415 | ALOGE("%s: dlsym error %s for csd_client_start_record", |
| 416 | __func__, dlerror()); |
| 417 | goto error; |
| 418 | } |
| 419 | csd->stop_record = (stop_record_t)dlsym(csd->csd_client, |
| 420 | "csd_client_stop_record"); |
| 421 | if (csd->stop_record == NULL) { |
| 422 | ALOGE("%s: dlsym error %s for csd_client_stop_record", |
| 423 | __func__, dlerror()); |
| 424 | goto error; |
| 425 | } |
| 426 | csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init"); |
| 427 | |
| 428 | if (csd->init == NULL) { |
| 429 | ALOGE("%s: dlsym error %s for csd_client_init", |
| 430 | __func__, dlerror()); |
| 431 | goto error; |
| 432 | } else { |
| 433 | csd->init(); |
| 434 | } |
| 435 | } |
| 436 | return csd; |
| 437 | |
| 438 | error: |
| 439 | free(csd); |
| 440 | csd = NULL; |
| 441 | return csd; |
| 442 | } |
| 443 | |
| 444 | void close_csd_client(struct csd_data *csd) |
| 445 | { |
| 446 | if (csd != NULL) { |
| 447 | csd->deinit(); |
| 448 | dlclose(csd->csd_client); |
| 449 | free(csd); |
| 450 | csd = NULL; |
| 451 | } |
| 452 | } |
| 453 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 454 | void *platform_init(struct audio_device *adev) |
| 455 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 456 | char platform[PROPERTY_VALUE_MAX]; |
| 457 | char baseband[PROPERTY_VALUE_MAX]; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 458 | char value[PROPERTY_VALUE_MAX]; |
Apoorv Raghuvanshi | 84fa2fe | 2013-12-04 11:57:47 -0800 | [diff] [blame] | 459 | struct platform_data *my_data = NULL; |
| 460 | int retry_num = 0, snd_card_num = 0; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 461 | const char *snd_card_name; |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 462 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 463 | my_data = calloc(1, sizeof(struct platform_data)); |
| 464 | |
Apoorv Raghuvanshi | 84fa2fe | 2013-12-04 11:57:47 -0800 | [diff] [blame] | 465 | while (snd_card_num < MAX_SND_CARD) { |
| 466 | adev->mixer = mixer_open(snd_card_num); |
| 467 | |
| 468 | while (!adev->mixer && retry_num < RETRY_NUMBER) { |
| 469 | usleep(RETRY_US); |
| 470 | adev->mixer = mixer_open(snd_card_num); |
| 471 | retry_num++; |
| 472 | } |
| 473 | |
| 474 | if (!adev->mixer) { |
| 475 | ALOGE("%s: Unable to open the mixer card: %d", __func__, |
| 476 | snd_card_num); |
| 477 | retry_num = 0; |
| 478 | snd_card_num++; |
| 479 | continue; |
| 480 | } |
| 481 | |
| 482 | snd_card_name = mixer_get_name(adev->mixer); |
| 483 | ALOGV("%s: snd_card_name: %s", __func__, snd_card_name); |
| 484 | |
| 485 | my_data->hw_info = hw_info_init(snd_card_name); |
| 486 | if (!my_data->hw_info) { |
| 487 | ALOGE("%s: Failed to init hardware info", __func__); |
| 488 | } else { |
| 489 | if (audio_extn_read_xml(adev, snd_card_num, MIXER_XML_PATH, |
| 490 | MIXER_XML_PATH_AUXPCM) == -ENOSYS) |
| 491 | adev->audio_route = audio_route_init(snd_card_num, |
| 492 | MIXER_XML_PATH); |
| 493 | if (!adev->audio_route) { |
| 494 | ALOGE("%s: Failed to init audio route controls, aborting.", |
| 495 | __func__); |
| 496 | free(my_data); |
| 497 | return NULL; |
| 498 | } |
| 499 | adev->snd_card = snd_card_num; |
| 500 | ALOGD("%s: Opened sound card:%d", __func__, snd_card_num); |
| 501 | break; |
| 502 | } |
| 503 | retry_num = 0; |
| 504 | snd_card_num++; |
| 505 | } |
| 506 | |
| 507 | if (snd_card_num >= MAX_SND_CARD) { |
| 508 | ALOGE("%s: Unable to find correct sound card, aborting.", __func__); |
| 509 | free(my_data); |
| 510 | return NULL; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 511 | } |
| 512 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 513 | my_data->adev = adev; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 514 | my_data->btsco_sample_rate = SAMPLE_RATE_8KHZ; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 515 | my_data->fluence_in_spkr_mode = false; |
| 516 | my_data->fluence_in_voice_call = false; |
| 517 | my_data->fluence_in_voice_rec = false; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 518 | my_data->fluence_in_audio_rec = false; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 519 | my_data->fluence_type = FLUENCE_NONE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 520 | |
Venkata Narendra Kumar Gutta | 9c38b18 | 2014-03-27 17:39:57 +0530 | [diff] [blame] | 521 | property_get("ro.qc.sdk.audio.fluencetype", my_data->fluence_cap, ""); |
| 522 | if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro"))) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 523 | my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC; |
Venkata Narendra Kumar Gutta | 9c38b18 | 2014-03-27 17:39:57 +0530 | [diff] [blame] | 524 | } else if (!strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 525 | my_data->fluence_type = FLUENCE_DUAL_MIC; |
| 526 | } else { |
| 527 | my_data->fluence_type = FLUENCE_NONE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 528 | } |
| 529 | |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 530 | if (my_data->fluence_type != FLUENCE_NONE) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 531 | property_get("persist.audio.fluence.voicecall",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 532 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 533 | my_data->fluence_in_voice_call = true; |
| 534 | } |
| 535 | |
| 536 | property_get("persist.audio.fluence.voicerec",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 537 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 538 | my_data->fluence_in_voice_rec = true; |
| 539 | } |
| 540 | |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 541 | property_get("persist.audio.fluence.audiorec",value,""); |
| 542 | if (!strncmp("true", value, sizeof("true"))) { |
| 543 | my_data->fluence_in_audio_rec = true; |
| 544 | } |
| 545 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 546 | property_get("persist.audio.fluence.speaker",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 547 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 548 | my_data->fluence_in_spkr_mode = true; |
| 549 | } |
| 550 | } |
| 551 | |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 552 | my_data->voice_feature_set = VOICE_FEATURE_SET_DEFAULT; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 553 | my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW); |
| 554 | if (my_data->acdb_handle == NULL) { |
| 555 | ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER); |
| 556 | } else { |
| 557 | ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER); |
| 558 | my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle, |
| 559 | "acdb_loader_deallocate_ACDB"); |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 560 | if (!my_data->acdb_deallocate) |
| 561 | ALOGE("%s: Could not find the symbol acdb_loader_deallocate_ACDB from %s", |
| 562 | __func__, LIB_ACDB_LOADER); |
| 563 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 564 | my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle, |
| 565 | "acdb_loader_send_audio_cal"); |
| 566 | if (!my_data->acdb_send_audio_cal) |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 567 | ALOGE("%s: Could not find the symbol acdb_send_audio_cal from %s", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 568 | __func__, LIB_ACDB_LOADER); |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 569 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 570 | my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle, |
| 571 | "acdb_loader_send_voice_cal"); |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 572 | if (!my_data->acdb_send_voice_cal) |
| 573 | ALOGE("%s: Could not find the symbol acdb_loader_send_voice_cal from %s", |
| 574 | __func__, LIB_ACDB_LOADER); |
| 575 | |
| 576 | my_data->acdb_reload_vocvoltable = (acdb_reload_vocvoltable_t)dlsym(my_data->acdb_handle, |
| 577 | "acdb_loader_reload_vocvoltable"); |
| 578 | if (!my_data->acdb_reload_vocvoltable) |
| 579 | ALOGE("%s: Could not find the symbol acdb_loader_reload_vocvoltable from %s", |
| 580 | __func__, LIB_ACDB_LOADER); |
| 581 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 582 | my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle, |
| 583 | "acdb_loader_init_ACDB"); |
| 584 | if (my_data->acdb_init == NULL) |
| 585 | ALOGE("%s: dlsym error %s for acdb_loader_init_ACDB", __func__, dlerror()); |
| 586 | else |
| 587 | my_data->acdb_init(); |
| 588 | } |
| 589 | |
Ben Romberger | a167371 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 590 | /* Initialize ACDB ID's */ |
| 591 | platform_info_init(); |
| 592 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 593 | /* If platform is apq8084 and baseband is MDM, load CSD Client specific |
| 594 | * symbols. Voice call is handled by MDM and apps processor talks to |
| 595 | * MDM through CSD Client |
| 596 | */ |
| 597 | property_get("ro.board.platform", platform, ""); |
| 598 | property_get("ro.baseband", baseband, ""); |
| 599 | if (!strncmp("apq8084", platform, sizeof("apq8084")) && |
| 600 | !strncmp("mdm", baseband, sizeof("mdm"))) { |
| 601 | my_data->csd = open_csd_client(); |
| 602 | } |
| 603 | |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 604 | /* init usb */ |
| 605 | audio_extn_usb_init(adev); |
Apoorv Raghuvanshi | 84fa2fe | 2013-12-04 11:57:47 -0800 | [diff] [blame] | 606 | /* update sound cards appropriately */ |
| 607 | audio_extn_usb_set_proxy_sound_card(adev->snd_card); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 608 | |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 609 | /* Read one time ssr property */ |
Mingming Yin | 49be803 | 2013-12-19 12:51:25 -0800 | [diff] [blame] | 610 | audio_extn_ssr_update_enabled(); |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 611 | audio_extn_spkr_prot_init(adev); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 612 | return my_data; |
| 613 | } |
| 614 | |
| 615 | void platform_deinit(void *platform) |
| 616 | { |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 617 | struct platform_data *my_data = (struct platform_data *)platform; |
| 618 | |
| 619 | hw_info_deinit(my_data->hw_info); |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 620 | close_csd_client(my_data->csd); |
| 621 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 622 | free(platform); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 623 | /* deinit usb */ |
| 624 | audio_extn_usb_deinit(); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | const char *platform_get_snd_device_name(snd_device_t snd_device) |
| 628 | { |
| 629 | if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) |
| 630 | return device_table[snd_device]; |
| 631 | else |
| 632 | return ""; |
| 633 | } |
| 634 | |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 635 | int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device, |
| 636 | char *device_name) |
| 637 | { |
| 638 | struct platform_data *my_data = (struct platform_data *)platform; |
| 639 | |
| 640 | if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) { |
| 641 | strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE); |
| 642 | hw_info_append_hw_type(my_data->hw_info, snd_device, device_name); |
| 643 | } else { |
| 644 | strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE); |
| 645 | return -EINVAL; |
| 646 | } |
| 647 | |
| 648 | return 0; |
| 649 | } |
| 650 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 651 | void platform_add_backend_name(char *mixer_path, snd_device_t snd_device) |
| 652 | { |
| 653 | if (snd_device == SND_DEVICE_IN_BT_SCO_MIC) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 654 | strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH); |
| 655 | else if (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB) |
| 656 | strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 657 | else if(snd_device == SND_DEVICE_OUT_BT_SCO) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 658 | strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH); |
| 659 | else if(snd_device == SND_DEVICE_OUT_BT_SCO_WB) |
| 660 | strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 661 | else if (snd_device == SND_DEVICE_OUT_HDMI) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 662 | strlcat(mixer_path, " hdmi", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 663 | else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI) |
| 664 | strcat(mixer_path, " speaker-and-hdmi"); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 665 | else if (snd_device == SND_DEVICE_OUT_AFE_PROXY) |
| 666 | strlcat(mixer_path, " afe-proxy", MIXER_PATH_MAX_LENGTH); |
| 667 | else if (snd_device == SND_DEVICE_OUT_USB_HEADSET) |
| 668 | strlcat(mixer_path, " usb-headphones", MIXER_PATH_MAX_LENGTH); |
| 669 | else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET) |
| 670 | strlcat(mixer_path, " speaker-and-usb-headphones", |
| 671 | MIXER_PATH_MAX_LENGTH); |
| 672 | else if (snd_device == SND_DEVICE_IN_USB_HEADSET_MIC) |
| 673 | strlcat(mixer_path, " usb-headset-mic", MIXER_PATH_MAX_LENGTH); |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 674 | else if (snd_device == SND_DEVICE_IN_CAPTURE_FM) |
| 675 | strlcat(mixer_path, " capture-fm", MIXER_PATH_MAX_LENGTH); |
| 676 | else if (snd_device == SND_DEVICE_OUT_TRANSMISSION_FM) |
| 677 | strlcat(mixer_path, " transmission-fm", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 678 | } |
| 679 | |
| 680 | int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type) |
| 681 | { |
| 682 | int device_id; |
| 683 | if (device_type == PCM_PLAYBACK) |
| 684 | device_id = pcm_device_table[usecase][0]; |
| 685 | else |
| 686 | device_id = pcm_device_table[usecase][1]; |
| 687 | return device_id; |
| 688 | } |
| 689 | |
Venkata Narendra Kumar Gutta | 9c38b18 | 2014-03-27 17:39:57 +0530 | [diff] [blame] | 690 | int platform_set_fluence_type(void *platform, char *value) |
| 691 | { |
| 692 | int ret = 0; |
| 693 | int fluence_type = FLUENCE_NONE; |
| 694 | int fluence_flag = NONE_FLAG; |
| 695 | struct platform_data *my_data = (struct platform_data *)platform; |
| 696 | struct audio_device *adev = my_data->adev; |
| 697 | |
| 698 | ALOGV("%s: fluence type:%d", __func__, my_data->fluence_type); |
| 699 | |
| 700 | /* only dual mic turn on and off is supported as of now through setparameters */ |
| 701 | if (!strncmp(AUDIO_PARAMETER_VALUE_DUALMIC,value, sizeof(AUDIO_PARAMETER_VALUE_DUALMIC))) { |
| 702 | if (!strncmp("fluencepro", my_data->fluence_cap, sizeof("fluencepro")) || |
| 703 | !strncmp("fluence", my_data->fluence_cap, sizeof("fluence"))) { |
| 704 | ALOGV("fluence dualmic feature enabled \n"); |
| 705 | fluence_type = FLUENCE_DUAL_MIC; |
| 706 | fluence_flag = DMIC_FLAG; |
| 707 | } else { |
| 708 | ALOGE("%s: Failed to set DUALMIC", __func__); |
| 709 | ret = -1; |
| 710 | goto done; |
| 711 | } |
| 712 | } else if (!strncmp(AUDIO_PARAMETER_KEY_NO_FLUENCE, value, sizeof(AUDIO_PARAMETER_KEY_NO_FLUENCE))) { |
| 713 | ALOGV("fluence disabled"); |
| 714 | fluence_type = FLUENCE_NONE; |
| 715 | } else { |
| 716 | ALOGE("Invalid fluence value : %s",value); |
| 717 | ret = -1; |
| 718 | goto done; |
| 719 | } |
| 720 | |
| 721 | if (fluence_type != my_data->fluence_type) { |
| 722 | ALOGV("%s: Updating fluence_type to :%d", __func__, fluence_type); |
| 723 | my_data->fluence_type = fluence_type; |
| 724 | adev->acdb_settings = (adev->acdb_settings & FLUENCE_MODE_CLEAR) | fluence_flag; |
| 725 | } |
| 726 | done: |
| 727 | return ret; |
| 728 | } |
| 729 | |
Ben Romberger | a167371 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 730 | int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id) |
| 731 | { |
| 732 | int ret = 0; |
| 733 | |
| 734 | if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) { |
| 735 | ALOGE("%s: Invalid snd_device = %d", |
| 736 | __func__, snd_device); |
| 737 | ret = -EINVAL; |
| 738 | goto done; |
| 739 | } |
| 740 | |
| 741 | acdb_device_table[snd_device] = acdb_id; |
| 742 | done: |
| 743 | return ret; |
| 744 | } |
| 745 | |
Venkata Narendra Kumar Gutta | 9c38b18 | 2014-03-27 17:39:57 +0530 | [diff] [blame] | 746 | int platform_get_fluence_type(void *platform, char *value, uint32_t len) |
| 747 | { |
| 748 | int ret = 0; |
| 749 | struct platform_data *my_data = (struct platform_data *)platform; |
| 750 | |
| 751 | if (my_data->fluence_type == FLUENCE_QUAD_MIC) { |
| 752 | strlcpy(value, "quadmic", len); |
| 753 | } else if (my_data->fluence_type == FLUENCE_DUAL_MIC) { |
| 754 | strlcpy(value, "dualmic", len); |
| 755 | } else if (my_data->fluence_type == FLUENCE_NONE) { |
| 756 | strlcpy(value, "none", len); |
| 757 | } else |
| 758 | ret = -1; |
| 759 | |
| 760 | return ret; |
| 761 | } |
| 762 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 763 | int platform_send_audio_calibration(void *platform, snd_device_t snd_device) |
| 764 | { |
| 765 | struct platform_data *my_data = (struct platform_data *)platform; |
| 766 | int acdb_dev_id, acdb_dev_type; |
| 767 | |
| 768 | acdb_dev_id = acdb_device_table[snd_device]; |
| 769 | if (acdb_dev_id < 0) { |
| 770 | ALOGE("%s: Could not find acdb id for device(%d)", |
| 771 | __func__, snd_device); |
| 772 | return -EINVAL; |
| 773 | } |
| 774 | if (my_data->acdb_send_audio_cal) { |
Eric Laurent | 994a693 | 2013-07-17 11:51:42 -0700 | [diff] [blame] | 775 | ("%s: sending audio calibration for snd_device(%d) acdb_id(%d)", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 776 | __func__, snd_device, acdb_dev_id); |
| 777 | if (snd_device >= SND_DEVICE_OUT_BEGIN && |
| 778 | snd_device < SND_DEVICE_OUT_END) |
| 779 | acdb_dev_type = ACDB_DEV_TYPE_OUT; |
| 780 | else |
| 781 | acdb_dev_type = ACDB_DEV_TYPE_IN; |
| 782 | my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type); |
| 783 | } |
| 784 | return 0; |
| 785 | } |
| 786 | |
| 787 | int platform_switch_voice_call_device_pre(void *platform) |
| 788 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 789 | struct platform_data *my_data = (struct platform_data *)platform; |
| 790 | int ret = 0; |
| 791 | |
Vidyakumar Athota | 1fd2179 | 2013-11-15 14:50:57 -0800 | [diff] [blame] | 792 | if (my_data->csd != NULL && |
| 793 | my_data->adev->mode == AUDIO_MODE_IN_CALL) { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 794 | /* This must be called before disabling mixer controls on APQ side */ |
| 795 | ret = my_data->csd->disable_device(); |
| 796 | if (ret < 0) { |
| 797 | ALOGE("%s: csd_client_disable_device, failed, error %d", |
| 798 | __func__, ret); |
| 799 | } |
| 800 | } |
| 801 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 802 | } |
| 803 | |
| 804 | int platform_switch_voice_call_device_post(void *platform, |
| 805 | snd_device_t out_snd_device, |
| 806 | snd_device_t in_snd_device) |
| 807 | { |
| 808 | struct platform_data *my_data = (struct platform_data *)platform; |
| 809 | int acdb_rx_id, acdb_tx_id; |
| 810 | |
| 811 | if (my_data->acdb_send_voice_cal == NULL) { |
| 812 | ALOGE("%s: dlsym error for acdb_send_voice_call", __func__); |
| 813 | } else { |
Vidyakumar Athota | 1fd2179 | 2013-11-15 14:50:57 -0800 | [diff] [blame] | 814 | acdb_rx_id = acdb_device_table[out_snd_device]; |
| 815 | acdb_tx_id = acdb_device_table[in_snd_device]; |
| 816 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 817 | if (acdb_rx_id > 0 && acdb_tx_id > 0) |
| 818 | my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id); |
| 819 | else |
| 820 | ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, |
| 821 | acdb_rx_id, acdb_tx_id); |
| 822 | } |
| 823 | |
Vidyakumar Athota | 1fd2179 | 2013-11-15 14:50:57 -0800 | [diff] [blame] | 824 | return 0; |
| 825 | } |
| 826 | |
| 827 | int platform_switch_voice_call_usecase_route_post(void *platform, |
| 828 | snd_device_t out_snd_device, |
| 829 | snd_device_t in_snd_device) |
| 830 | { |
| 831 | struct platform_data *my_data = (struct platform_data *)platform; |
| 832 | int acdb_rx_id, acdb_tx_id; |
| 833 | int ret = 0; |
| 834 | |
| 835 | acdb_rx_id = acdb_device_table[out_snd_device]; |
| 836 | acdb_tx_id = acdb_device_table[in_snd_device]; |
| 837 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 838 | if (my_data->csd != NULL) { |
Vidyakumar Athota | 1fd2179 | 2013-11-15 14:50:57 -0800 | [diff] [blame] | 839 | if (acdb_rx_id > 0 && acdb_tx_id > 0) { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 840 | ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id, |
| 841 | my_data->adev->acdb_settings); |
| 842 | if (ret < 0) { |
| 843 | ALOGE("%s: csd_enable_device, failed, error %d", |
| 844 | __func__, ret); |
| 845 | } |
| 846 | } else { |
| 847 | ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, |
| 848 | acdb_rx_id, acdb_tx_id); |
| 849 | } |
| 850 | } |
| 851 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 852 | } |
| 853 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 854 | int platform_start_voice_call(void *platform, uint32_t vsid) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 855 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 856 | struct platform_data *my_data = (struct platform_data *)platform; |
| 857 | int ret = 0; |
| 858 | |
| 859 | if (my_data->csd != NULL) { |
| 860 | ret = my_data->csd->start_voice(vsid); |
| 861 | if (ret < 0) { |
| 862 | ALOGE("%s: csd_start_voice error %d\n", __func__, ret); |
| 863 | } |
| 864 | } |
| 865 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 866 | } |
| 867 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 868 | int platform_stop_voice_call(void *platform, uint32_t vsid) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 869 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 870 | struct platform_data *my_data = (struct platform_data *)platform; |
| 871 | int ret = 0; |
| 872 | |
| 873 | if (my_data->csd != NULL) { |
| 874 | ret = my_data->csd->stop_voice(vsid); |
| 875 | if (ret < 0) { |
| 876 | ALOGE("%s: csd_stop_voice error %d\n", __func__, ret); |
| 877 | } |
| 878 | } |
| 879 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 880 | } |
| 881 | |
| 882 | int platform_set_voice_volume(void *platform, int volume) |
| 883 | { |
| 884 | struct platform_data *my_data = (struct platform_data *)platform; |
| 885 | struct audio_device *adev = my_data->adev; |
| 886 | struct mixer_ctl *ctl; |
sangwoo | 53b2cf0 | 2013-07-25 19:18:44 -0700 | [diff] [blame] | 887 | const char *mixer_ctl_name = "Voice Rx Gain"; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 888 | int vol_index = 0, ret = 0; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 889 | uint32_t set_values[ ] = {0, |
| 890 | ALL_SESSION_VSID, |
| 891 | DEFAULT_VOLUME_RAMP_DURATION_MS}; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 892 | |
| 893 | // Voice volume levels are mapped to adsp volume levels as follows. |
| 894 | // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0 |
| 895 | // But this values don't changed in kernel. So, below change is need. |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 896 | vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX); |
| 897 | set_values[0] = vol_index; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 898 | |
| 899 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 900 | if (!ctl) { |
| 901 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 902 | __func__, mixer_ctl_name); |
| 903 | return -EINVAL; |
| 904 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 905 | ALOGV("Setting voice volume index: %d", set_values[0]); |
| 906 | mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 907 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 908 | if (my_data->csd != NULL) { |
| 909 | ret = my_data->csd->volume(ALL_SESSION_VSID, volume); |
| 910 | if (ret < 0) { |
| 911 | ALOGE("%s: csd_volume error %d", __func__, ret); |
| 912 | } |
| 913 | } |
| 914 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 915 | } |
| 916 | |
| 917 | int platform_set_mic_mute(void *platform, bool state) |
| 918 | { |
| 919 | struct platform_data *my_data = (struct platform_data *)platform; |
| 920 | struct audio_device *adev = my_data->adev; |
| 921 | struct mixer_ctl *ctl; |
| 922 | const char *mixer_ctl_name = "Voice Tx Mute"; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 923 | int ret = 0; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 924 | uint32_t set_values[ ] = {0, |
| 925 | ALL_SESSION_VSID, |
| 926 | DEFAULT_VOLUME_RAMP_DURATION_MS}; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 927 | |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 928 | set_values[0] = state; |
| 929 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 930 | if (!ctl) { |
| 931 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 932 | __func__, mixer_ctl_name); |
| 933 | return -EINVAL; |
| 934 | } |
| 935 | ALOGV("Setting voice mute state: %d", state); |
| 936 | mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 937 | |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 938 | if (my_data->csd != NULL) { |
| 939 | ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state); |
| 940 | if (ret < 0) { |
| 941 | ALOGE("%s: csd_mic_mute error %d", __func__, ret); |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 942 | } |
| 943 | } |
| 944 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 945 | } |
| 946 | |
Shiv Maliyappanahalli | 575c155 | 2014-03-07 15:31:55 -0800 | [diff] [blame] | 947 | int platform_set_device_mute(void *platform, bool state, char *dir) |
| 948 | { |
| 949 | struct platform_data *my_data = (struct platform_data *)platform; |
| 950 | struct audio_device *adev = my_data->adev; |
| 951 | struct mixer_ctl *ctl; |
| 952 | char *mixer_ctl_name = NULL; |
| 953 | int ret = 0; |
| 954 | uint32_t set_values[ ] = {0, |
| 955 | ALL_SESSION_VSID, |
| 956 | 0}; |
| 957 | if(dir == NULL) { |
| 958 | ALOGE("%s: Invalid direction:%s", __func__, dir); |
| 959 | return -EINVAL; |
| 960 | } |
| 961 | |
| 962 | if (!strncmp("rx", dir, sizeof("rx"))) { |
| 963 | mixer_ctl_name = "Voice Rx Device Mute"; |
| 964 | } else if (!strncmp("tx", dir, sizeof("tx"))) { |
| 965 | mixer_ctl_name = "Voice Tx Device Mute"; |
| 966 | } else { |
| 967 | return -EINVAL; |
| 968 | } |
| 969 | |
| 970 | set_values[0] = state; |
| 971 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 972 | if (!ctl) { |
| 973 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 974 | __func__, mixer_ctl_name); |
| 975 | return -EINVAL; |
| 976 | } |
| 977 | |
| 978 | ALOGV("%s: Setting device mute state: %d, mixer ctrl:%s", |
| 979 | __func__,state, mixer_ctl_name); |
| 980 | mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
| 981 | |
| 982 | return ret; |
| 983 | } |
| 984 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 985 | snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices) |
| 986 | { |
| 987 | struct platform_data *my_data = (struct platform_data *)platform; |
| 988 | struct audio_device *adev = my_data->adev; |
| 989 | audio_mode_t mode = adev->mode; |
| 990 | snd_device_t snd_device = SND_DEVICE_NONE; |
| 991 | |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 992 | audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? |
| 993 | AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; |
| 994 | int channel_count = popcount(channel_mask); |
| 995 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 996 | ALOGV("%s: enter: output devices(%#x)", __func__, devices); |
| 997 | if (devices == AUDIO_DEVICE_NONE || |
| 998 | devices & AUDIO_DEVICE_BIT_IN) { |
| 999 | ALOGV("%s: Invalid output devices (%#x)", __func__, devices); |
| 1000 | goto exit; |
| 1001 | } |
| 1002 | |
Mingming Yin | 4a72d65 | 2014-01-03 18:54:18 -0800 | [diff] [blame] | 1003 | if (popcount(devices) == 2) { |
| 1004 | if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE | |
| 1005 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 1006 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; |
| 1007 | } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET | |
| 1008 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 1009 | if (audio_extn_get_anc_enabled()) |
| 1010 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET; |
| 1011 | else |
| 1012 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; |
| 1013 | } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL | |
| 1014 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 1015 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI; |
| 1016 | } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET | |
| 1017 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 1018 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET; |
| 1019 | } else { |
| 1020 | ALOGE("%s: Invalid combo device(%#x)", __func__, devices); |
| 1021 | goto exit; |
| 1022 | } |
| 1023 | if (snd_device != SND_DEVICE_NONE) { |
| 1024 | goto exit; |
| 1025 | } |
| 1026 | } |
| 1027 | |
| 1028 | if (popcount(devices) != 1) { |
| 1029 | ALOGE("%s: Invalid output devices(%#x)", __func__, devices); |
| 1030 | goto exit; |
| 1031 | } |
| 1032 | |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 1033 | if ((mode == AUDIO_MODE_IN_CALL) || |
| 1034 | voice_extn_compress_voip_is_active(adev)) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1035 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 1036 | devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 1037 | if ((adev->voice.tty_mode != TTY_MODE_OFF) && |
| 1038 | !voice_extn_compress_voip_is_active(adev)) { |
| 1039 | switch (adev->voice.tty_mode) { |
| 1040 | case TTY_MODE_FULL: |
| 1041 | snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES; |
| 1042 | break; |
| 1043 | case TTY_MODE_VCO: |
| 1044 | snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES; |
| 1045 | break; |
| 1046 | case TTY_MODE_HCO: |
| 1047 | snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET; |
| 1048 | break; |
| 1049 | default: |
| 1050 | ALOGE("%s: Invalid TTY mode (%#x)", |
| 1051 | __func__, adev->voice.tty_mode); |
| 1052 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1053 | } else if (audio_extn_get_anc_enabled()) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 1054 | if (audio_extn_should_use_fb_anc()) |
| 1055 | snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET; |
| 1056 | else |
| 1057 | snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1058 | } else { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1059 | snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1060 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1061 | } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1062 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1063 | snd_device = SND_DEVICE_OUT_BT_SCO_WB; |
| 1064 | else |
| 1065 | snd_device = SND_DEVICE_OUT_BT_SCO; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1066 | } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { |
| 1067 | snd_device = SND_DEVICE_OUT_VOICE_SPEAKER; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1068 | } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 1069 | devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
| 1070 | snd_device = SND_DEVICE_OUT_USB_HEADSET; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 1071 | } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { |
| 1072 | snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1073 | } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { |
Ravi Kumar Alamanda | ceb4082 | 2013-11-06 11:01:47 -0800 | [diff] [blame] | 1074 | if (audio_extn_should_use_handset_anc(channel_count)) |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 1075 | snd_device = SND_DEVICE_OUT_ANC_HANDSET; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1076 | else |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1077 | snd_device = SND_DEVICE_OUT_VOICE_HANDSET; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1078 | } |
| 1079 | if (snd_device != SND_DEVICE_NONE) { |
| 1080 | goto exit; |
| 1081 | } |
| 1082 | } |
| 1083 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1084 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 1085 | devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 1086 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET |
| 1087 | && audio_extn_get_anc_enabled()) { |
| 1088 | if (audio_extn_should_use_fb_anc()) |
| 1089 | snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET; |
| 1090 | else |
| 1091 | snd_device = SND_DEVICE_OUT_ANC_HEADSET; |
| 1092 | } |
| 1093 | else |
| 1094 | snd_device = SND_DEVICE_OUT_HEADPHONES; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1095 | } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { |
| 1096 | if (adev->speaker_lr_swap) |
| 1097 | snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE; |
| 1098 | else |
| 1099 | snd_device = SND_DEVICE_OUT_SPEAKER; |
| 1100 | } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1101 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1102 | snd_device = SND_DEVICE_OUT_BT_SCO_WB; |
| 1103 | else |
| 1104 | snd_device = SND_DEVICE_OUT_BT_SCO; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1105 | } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { |
| 1106 | snd_device = SND_DEVICE_OUT_HDMI ; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1107 | } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 1108 | devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
Mingming Yin | 5bdb705 | 2014-03-05 17:45:03 -0800 | [diff] [blame] | 1109 | ALOGD("%s: setting USB hadset channel capability(2) for Proxy", __func__); |
| 1110 | audio_extn_set_afe_proxy_channel_mixer(adev, 2); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1111 | snd_device = SND_DEVICE_OUT_USB_HEADSET; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 1112 | } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { |
| 1113 | snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1114 | } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { |
| 1115 | snd_device = SND_DEVICE_OUT_HANDSET; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1116 | } else if (devices & AUDIO_DEVICE_OUT_PROXY) { |
Mingming Yin | 5bdb705 | 2014-03-05 17:45:03 -0800 | [diff] [blame] | 1117 | channel_count = audio_extn_get_afe_proxy_channel_count(); |
| 1118 | ALOGD("%s: setting sink capability(%d) for Proxy", __func__, channel_count); |
| 1119 | audio_extn_set_afe_proxy_channel_mixer(adev, channel_count); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1120 | snd_device = SND_DEVICE_OUT_AFE_PROXY; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1121 | } else { |
| 1122 | ALOGE("%s: Unknown device(s) %#x", __func__, devices); |
| 1123 | } |
| 1124 | exit: |
| 1125 | ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]); |
| 1126 | return snd_device; |
| 1127 | } |
| 1128 | |
| 1129 | snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device) |
| 1130 | { |
| 1131 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1132 | struct audio_device *adev = my_data->adev; |
| 1133 | audio_source_t source = (adev->active_input == NULL) ? |
| 1134 | AUDIO_SOURCE_DEFAULT : adev->active_input->source; |
| 1135 | |
| 1136 | audio_mode_t mode = adev->mode; |
| 1137 | audio_devices_t in_device = ((adev->active_input == NULL) ? |
| 1138 | AUDIO_DEVICE_NONE : adev->active_input->device) |
| 1139 | & ~AUDIO_DEVICE_BIT_IN; |
| 1140 | audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? |
| 1141 | AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; |
| 1142 | snd_device_t snd_device = SND_DEVICE_NONE; |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 1143 | int channel_count = popcount(channel_mask); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1144 | |
| 1145 | ALOGV("%s: enter: out_device(%#x) in_device(%#x)", |
| 1146 | __func__, out_device, in_device); |
Helen Zeng | 067b96b | 2013-11-26 12:10:29 -0800 | [diff] [blame] | 1147 | if ((out_device != AUDIO_DEVICE_NONE) && ((mode == AUDIO_MODE_IN_CALL) || |
Satya Krishna Pindiproli | fa51878 | 2014-05-21 14:45:28 +0530 | [diff] [blame] | 1148 | voice_extn_compress_voip_is_active(adev) || audio_extn_hfp_is_active(adev))) { |
Narsinga Rao Chella | 05573b7 | 2013-11-15 15:21:40 -0800 | [diff] [blame] | 1149 | if ((adev->voice.tty_mode != TTY_MODE_OFF) && |
| 1150 | !voice_extn_compress_voip_is_active(adev)) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1151 | if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 1152 | out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1153 | switch (adev->voice.tty_mode) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1154 | case TTY_MODE_FULL: |
| 1155 | snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC; |
| 1156 | break; |
| 1157 | case TTY_MODE_VCO: |
| 1158 | snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC; |
| 1159 | break; |
| 1160 | case TTY_MODE_HCO: |
| 1161 | snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC; |
| 1162 | break; |
| 1163 | default: |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1164 | ALOGE("%s: Invalid TTY mode (%#x)", |
| 1165 | __func__, adev->voice.tty_mode); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1166 | } |
| 1167 | goto exit; |
| 1168 | } |
| 1169 | } |
| 1170 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE || |
| 1171 | out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 1172 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE && |
| 1173 | audio_extn_should_use_handset_anc(channel_count)) { |
| 1174 | snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC; |
| 1175 | } else if (my_data->fluence_type == FLUENCE_NONE || |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1176 | my_data->fluence_in_voice_call == false) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1177 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1178 | set_echo_reference(adev, true); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1179 | } else { |
Ravi Kumar Alamanda | ceb4082 | 2013-11-06 11:01:47 -0800 | [diff] [blame] | 1180 | snd_device = SND_DEVICE_IN_VOICE_DMIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1181 | adev->acdb_settings |= DMIC_FLAG; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1182 | } |
| 1183 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
| 1184 | snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC; |
Anish Kumar | b692841 | 2014-06-12 23:16:32 -0700 | [diff] [blame^] | 1185 | set_echo_reference(adev, true); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1186 | } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1187 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1188 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 1189 | else |
| 1190 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1191 | } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1192 | if (my_data->fluence_type != FLUENCE_NONE && |
| 1193 | my_data->fluence_in_voice_call && |
| 1194 | my_data->fluence_in_spkr_mode) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1195 | if(my_data->fluence_type & FLUENCE_QUAD_MIC) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1196 | adev->acdb_settings |= QMIC_FLAG; |
| 1197 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1198 | } else { |
| 1199 | adev->acdb_settings |= DMIC_FLAG; |
| 1200 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1201 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1202 | } else { |
| 1203 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC; |
Anish Kumar | b692841 | 2014-06-12 23:16:32 -0700 | [diff] [blame^] | 1204 | set_echo_reference(adev, true); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1205 | } |
| 1206 | } |
| 1207 | } else if (source == AUDIO_SOURCE_CAMCORDER) { |
| 1208 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC || |
| 1209 | in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1210 | snd_device = SND_DEVICE_IN_CAMCORDER_MIC; |
| 1211 | } |
| 1212 | } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) { |
| 1213 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1214 | if (channel_count == 2) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1215 | snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 1216 | adev->acdb_settings |= DMIC_FLAG; |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1217 | } else if (adev->active_input->enable_ns) |
| 1218 | snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS; |
| 1219 | else if (my_data->fluence_type != FLUENCE_NONE && |
| 1220 | my_data->fluence_in_voice_rec) { |
| 1221 | snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE; |
| 1222 | adev->acdb_settings |= DMIC_FLAG; |
| 1223 | } else { |
| 1224 | snd_device = SND_DEVICE_IN_VOICE_REC_MIC; |
| 1225 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1226 | } |
| 1227 | } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION) { |
| 1228 | if (out_device & AUDIO_DEVICE_OUT_SPEAKER) |
| 1229 | in_device = AUDIO_DEVICE_IN_BACK_MIC; |
| 1230 | if (adev->active_input) { |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1231 | if (adev->active_input->enable_aec && |
| 1232 | adev->active_input->enable_ns) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1233 | if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1234 | if (my_data->fluence_type & FLUENCE_DUAL_MIC && |
| 1235 | my_data->fluence_in_spkr_mode) { |
| 1236 | snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS; |
| 1237 | adev->acdb_settings |= DMIC_FLAG; |
| 1238 | } else |
| 1239 | snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1240 | } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1241 | if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
| 1242 | snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS; |
| 1243 | adev->acdb_settings |= DMIC_FLAG; |
| 1244 | } else |
| 1245 | snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1246 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1247 | snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1248 | } |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1249 | set_echo_reference(adev, true); |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1250 | } else if (adev->active_input->enable_aec) { |
| 1251 | if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1252 | if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
| 1253 | snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC; |
| 1254 | adev->acdb_settings |= DMIC_FLAG; |
| 1255 | } else |
| 1256 | snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC; |
| 1257 | } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
| 1258 | if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
| 1259 | snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC; |
| 1260 | adev->acdb_settings |= DMIC_FLAG; |
| 1261 | } else |
| 1262 | snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC; |
| 1263 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
| 1264 | snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; |
| 1265 | } |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1266 | set_echo_reference(adev, true); |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1267 | } else if (adev->active_input->enable_ns) { |
| 1268 | if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1269 | if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
| 1270 | snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS; |
| 1271 | adev->acdb_settings |= DMIC_FLAG; |
| 1272 | } else |
| 1273 | snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS; |
| 1274 | } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
| 1275 | if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
| 1276 | snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS; |
| 1277 | adev->acdb_settings |= DMIC_FLAG; |
| 1278 | } else |
| 1279 | snd_device = SND_DEVICE_IN_HANDSET_MIC_NS; |
| 1280 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
| 1281 | snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE; |
| 1282 | } |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1283 | set_echo_reference(adev, false); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1284 | } else |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1285 | set_echo_reference(adev, false); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1286 | } |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1287 | } else if (source == AUDIO_SOURCE_MIC) { |
Apoorv Raghuvanshi | c053654 | 2013-11-14 16:25:59 -0800 | [diff] [blame] | 1288 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC && |
| 1289 | channel_count == 1 ) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1290 | if(my_data->fluence_type & FLUENCE_DUAL_MIC && |
Ravi Kumar Alamanda | 31cf24c | 2014-03-07 11:40:24 -0800 | [diff] [blame] | 1291 | my_data->fluence_in_audio_rec) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1292 | snd_device = SND_DEVICE_IN_HANDSET_DMIC; |
Anish Kumar | 674837a | 2014-04-17 12:42:20 -0700 | [diff] [blame] | 1293 | set_echo_reference(adev, true); |
Ravi Kumar Alamanda | 31cf24c | 2014-03-07 11:40:24 -0800 | [diff] [blame] | 1294 | } |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1295 | } |
Mingming Yin | ab42978 | 2013-11-07 11:16:55 -0800 | [diff] [blame] | 1296 | } else if (source == AUDIO_SOURCE_FM_RX || |
Ravi Kumar Alamanda | 198185e | 2013-11-07 15:42:19 -0800 | [diff] [blame] | 1297 | source == AUDIO_SOURCE_FM_RX_A2DP) { |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1298 | snd_device = SND_DEVICE_IN_CAPTURE_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1299 | } else if (source == AUDIO_SOURCE_DEFAULT) { |
| 1300 | goto exit; |
| 1301 | } |
| 1302 | |
| 1303 | |
| 1304 | if (snd_device != SND_DEVICE_NONE) { |
| 1305 | goto exit; |
| 1306 | } |
| 1307 | |
| 1308 | if (in_device != AUDIO_DEVICE_NONE && |
| 1309 | !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) && |
| 1310 | !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) { |
| 1311 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 1312 | if (audio_extn_ssr_get_enabled() && channel_count == 6) |
| 1313 | snd_device = SND_DEVICE_IN_QUAD_MIC; |
Walter Yang | f8a5d0a | 2014-01-17 11:24:23 +0800 | [diff] [blame] | 1314 | else if (my_data->fluence_type & (FLUENCE_DUAL_MIC | FLUENCE_QUAD_MIC) && |
| 1315 | channel_count == 2) |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 1316 | snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC; |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 1317 | else |
| 1318 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1319 | } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1320 | snd_device = SND_DEVICE_IN_SPEAKER_MIC; |
| 1321 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
| 1322 | snd_device = SND_DEVICE_IN_HEADSET_MIC; |
| 1323 | } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1324 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1325 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 1326 | else |
| 1327 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1328 | } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) { |
| 1329 | snd_device = SND_DEVICE_IN_HDMI_MIC; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1330 | } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET || |
| 1331 | in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) { |
| 1332 | snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 1333 | } else if (in_device & AUDIO_DEVICE_IN_FM_RX) { |
| 1334 | snd_device = SND_DEVICE_IN_CAPTURE_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1335 | } else { |
| 1336 | ALOGE("%s: Unknown input device(s) %#x", __func__, in_device); |
| 1337 | ALOGW("%s: Using default handset-mic", __func__); |
| 1338 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1339 | } |
| 1340 | } else { |
| 1341 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE) { |
| 1342 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1343 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
| 1344 | snd_device = SND_DEVICE_IN_HEADSET_MIC; |
| 1345 | } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 1346 | if (channel_count > 1) |
| 1347 | snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC; |
| 1348 | else |
| 1349 | snd_device = SND_DEVICE_IN_SPEAKER_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1350 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { |
| 1351 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1352 | } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1353 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1354 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 1355 | else |
| 1356 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1357 | } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) { |
| 1358 | snd_device = SND_DEVICE_IN_HDMI_MIC; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1359 | } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 1360 | out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
| 1361 | snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1362 | } else { |
| 1363 | ALOGE("%s: Unknown output device(s) %#x", __func__, out_device); |
| 1364 | ALOGW("%s: Using default handset-mic", __func__); |
| 1365 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1366 | } |
| 1367 | } |
| 1368 | exit: |
| 1369 | ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]); |
| 1370 | return snd_device; |
| 1371 | } |
| 1372 | |
| 1373 | int platform_set_hdmi_channels(void *platform, int channel_count) |
| 1374 | { |
| 1375 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1376 | struct audio_device *adev = my_data->adev; |
| 1377 | struct mixer_ctl *ctl; |
| 1378 | const char *channel_cnt_str = NULL; |
| 1379 | const char *mixer_ctl_name = "HDMI_RX Channels"; |
| 1380 | switch (channel_count) { |
| 1381 | case 8: |
| 1382 | channel_cnt_str = "Eight"; break; |
| 1383 | case 7: |
| 1384 | channel_cnt_str = "Seven"; break; |
| 1385 | case 6: |
| 1386 | channel_cnt_str = "Six"; break; |
| 1387 | case 5: |
| 1388 | channel_cnt_str = "Five"; break; |
| 1389 | case 4: |
| 1390 | channel_cnt_str = "Four"; break; |
| 1391 | case 3: |
| 1392 | channel_cnt_str = "Three"; break; |
| 1393 | default: |
| 1394 | channel_cnt_str = "Two"; break; |
| 1395 | } |
| 1396 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1397 | if (!ctl) { |
| 1398 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1399 | __func__, mixer_ctl_name); |
| 1400 | return -EINVAL; |
| 1401 | } |
| 1402 | ALOGV("HDMI channel count: %s", channel_cnt_str); |
| 1403 | mixer_ctl_set_enum_by_string(ctl, channel_cnt_str); |
| 1404 | return 0; |
| 1405 | } |
| 1406 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1407 | int platform_edid_get_max_channels(void *platform) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1408 | { |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1409 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1410 | struct audio_device *adev = my_data->adev; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1411 | char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE]; |
| 1412 | char *sad = block; |
| 1413 | int num_audio_blocks; |
| 1414 | int channel_count; |
| 1415 | int max_channels = 0; |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1416 | int i, ret, count; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1417 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1418 | struct mixer_ctl *ctl; |
| 1419 | |
| 1420 | ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL); |
| 1421 | if (!ctl) { |
| 1422 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1423 | __func__, AUDIO_DATA_BLOCK_MIXER_CTL); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1424 | return 0; |
| 1425 | } |
| 1426 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1427 | mixer_ctl_update(ctl); |
| 1428 | |
| 1429 | count = mixer_ctl_get_num_values(ctl); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1430 | |
| 1431 | /* Read SAD blocks, clamping the maximum size for safety */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1432 | if (count > (int)sizeof(block)) |
| 1433 | count = (int)sizeof(block); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1434 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1435 | ret = mixer_ctl_get_array(ctl, block, count); |
| 1436 | if (ret != 0) { |
| 1437 | ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__); |
| 1438 | return 0; |
| 1439 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1440 | |
| 1441 | /* Calculate the number of SAD blocks */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1442 | num_audio_blocks = count / SAD_BLOCK_SIZE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1443 | |
| 1444 | for (i = 0; i < num_audio_blocks; i++) { |
| 1445 | /* Only consider LPCM blocks */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1446 | if ((sad[0] >> 3) != EDID_FORMAT_LPCM) { |
| 1447 | sad += 3; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1448 | continue; |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1449 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1450 | |
| 1451 | channel_count = (sad[0] & 0x7) + 1; |
| 1452 | if (channel_count > max_channels) |
| 1453 | max_channels = channel_count; |
| 1454 | |
| 1455 | /* Advance to next block */ |
| 1456 | sad += 3; |
| 1457 | } |
| 1458 | |
| 1459 | return max_channels; |
| 1460 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1461 | |
| 1462 | static int platform_set_slowtalk(struct platform_data *my_data, bool state) |
| 1463 | { |
| 1464 | int ret = 0; |
| 1465 | struct audio_device *adev = my_data->adev; |
| 1466 | struct mixer_ctl *ctl; |
| 1467 | const char *mixer_ctl_name = "Slowtalk Enable"; |
| 1468 | uint32_t set_values[ ] = {0, |
| 1469 | ALL_SESSION_VSID}; |
| 1470 | |
| 1471 | set_values[0] = state; |
| 1472 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1473 | if (!ctl) { |
| 1474 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1475 | __func__, mixer_ctl_name); |
| 1476 | ret = -EINVAL; |
| 1477 | } else { |
| 1478 | ALOGV("Setting slowtalk state: %d", state); |
| 1479 | ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
| 1480 | my_data->slowtalk = state; |
| 1481 | } |
| 1482 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 1483 | if (my_data->csd != NULL) { |
| 1484 | ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state); |
| 1485 | if (ret < 0) { |
| 1486 | ALOGE("%s: csd_client_disable_device, failed, error %d", |
| 1487 | __func__, ret); |
| 1488 | } |
| 1489 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1490 | return ret; |
| 1491 | } |
| 1492 | |
| 1493 | int platform_set_parameters(void *platform, struct str_parms *parms) |
| 1494 | { |
| 1495 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1496 | char *str; |
Vidyakumar Athota | 3ade279 | 2013-12-02 11:02:20 -0800 | [diff] [blame] | 1497 | char value[256] = {0}; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1498 | int val; |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 1499 | int ret = 0, err; |
Krishnankutty Kolathappilly | 301cc36 | 2014-01-31 18:12:13 -0800 | [diff] [blame] | 1500 | char *kv_pairs = str_parms_to_str(parms); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1501 | |
Krishnankutty Kolathappilly | 301cc36 | 2014-01-31 18:12:13 -0800 | [diff] [blame] | 1502 | ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1503 | |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 1504 | err = str_parms_get_int(parms, AUDIO_PARAMETER_KEY_BTSCO, &val); |
| 1505 | if (err >= 0) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1506 | str_parms_del(parms, AUDIO_PARAMETER_KEY_BTSCO); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1507 | my_data->btsco_sample_rate = val; |
Vidyakumar Athota | 67c4271 | 2013-12-04 14:03:06 -0800 | [diff] [blame] | 1508 | if (val == SAMPLE_RATE_16KHZ) { |
| 1509 | audio_route_apply_path(my_data->adev->audio_route, |
| 1510 | "bt-sco-wb-samplerate"); |
| 1511 | audio_route_update_mixer(my_data->adev->audio_route); |
| 1512 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1513 | } |
| 1514 | |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 1515 | err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_SLOWTALK, value, sizeof(value)); |
| 1516 | if (err >= 0) { |
Vidyakumar Athota | 3ade279 | 2013-12-02 11:02:20 -0800 | [diff] [blame] | 1517 | bool state = false; |
| 1518 | if (!strncmp("true", value, sizeof("true"))) { |
| 1519 | state = true; |
| 1520 | } |
| 1521 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1522 | str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK); |
Vidyakumar Athota | 3ade279 | 2013-12-02 11:02:20 -0800 | [diff] [blame] | 1523 | ret = platform_set_slowtalk(my_data, state); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1524 | if (ret) |
| 1525 | ALOGE("%s: Failed to set slow talk err: %d", __func__, ret); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1526 | } |
| 1527 | |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 1528 | err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST, |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 1529 | value, sizeof(value)); |
Shiv Maliyappanahalli | 3e064fd | 2013-12-16 15:54:40 -0800 | [diff] [blame] | 1530 | if (err >= 0) { |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 1531 | str_parms_del(parms, AUDIO_PARAMETER_KEY_VOLUME_BOOST); |
| 1532 | |
| 1533 | if (my_data->acdb_reload_vocvoltable == NULL) { |
| 1534 | ALOGE("%s: acdb_reload_vocvoltable is NULL", __func__); |
| 1535 | } else if (!strcmp(value, "on")) { |
| 1536 | if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_VOLUME_BOOST)) { |
| 1537 | my_data->voice_feature_set = 1; |
| 1538 | } |
| 1539 | } else { |
| 1540 | if (!my_data->acdb_reload_vocvoltable(VOICE_FEATURE_SET_DEFAULT)) { |
| 1541 | my_data->voice_feature_set = 0; |
| 1542 | } |
| 1543 | } |
| 1544 | } |
| 1545 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1546 | ALOGV("%s: exit with code(%d)", __func__, ret); |
Krishnankutty Kolathappilly | 301cc36 | 2014-01-31 18:12:13 -0800 | [diff] [blame] | 1547 | free(kv_pairs); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1548 | return ret; |
| 1549 | } |
| 1550 | |
Vidyakumar Athota | 2850d53 | 2013-11-19 16:02:12 -0800 | [diff] [blame] | 1551 | int platform_set_incall_recording_session_id(void *platform, |
| 1552 | uint32_t session_id, int rec_mode) |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 1553 | { |
| 1554 | int ret = 0; |
| 1555 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1556 | struct audio_device *adev = my_data->adev; |
| 1557 | struct mixer_ctl *ctl; |
| 1558 | const char *mixer_ctl_name = "Voc VSID"; |
| 1559 | int num_ctl_values; |
| 1560 | int i; |
| 1561 | |
| 1562 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1563 | if (!ctl) { |
| 1564 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1565 | __func__, mixer_ctl_name); |
| 1566 | ret = -EINVAL; |
| 1567 | } else { |
| 1568 | num_ctl_values = mixer_ctl_get_num_values(ctl); |
| 1569 | for (i = 0; i < num_ctl_values; i++) { |
| 1570 | if (mixer_ctl_set_value(ctl, i, session_id)) { |
| 1571 | ALOGV("Error: invalid session_id: %x", session_id); |
| 1572 | ret = -EINVAL; |
| 1573 | break; |
| 1574 | } |
| 1575 | } |
| 1576 | } |
| 1577 | |
Vidyakumar Athota | 2850d53 | 2013-11-19 16:02:12 -0800 | [diff] [blame] | 1578 | if (my_data->csd != NULL) { |
| 1579 | ret = my_data->csd->start_record(ALL_SESSION_VSID, rec_mode); |
| 1580 | if (ret < 0) { |
| 1581 | ALOGE("%s: csd_client_start_record failed, error %d", |
| 1582 | __func__, ret); |
| 1583 | } |
| 1584 | } |
| 1585 | |
| 1586 | return ret; |
| 1587 | } |
| 1588 | |
| 1589 | int platform_stop_incall_recording_usecase(void *platform) |
| 1590 | { |
| 1591 | int ret = 0; |
| 1592 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1593 | |
| 1594 | if (my_data->csd != NULL) { |
| 1595 | ret = my_data->csd->stop_record(ALL_SESSION_VSID); |
| 1596 | if (ret < 0) { |
| 1597 | ALOGE("%s: csd_client_stop_record failed, error %d", |
| 1598 | __func__, ret); |
| 1599 | } |
| 1600 | } |
| 1601 | |
| 1602 | return ret; |
| 1603 | } |
| 1604 | |
| 1605 | int platform_start_incall_music_usecase(void *platform) |
| 1606 | { |
| 1607 | int ret = 0; |
| 1608 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1609 | |
| 1610 | if (my_data->csd != NULL) { |
| 1611 | ret = my_data->csd->start_playback(ALL_SESSION_VSID); |
| 1612 | if (ret < 0) { |
| 1613 | ALOGE("%s: csd_client_start_playback failed, error %d", |
| 1614 | __func__, ret); |
| 1615 | } |
| 1616 | } |
| 1617 | |
| 1618 | return ret; |
| 1619 | } |
| 1620 | |
| 1621 | int platform_stop_incall_music_usecase(void *platform) |
| 1622 | { |
| 1623 | int ret = 0; |
| 1624 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1625 | |
| 1626 | if (my_data->csd != NULL) { |
| 1627 | ret = my_data->csd->stop_playback(ALL_SESSION_VSID); |
| 1628 | if (ret < 0) { |
| 1629 | ALOGE("%s: csd_client_stop_playback failed, error %d", |
| 1630 | __func__, ret); |
| 1631 | } |
| 1632 | } |
| 1633 | |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 1634 | return ret; |
| 1635 | } |
| 1636 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1637 | void platform_get_parameters(void *platform, |
| 1638 | struct str_parms *query, |
| 1639 | struct str_parms *reply) |
| 1640 | { |
| 1641 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1642 | char *str = NULL; |
| 1643 | char value[256] = {0}; |
| 1644 | int ret; |
Krishnankutty Kolathappilly | 301cc36 | 2014-01-31 18:12:13 -0800 | [diff] [blame] | 1645 | char *kv_pairs = NULL; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1646 | |
Shiv Maliyappanahalli | 9d89929 | 2013-11-20 14:43:01 -0800 | [diff] [blame] | 1647 | ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK, |
| 1648 | value, sizeof(value)); |
| 1649 | if (ret >= 0) { |
Vidyakumar Athota | 3ade279 | 2013-12-02 11:02:20 -0800 | [diff] [blame] | 1650 | str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SLOWTALK, |
| 1651 | my_data->slowtalk?"true":"false"); |
Shiv Maliyappanahalli | 9d89929 | 2013-11-20 14:43:01 -0800 | [diff] [blame] | 1652 | } |
| 1653 | |
Ben Romberger | c1dc70d | 2013-12-19 15:11:17 -0800 | [diff] [blame] | 1654 | ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_VOLUME_BOOST, |
| 1655 | value, sizeof(value)); |
| 1656 | if (ret >= 0) { |
| 1657 | if (my_data->voice_feature_set == VOICE_FEATURE_SET_VOLUME_BOOST) { |
| 1658 | strlcpy(value, "on", sizeof(value)); |
| 1659 | } else { |
| 1660 | strlcpy(value, "off", sizeof(value)); |
| 1661 | } |
| 1662 | |
| 1663 | str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VOLUME_BOOST, value); |
| 1664 | } |
| 1665 | |
Krishnankutty Kolathappilly | 301cc36 | 2014-01-31 18:12:13 -0800 | [diff] [blame] | 1666 | kv_pairs = str_parms_to_str(reply); |
| 1667 | ALOGV_IF(kv_pairs != NULL, "%s: exit: returns - %s", __func__, kv_pairs); |
Narsinga Rao Chella | db712ed | 2014-02-13 11:44:31 -0800 | [diff] [blame] | 1668 | free(kv_pairs); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1669 | } |
| 1670 | |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 1671 | /* Delay in Us */ |
| 1672 | int64_t platform_render_latency(audio_usecase_t usecase) |
| 1673 | { |
| 1674 | switch (usecase) { |
| 1675 | case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER: |
| 1676 | return DEEP_BUFFER_PLATFORM_DELAY; |
| 1677 | case USECASE_AUDIO_PLAYBACK_LOW_LATENCY: |
| 1678 | return LOW_LATENCY_PLATFORM_DELAY; |
| 1679 | default: |
| 1680 | return 0; |
| 1681 | } |
| 1682 | } |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1683 | |
Mingming Yin | e62d784 | 2013-10-25 16:26:03 -0700 | [diff] [blame] | 1684 | int platform_update_usecase_from_source(int source, int usecase) |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1685 | { |
Mingming Yin | ab42978 | 2013-11-07 11:16:55 -0800 | [diff] [blame] | 1686 | ALOGV("%s: input source :%d", __func__, source); |
| 1687 | if(source == AUDIO_SOURCE_FM_RX_A2DP) |
Mingming Yin | e62d784 | 2013-10-25 16:26:03 -0700 | [diff] [blame] | 1688 | usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL; |
| 1689 | return usecase; |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1690 | } |
Kiran Kandi | de144c8 | 2013-11-20 15:58:32 -0800 | [diff] [blame] | 1691 | |
| 1692 | bool platform_listen_update_status(snd_device_t snd_device) |
| 1693 | { |
| 1694 | if ((snd_device >= SND_DEVICE_IN_BEGIN) && |
| 1695 | (snd_device < SND_DEVICE_IN_END) && |
| 1696 | (snd_device != SND_DEVICE_IN_CAPTURE_FM) && |
| 1697 | (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)) |
| 1698 | return true; |
| 1699 | else |
| 1700 | return false; |
| 1701 | } |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 1702 | |
| 1703 | /* Read offload buffer size from a property. |
| 1704 | * If value is not power of 2 round it to |
| 1705 | * power of 2. |
| 1706 | */ |
| 1707 | uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info) |
| 1708 | { |
| 1709 | char value[PROPERTY_VALUE_MAX] = {0}; |
| 1710 | uint32_t fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE; |
| 1711 | if((property_get("audio.offload.buffer.size.kb", value, "")) && |
| 1712 | atoi(value)) { |
| 1713 | fragment_size = atoi(value) * 1024; |
| 1714 | } |
| 1715 | |
| 1716 | if (info != NULL && info->has_video && info->is_streaming) { |
| 1717 | fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE_FOR_AV_STREAMING; |
| 1718 | ALOGV("%s: offload fragment size reduced for AV streaming to %d", |
ApurupaPattapu | 28261e9 | 2014-03-05 11:13:32 -0800 | [diff] [blame] | 1719 | __func__, fragment_size); |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 1720 | } |
| 1721 | |
| 1722 | fragment_size = ALIGN( fragment_size, 1024); |
| 1723 | |
| 1724 | if(fragment_size < MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE) |
| 1725 | fragment_size = MIN_COMPRESS_OFFLOAD_FRAGMENT_SIZE; |
| 1726 | else if(fragment_size > MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE) |
| 1727 | fragment_size = MAX_COMPRESS_OFFLOAD_FRAGMENT_SIZE; |
| 1728 | ALOGV("%s: fragment_size %d", __func__, fragment_size); |
| 1729 | return fragment_size; |
| 1730 | } |
| 1731 | |
| 1732 | uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info) |
| 1733 | { |
| 1734 | uint32_t fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE; |
| 1735 | uint32_t bits_per_sample = 16; |
| 1736 | |
| 1737 | if (info->format == AUDIO_FORMAT_PCM_24_BIT_OFFLOAD) { |
| 1738 | bits_per_sample = 32; |
| 1739 | } |
| 1740 | |
| 1741 | if (!info->has_video) { |
| 1742 | fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE; |
| 1743 | |
| 1744 | } else if (info->has_video && info->is_streaming) { |
| 1745 | fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV_STREAMING |
| 1746 | * info->sample_rate |
ApurupaPattapu | 0c097d5 | 2014-04-08 10:41:07 -0700 | [diff] [blame] | 1747 | * (bits_per_sample >> 3) |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 1748 | * popcount(info->channel_mask))/1000; |
| 1749 | |
| 1750 | } else if (info->has_video) { |
| 1751 | fragment_size = (PCM_OFFLOAD_BUFFER_DURATION_FOR_AV |
| 1752 | * info->sample_rate |
ApurupaPattapu | 0c097d5 | 2014-04-08 10:41:07 -0700 | [diff] [blame] | 1753 | * (bits_per_sample >> 3) |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 1754 | * popcount(info->channel_mask))/1000; |
| 1755 | } |
| 1756 | |
ApurupaPattapu | 0c097d5 | 2014-04-08 10:41:07 -0700 | [diff] [blame] | 1757 | char value[PROPERTY_VALUE_MAX] = {0}; |
| 1758 | if((property_get("audio.offload.pcm.buffer.size", value, "")) && |
| 1759 | atoi(value)) { |
| 1760 | fragment_size = atoi(value) * 1024; |
| 1761 | ALOGV("Using buffer size from sys prop %d", fragment_size); |
| 1762 | } |
| 1763 | |
ApurupaPattapu | 0c56687 | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 1764 | fragment_size = ALIGN( fragment_size, 1024); |
| 1765 | |
| 1766 | if(fragment_size < MIN_PCM_OFFLOAD_FRAGMENT_SIZE) |
| 1767 | fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE; |
| 1768 | else if(fragment_size > MAX_PCM_OFFLOAD_FRAGMENT_SIZE) |
| 1769 | fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE; |
| 1770 | |
| 1771 | ALOGV("%s: fragment_size %d", __func__, fragment_size); |
| 1772 | return fragment_size; |
| 1773 | } |
| 1774 | |