Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1 | /* |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 2 | * Copyright (c) 2013, The Linux Foundation. All rights reserved. |
| 3 | * Not a Contribution. |
| 4 | * |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 5 | * Copyright (C) 2013 The Android Open Source Project |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 8 | * you may not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
| 18 | */ |
| 19 | |
| 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" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 33 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 34 | #define MIXER_XML_PATH "/system/etc/mixer_paths.xml" |
Damir Didjusto | f1d46c7 | 2013-11-06 17:59:04 -0800 | [diff] [blame] | 35 | #define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 36 | #define LIB_ACDB_LOADER "libacdbloader.so" |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 37 | #define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 38 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 39 | /* |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 40 | * This file will have a maximum of 38 bytes: |
| 41 | * |
| 42 | * 4 bytes: number of audio blocks |
| 43 | * 4 bytes: total length of Short Audio Descriptor (SAD) blocks |
| 44 | * Maximum 10 * 3 bytes: SAD blocks |
| 45 | */ |
| 46 | #define MAX_SAD_BLOCKS 10 |
| 47 | #define SAD_BLOCK_SIZE 3 |
| 48 | |
| 49 | /* EDID format ID for LPCM audio */ |
| 50 | #define EDID_FORMAT_LPCM 1 |
| 51 | |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 52 | /* Retry for delay in FW loading*/ |
| 53 | #define RETRY_NUMBER 10 |
| 54 | #define RETRY_US 500000 |
| 55 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 56 | #define SAMPLE_RATE_8KHZ 8000 |
| 57 | #define SAMPLE_RATE_16KHZ 16000 |
| 58 | |
sangwoo | 53b2cf0 | 2013-07-25 19:18:44 -0700 | [diff] [blame] | 59 | #define MAX_VOL_INDEX 5 |
| 60 | #define MIN_VOL_INDEX 0 |
| 61 | #define percent_to_index(val, min, max) \ |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 62 | ((val) * ((max) - (min)) * 0.01 + (min) + .5) |
| 63 | |
| 64 | #define AUDIO_PARAMETER_KEY_FLUENCE_TYPE "fluence" |
| 65 | #define AUDIO_PARAMETER_KEY_BTSCO "bt_samplerate" |
| 66 | #define AUDIO_PARAMETER_KEY_SLOWTALK "st_enable" |
sangwoo | 53b2cf0 | 2013-07-25 19:18:44 -0700 | [diff] [blame] | 67 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 68 | struct audio_block_header |
| 69 | { |
| 70 | int reserved; |
| 71 | int length; |
| 72 | }; |
| 73 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 74 | /* Audio calibration related functions */ |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 75 | typedef void (*acdb_deallocate_t)(); |
| 76 | typedef int (*acdb_init_t)(); |
| 77 | typedef void (*acdb_send_audio_cal_t)(int, int); |
| 78 | typedef void (*acdb_send_voice_cal_t)(int, int); |
| 79 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 80 | struct platform_data { |
| 81 | struct audio_device *adev; |
| 82 | bool fluence_in_spkr_mode; |
| 83 | bool fluence_in_voice_call; |
| 84 | bool fluence_in_voice_rec; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 85 | bool fluence_in_audio_rec; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 86 | int fluence_type; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 87 | int btsco_sample_rate; |
| 88 | bool slowtalk; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 89 | /* Audio calibration related functions */ |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 90 | void *acdb_handle; |
| 91 | acdb_init_t acdb_init; |
| 92 | acdb_deallocate_t acdb_deallocate; |
| 93 | acdb_send_audio_cal_t acdb_send_audio_cal; |
| 94 | acdb_send_voice_cal_t acdb_send_voice_cal; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 95 | |
| 96 | void *hw_info; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 97 | struct csd_data *csd; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 98 | }; |
| 99 | |
| 100 | static const int pcm_device_table[AUDIO_USECASE_MAX][2] = { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 101 | [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {DEEP_BUFFER_PCM_DEVICE, |
| 102 | DEEP_BUFFER_PCM_DEVICE}, |
| 103 | [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE, |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 104 | LOWLATENCY_PCM_DEVICE}, |
| 105 | [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {MULTIMEDIA2_PCM_DEVICE, |
| 106 | MULTIMEDIA2_PCM_DEVICE}, |
Krishnankutty Kolathappilly | a43f96e | 2013-11-01 12:17:53 -0700 | [diff] [blame] | 107 | [USECASE_AUDIO_PLAYBACK_OFFLOAD] = |
| 108 | {PLAYBACK_OFFLOAD_DEVICE, PLAYBACK_OFFLOAD_DEVICE}, |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 109 | [USECASE_AUDIO_RECORD] = {AUDIO_RECORD_PCM_DEVICE, AUDIO_RECORD_PCM_DEVICE}, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 110 | [USECASE_AUDIO_RECORD_LOW_LATENCY] = {LOWLATENCY_PCM_DEVICE, |
| 111 | LOWLATENCY_PCM_DEVICE}, |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 112 | [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {MULTIMEDIA2_PCM_DEVICE, |
| 113 | MULTIMEDIA2_PCM_DEVICE}, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 114 | [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE}, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 115 | [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE}, |
| 116 | [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE}, |
| 117 | [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE}, |
| 118 | [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE}, |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 119 | [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 120 | AUDIO_RECORD_PCM_DEVICE}, |
| 121 | [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 122 | AUDIO_RECORD_PCM_DEVICE}, |
| 123 | [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE, |
| 124 | AUDIO_RECORD_PCM_DEVICE}, |
Shiv Maliyappanahalli | f3b9a42 | 2013-10-22 16:38:08 -0700 | [diff] [blame] | 125 | [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE, |
| 126 | INCALL_MUSIC_UPLINK_PCM_DEVICE}, |
| 127 | [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE, |
| 128 | INCALL_MUSIC_UPLINK2_PCM_DEVICE}, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 129 | [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1}, |
| 130 | [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE}, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 131 | }; |
| 132 | |
| 133 | /* Array to store sound devices */ |
| 134 | static const char * const device_table[SND_DEVICE_MAX] = { |
| 135 | [SND_DEVICE_NONE] = "none", |
| 136 | /* Playback sound devices */ |
| 137 | [SND_DEVICE_OUT_HANDSET] = "handset", |
| 138 | [SND_DEVICE_OUT_SPEAKER] = "speaker", |
| 139 | [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse", |
| 140 | [SND_DEVICE_OUT_HEADPHONES] = "headphones", |
| 141 | [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones", |
| 142 | [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset", |
| 143 | [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker", |
| 144 | [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones", |
| 145 | [SND_DEVICE_OUT_HDMI] = "hdmi", |
| 146 | [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi", |
| 147 | [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset", |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 148 | [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 149 | [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones", |
| 150 | [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones", |
| 151 | [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset", |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 152 | [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy", |
| 153 | [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones", |
| 154 | [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones", |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 155 | [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm", |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 156 | [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones", |
| 157 | [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones", |
| 158 | [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones", |
| 159 | [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones", |
| 160 | [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones", |
| 161 | [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset", |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 162 | [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 163 | |
| 164 | /* Capture sound devices */ |
| 165 | [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 166 | [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 167 | [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 168 | [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 169 | [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic", |
| 170 | [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 171 | [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire", |
| 172 | [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic", |
| 173 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 174 | [SND_DEVICE_IN_HEADSET_MIC_AEC] = "headset-mic", |
| 175 | [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic", |
| 176 | [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic", |
| 177 | [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic", |
| 178 | [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic", |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 179 | [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 180 | [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 181 | [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 182 | [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 183 | [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic", |
| 184 | [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic", |
| 185 | [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic", |
| 186 | [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic", |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 187 | [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef", |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 188 | [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence", |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 189 | [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic", |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 190 | [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm", |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 191 | [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic", |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 192 | [SND_DEVICE_IN_QUAD_MIC] = "quad-mic", |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 193 | [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef", |
| 194 | [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef", |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 195 | [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 196 | }; |
| 197 | |
| 198 | /* ACDB IDs (audio DSP path configuration IDs) for each sound device */ |
| 199 | static const int acdb_device_table[SND_DEVICE_MAX] = { |
| 200 | [SND_DEVICE_NONE] = -1, |
| 201 | [SND_DEVICE_OUT_HANDSET] = 7, |
| 202 | [SND_DEVICE_OUT_SPEAKER] = 15, |
| 203 | [SND_DEVICE_OUT_SPEAKER_REVERSE] = 15, |
| 204 | [SND_DEVICE_OUT_HEADPHONES] = 10, |
| 205 | [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10, |
| 206 | [SND_DEVICE_OUT_VOICE_HANDSET] = 7, |
| 207 | [SND_DEVICE_OUT_VOICE_SPEAKER] = 15, |
| 208 | [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10, |
| 209 | [SND_DEVICE_OUT_HDMI] = 18, |
| 210 | [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 15, |
| 211 | [SND_DEVICE_OUT_BT_SCO] = 22, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 212 | [SND_DEVICE_OUT_BT_SCO_WB] = 39, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 213 | [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17, |
| 214 | [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17, |
| 215 | [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37, |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 216 | [SND_DEVICE_OUT_AFE_PROXY] = 0, |
| 217 | [SND_DEVICE_OUT_USB_HEADSET] = 0, |
| 218 | [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 219 | [SND_DEVICE_OUT_TRANSMISSION_FM] = 0, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 220 | [SND_DEVICE_OUT_ANC_HEADSET] = 26, |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 221 | [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 222 | [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26, |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 223 | [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 224 | [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26, |
| 225 | [SND_DEVICE_OUT_ANC_HANDSET] = 103, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 226 | [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 101, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 227 | |
| 228 | [SND_DEVICE_IN_HANDSET_MIC] = 4, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 229 | [SND_DEVICE_IN_HANDSET_DMIC] = 41, |
| 230 | [SND_DEVICE_IN_SPEAKER_MIC] = 11, |
| 231 | [SND_DEVICE_IN_SPEAKER_DMIC] = 43, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 232 | [SND_DEVICE_IN_HEADSET_MIC] = 8, |
| 233 | [SND_DEVICE_IN_HANDSET_MIC_AEC] = 40, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 234 | [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 41, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 235 | [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 42, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 236 | [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 43, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 237 | [SND_DEVICE_IN_HEADSET_MIC_AEC] = 47, |
| 238 | [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11, |
| 239 | [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8, |
| 240 | [SND_DEVICE_IN_HDMI_MIC] = 4, |
| 241 | [SND_DEVICE_IN_BT_SCO_MIC] = 21, |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 242 | [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 243 | [SND_DEVICE_IN_CAMCORDER_MIC] = 4, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 244 | [SND_DEVICE_IN_VOICE_DMIC] = 41, |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 245 | [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 246 | [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16, |
| 247 | [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36, |
| 248 | [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16, |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 249 | [SND_DEVICE_IN_VOICE_REC_MIC] = 4, |
| 250 | [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34, |
| 251 | [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41, |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 252 | [SND_DEVICE_IN_USB_HEADSET_MIC] = 44, |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 253 | [SND_DEVICE_IN_CAPTURE_FM] = 0, |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 254 | [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104, |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 255 | [SND_DEVICE_IN_QUAD_MIC] = 46, |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 256 | [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34, |
| 257 | [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35, |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 258 | [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102, |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 259 | }; |
| 260 | |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 261 | #define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL) |
| 262 | #define LOW_LATENCY_PLATFORM_DELAY (13*1000LL) |
| 263 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 264 | static int set_echo_reference(struct mixer *mixer, const char* ec_ref) |
| 265 | { |
| 266 | struct mixer_ctl *ctl; |
| 267 | const char *mixer_ctl_name = "EC_REF_RX"; |
| 268 | |
| 269 | ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name); |
| 270 | if (!ctl) { |
| 271 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 272 | __func__, mixer_ctl_name); |
| 273 | return -EINVAL; |
| 274 | } |
| 275 | ALOGV("Setting EC Reference: %s", ec_ref); |
| 276 | mixer_ctl_set_enum_by_string(ctl, ec_ref); |
| 277 | return 0; |
| 278 | } |
| 279 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 280 | static struct csd_data *open_csd_client() |
| 281 | { |
| 282 | struct csd_data *csd = calloc(1, sizeof(struct csd_data)); |
| 283 | |
| 284 | csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW); |
| 285 | if (csd->csd_client == NULL) { |
| 286 | ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT); |
| 287 | goto error; |
| 288 | } else { |
| 289 | ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT); |
| 290 | |
| 291 | csd->deinit = (deinit_t)dlsym(csd->csd_client, |
| 292 | "csd_client_deinit"); |
| 293 | if (csd->deinit == NULL) { |
| 294 | ALOGE("%s: dlsym error %s for csd_client_deinit", __func__, |
| 295 | dlerror()); |
| 296 | goto error; |
| 297 | } |
| 298 | csd->disable_device = (disable_device_t)dlsym(csd->csd_client, |
| 299 | "csd_client_disable_device"); |
| 300 | if (csd->disable_device == NULL) { |
| 301 | ALOGE("%s: dlsym error %s for csd_client_disable_device", |
| 302 | __func__, dlerror()); |
| 303 | goto error; |
| 304 | } |
| 305 | csd->enable_device = (enable_device_t)dlsym(csd->csd_client, |
| 306 | "csd_client_enable_device"); |
| 307 | if (csd->enable_device == NULL) { |
| 308 | ALOGE("%s: dlsym error %s for csd_client_enable_device", |
| 309 | __func__, dlerror()); |
| 310 | goto error; |
| 311 | } |
| 312 | csd->start_voice = (start_voice_t)dlsym(csd->csd_client, |
| 313 | "csd_client_start_voice"); |
| 314 | if (csd->start_voice == NULL) { |
| 315 | ALOGE("%s: dlsym error %s for csd_client_start_voice", |
| 316 | __func__, dlerror()); |
| 317 | goto error; |
| 318 | } |
| 319 | csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client, |
| 320 | "csd_client_stop_voice"); |
| 321 | if (csd->stop_voice == NULL) { |
| 322 | ALOGE("%s: dlsym error %s for csd_client_stop_voice", |
| 323 | __func__, dlerror()); |
| 324 | goto error; |
| 325 | } |
| 326 | csd->volume = (volume_t)dlsym(csd->csd_client, |
| 327 | "csd_client_volume"); |
| 328 | if (csd->volume == NULL) { |
| 329 | ALOGE("%s: dlsym error %s for csd_client_volume", |
| 330 | __func__, dlerror()); |
| 331 | goto error; |
| 332 | } |
| 333 | csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client, |
| 334 | "csd_client_mic_mute"); |
| 335 | if (csd->mic_mute == NULL) { |
| 336 | ALOGE("%s: dlsym error %s for csd_client_mic_mute", |
| 337 | __func__, dlerror()); |
| 338 | goto error; |
| 339 | } |
| 340 | csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client, |
| 341 | "csd_client_slow_talk"); |
| 342 | if (csd->slow_talk == NULL) { |
| 343 | ALOGE("%s: dlsym error %s for csd_client_slow_talk", |
| 344 | __func__, dlerror()); |
| 345 | goto error; |
| 346 | } |
| 347 | csd->start_playback = (start_playback_t)dlsym(csd->csd_client, |
| 348 | "csd_client_start_playback"); |
| 349 | if (csd->start_playback == NULL) { |
| 350 | ALOGE("%s: dlsym error %s for csd_client_start_playback", |
| 351 | __func__, dlerror()); |
| 352 | goto error; |
| 353 | } |
| 354 | csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client, |
| 355 | "csd_client_stop_playback"); |
| 356 | if (csd->stop_playback == NULL) { |
| 357 | ALOGE("%s: dlsym error %s for csd_client_stop_playback", |
| 358 | __func__, dlerror()); |
| 359 | goto error; |
| 360 | } |
| 361 | csd->start_record = (start_record_t)dlsym(csd->csd_client, |
| 362 | "csd_client_start_record"); |
| 363 | if (csd->start_record == NULL) { |
| 364 | ALOGE("%s: dlsym error %s for csd_client_start_record", |
| 365 | __func__, dlerror()); |
| 366 | goto error; |
| 367 | } |
| 368 | csd->stop_record = (stop_record_t)dlsym(csd->csd_client, |
| 369 | "csd_client_stop_record"); |
| 370 | if (csd->stop_record == NULL) { |
| 371 | ALOGE("%s: dlsym error %s for csd_client_stop_record", |
| 372 | __func__, dlerror()); |
| 373 | goto error; |
| 374 | } |
| 375 | csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init"); |
| 376 | |
| 377 | if (csd->init == NULL) { |
| 378 | ALOGE("%s: dlsym error %s for csd_client_init", |
| 379 | __func__, dlerror()); |
| 380 | goto error; |
| 381 | } else { |
| 382 | csd->init(); |
| 383 | } |
| 384 | } |
| 385 | return csd; |
| 386 | |
| 387 | error: |
| 388 | free(csd); |
| 389 | csd = NULL; |
| 390 | return csd; |
| 391 | } |
| 392 | |
| 393 | void close_csd_client(struct csd_data *csd) |
| 394 | { |
| 395 | if (csd != NULL) { |
| 396 | csd->deinit(); |
| 397 | dlclose(csd->csd_client); |
| 398 | free(csd); |
| 399 | csd = NULL; |
| 400 | } |
| 401 | } |
| 402 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 403 | void *platform_init(struct audio_device *adev) |
| 404 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 405 | char platform[PROPERTY_VALUE_MAX]; |
| 406 | char baseband[PROPERTY_VALUE_MAX]; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 407 | char value[PROPERTY_VALUE_MAX]; |
| 408 | struct platform_data *my_data; |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 409 | int retry_num = 0; |
| 410 | const char *snd_card_name; |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 411 | |
| 412 | adev->mixer = mixer_open(MIXER_CARD); |
| 413 | |
| 414 | while (!adev->mixer && retry_num < RETRY_NUMBER) { |
| 415 | usleep(RETRY_US); |
| 416 | adev->mixer = mixer_open(MIXER_CARD); |
| 417 | retry_num++; |
| 418 | } |
| 419 | |
| 420 | if (!adev->mixer) { |
| 421 | ALOGE("Unable to open the mixer, aborting."); |
| 422 | return NULL; |
| 423 | } |
| 424 | |
Damir Didjusto | f1d46c7 | 2013-11-06 17:59:04 -0800 | [diff] [blame] | 425 | if (audio_extn_read_xml(adev, MIXER_CARD, MIXER_XML_PATH, |
| 426 | MIXER_XML_PATH_AUXPCM) == -ENOSYS) |
| 427 | adev->audio_route = audio_route_init(MIXER_CARD, MIXER_XML_PATH); |
| 428 | |
sangwoo | 1b9f4b3 | 2013-06-21 18:22:55 -0700 | [diff] [blame] | 429 | if (!adev->audio_route) { |
| 430 | ALOGE("%s: Failed to init audio route controls, aborting.", __func__); |
| 431 | return NULL; |
| 432 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 433 | |
| 434 | my_data = calloc(1, sizeof(struct platform_data)); |
| 435 | |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 436 | snd_card_name = mixer_get_name(adev->mixer); |
| 437 | my_data->hw_info = hw_info_init(snd_card_name); |
| 438 | if (!my_data->hw_info) { |
| 439 | ALOGE("%s: Failed to init hardware info", __func__); |
| 440 | } |
| 441 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 442 | my_data->adev = adev; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 443 | my_data->btsco_sample_rate = SAMPLE_RATE_8KHZ; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 444 | my_data->fluence_in_spkr_mode = false; |
| 445 | my_data->fluence_in_voice_call = false; |
| 446 | my_data->fluence_in_voice_rec = false; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 447 | my_data->fluence_in_audio_rec = false; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 448 | my_data->fluence_type = FLUENCE_NONE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 449 | |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 450 | property_get("ro.qc.sdk.audio.fluencetype", value, ""); |
| 451 | if (!strncmp("fluencepro", value, sizeof("fluencepro"))) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 452 | my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 453 | } else if (!strncmp("fluence", value, sizeof("fluence"))) { |
| 454 | my_data->fluence_type = FLUENCE_DUAL_MIC; |
| 455 | } else { |
| 456 | my_data->fluence_type = FLUENCE_NONE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 457 | } |
| 458 | |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 459 | if (my_data->fluence_type != FLUENCE_NONE) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 460 | property_get("persist.audio.fluence.voicecall",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 461 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 462 | my_data->fluence_in_voice_call = true; |
| 463 | } |
| 464 | |
| 465 | property_get("persist.audio.fluence.voicerec",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 466 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 467 | my_data->fluence_in_voice_rec = true; |
| 468 | } |
| 469 | |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 470 | property_get("persist.audio.fluence.audiorec",value,""); |
| 471 | if (!strncmp("true", value, sizeof("true"))) { |
| 472 | my_data->fluence_in_audio_rec = true; |
| 473 | } |
| 474 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 475 | property_get("persist.audio.fluence.speaker",value,""); |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 476 | if (!strncmp("true", value, sizeof("true"))) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 477 | my_data->fluence_in_spkr_mode = true; |
| 478 | } |
| 479 | } |
| 480 | |
| 481 | my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW); |
| 482 | if (my_data->acdb_handle == NULL) { |
| 483 | ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER); |
| 484 | } else { |
| 485 | ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER); |
| 486 | my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle, |
| 487 | "acdb_loader_deallocate_ACDB"); |
| 488 | my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle, |
| 489 | "acdb_loader_send_audio_cal"); |
| 490 | if (!my_data->acdb_send_audio_cal) |
| 491 | ALOGW("%s: Could not find the symbol acdb_send_audio_cal from %s", |
| 492 | __func__, LIB_ACDB_LOADER); |
| 493 | my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle, |
| 494 | "acdb_loader_send_voice_cal"); |
| 495 | my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle, |
| 496 | "acdb_loader_init_ACDB"); |
| 497 | if (my_data->acdb_init == NULL) |
| 498 | ALOGE("%s: dlsym error %s for acdb_loader_init_ACDB", __func__, dlerror()); |
| 499 | else |
| 500 | my_data->acdb_init(); |
| 501 | } |
| 502 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 503 | /* If platform is apq8084 and baseband is MDM, load CSD Client specific |
| 504 | * symbols. Voice call is handled by MDM and apps processor talks to |
| 505 | * MDM through CSD Client |
| 506 | */ |
| 507 | property_get("ro.board.platform", platform, ""); |
| 508 | property_get("ro.baseband", baseband, ""); |
| 509 | if (!strncmp("apq8084", platform, sizeof("apq8084")) && |
| 510 | !strncmp("mdm", baseband, sizeof("mdm"))) { |
| 511 | my_data->csd = open_csd_client(); |
| 512 | } |
| 513 | |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 514 | /* init usb */ |
| 515 | audio_extn_usb_init(adev); |
| 516 | |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 517 | /* Read one time ssr property */ |
| 518 | audio_extn_ssr_update_enabled(adev); |
Gopikrishnaiah Anandan | f538cef | 2013-10-28 14:06:03 -0700 | [diff] [blame] | 519 | audio_extn_spkr_prot_init(adev); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 520 | return my_data; |
| 521 | } |
| 522 | |
| 523 | void platform_deinit(void *platform) |
| 524 | { |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 525 | struct platform_data *my_data = (struct platform_data *)platform; |
| 526 | |
| 527 | hw_info_deinit(my_data->hw_info); |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 528 | close_csd_client(my_data->csd); |
| 529 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 530 | free(platform); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 531 | /* deinit usb */ |
| 532 | audio_extn_usb_deinit(); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 533 | } |
| 534 | |
| 535 | const char *platform_get_snd_device_name(snd_device_t snd_device) |
| 536 | { |
| 537 | if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) |
| 538 | return device_table[snd_device]; |
| 539 | else |
| 540 | return ""; |
| 541 | } |
| 542 | |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 543 | int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device, |
| 544 | char *device_name) |
| 545 | { |
| 546 | struct platform_data *my_data = (struct platform_data *)platform; |
| 547 | |
| 548 | if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) { |
| 549 | strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE); |
| 550 | hw_info_append_hw_type(my_data->hw_info, snd_device, device_name); |
| 551 | } else { |
| 552 | strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE); |
| 553 | return -EINVAL; |
| 554 | } |
| 555 | |
| 556 | return 0; |
| 557 | } |
| 558 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 559 | void platform_add_backend_name(char *mixer_path, snd_device_t snd_device) |
| 560 | { |
| 561 | if (snd_device == SND_DEVICE_IN_BT_SCO_MIC) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 562 | strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH); |
| 563 | else if (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB) |
| 564 | strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 565 | else if(snd_device == SND_DEVICE_OUT_BT_SCO) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 566 | strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH); |
| 567 | else if(snd_device == SND_DEVICE_OUT_BT_SCO_WB) |
| 568 | strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 569 | else if (snd_device == SND_DEVICE_OUT_HDMI) |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 570 | strlcat(mixer_path, " hdmi", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 571 | else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI) |
| 572 | strcat(mixer_path, " speaker-and-hdmi"); |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 573 | else if (snd_device == SND_DEVICE_OUT_AFE_PROXY) |
| 574 | strlcat(mixer_path, " afe-proxy", MIXER_PATH_MAX_LENGTH); |
| 575 | else if (snd_device == SND_DEVICE_OUT_USB_HEADSET) |
| 576 | strlcat(mixer_path, " usb-headphones", MIXER_PATH_MAX_LENGTH); |
| 577 | else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET) |
| 578 | strlcat(mixer_path, " speaker-and-usb-headphones", |
| 579 | MIXER_PATH_MAX_LENGTH); |
| 580 | else if (snd_device == SND_DEVICE_IN_USB_HEADSET_MIC) |
| 581 | strlcat(mixer_path, " usb-headset-mic", MIXER_PATH_MAX_LENGTH); |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 582 | else if (snd_device == SND_DEVICE_IN_CAPTURE_FM) |
| 583 | strlcat(mixer_path, " capture-fm", MIXER_PATH_MAX_LENGTH); |
| 584 | else if (snd_device == SND_DEVICE_OUT_TRANSMISSION_FM) |
| 585 | strlcat(mixer_path, " transmission-fm", MIXER_PATH_MAX_LENGTH); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 586 | } |
| 587 | |
| 588 | int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type) |
| 589 | { |
| 590 | int device_id; |
| 591 | if (device_type == PCM_PLAYBACK) |
| 592 | device_id = pcm_device_table[usecase][0]; |
| 593 | else |
| 594 | device_id = pcm_device_table[usecase][1]; |
| 595 | return device_id; |
| 596 | } |
| 597 | |
| 598 | int platform_send_audio_calibration(void *platform, snd_device_t snd_device) |
| 599 | { |
| 600 | struct platform_data *my_data = (struct platform_data *)platform; |
| 601 | int acdb_dev_id, acdb_dev_type; |
| 602 | |
| 603 | acdb_dev_id = acdb_device_table[snd_device]; |
| 604 | if (acdb_dev_id < 0) { |
| 605 | ALOGE("%s: Could not find acdb id for device(%d)", |
| 606 | __func__, snd_device); |
| 607 | return -EINVAL; |
| 608 | } |
| 609 | if (my_data->acdb_send_audio_cal) { |
Eric Laurent | 994a693 | 2013-07-17 11:51:42 -0700 | [diff] [blame] | 610 | ("%s: sending audio calibration for snd_device(%d) acdb_id(%d)", |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 611 | __func__, snd_device, acdb_dev_id); |
| 612 | if (snd_device >= SND_DEVICE_OUT_BEGIN && |
| 613 | snd_device < SND_DEVICE_OUT_END) |
| 614 | acdb_dev_type = ACDB_DEV_TYPE_OUT; |
| 615 | else |
| 616 | acdb_dev_type = ACDB_DEV_TYPE_IN; |
| 617 | my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type); |
| 618 | } |
| 619 | return 0; |
| 620 | } |
| 621 | |
| 622 | int platform_switch_voice_call_device_pre(void *platform) |
| 623 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 624 | struct platform_data *my_data = (struct platform_data *)platform; |
| 625 | int ret = 0; |
| 626 | |
| 627 | if (my_data->csd != NULL) { |
| 628 | /* This must be called before disabling mixer controls on APQ side */ |
| 629 | ret = my_data->csd->disable_device(); |
| 630 | if (ret < 0) { |
| 631 | ALOGE("%s: csd_client_disable_device, failed, error %d", |
| 632 | __func__, ret); |
| 633 | } |
| 634 | } |
| 635 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 636 | } |
| 637 | |
| 638 | int platform_switch_voice_call_device_post(void *platform, |
| 639 | snd_device_t out_snd_device, |
| 640 | snd_device_t in_snd_device) |
| 641 | { |
| 642 | struct platform_data *my_data = (struct platform_data *)platform; |
| 643 | int acdb_rx_id, acdb_tx_id; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 644 | int ret = 0; |
| 645 | |
| 646 | acdb_rx_id = acdb_device_table[out_snd_device]; |
| 647 | acdb_tx_id = acdb_device_table[in_snd_device]; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 648 | |
| 649 | if (my_data->acdb_send_voice_cal == NULL) { |
| 650 | ALOGE("%s: dlsym error for acdb_send_voice_call", __func__); |
| 651 | } else { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 652 | if (acdb_rx_id > 0 && acdb_tx_id > 0) |
| 653 | my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id); |
| 654 | else |
| 655 | ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, |
| 656 | acdb_rx_id, acdb_tx_id); |
| 657 | } |
| 658 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 659 | if (my_data->csd != NULL) { |
| 660 | if (acdb_rx_id > 0 || acdb_tx_id > 0) { |
| 661 | ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id, |
| 662 | my_data->adev->acdb_settings); |
| 663 | if (ret < 0) { |
| 664 | ALOGE("%s: csd_enable_device, failed, error %d", |
| 665 | __func__, ret); |
| 666 | } |
| 667 | } else { |
| 668 | ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__, |
| 669 | acdb_rx_id, acdb_tx_id); |
| 670 | } |
| 671 | } |
| 672 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 673 | } |
| 674 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 675 | int platform_start_voice_call(void *platform, uint32_t vsid) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 676 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 677 | struct platform_data *my_data = (struct platform_data *)platform; |
| 678 | int ret = 0; |
| 679 | |
| 680 | if (my_data->csd != NULL) { |
| 681 | ret = my_data->csd->start_voice(vsid); |
| 682 | if (ret < 0) { |
| 683 | ALOGE("%s: csd_start_voice error %d\n", __func__, ret); |
| 684 | } |
| 685 | } |
| 686 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 687 | } |
| 688 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 689 | int platform_stop_voice_call(void *platform, uint32_t vsid) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 690 | { |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 691 | struct platform_data *my_data = (struct platform_data *)platform; |
| 692 | int ret = 0; |
| 693 | |
| 694 | if (my_data->csd != NULL) { |
| 695 | ret = my_data->csd->stop_voice(vsid); |
| 696 | if (ret < 0) { |
| 697 | ALOGE("%s: csd_stop_voice error %d\n", __func__, ret); |
| 698 | } |
| 699 | } |
| 700 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 701 | } |
| 702 | |
| 703 | int platform_set_voice_volume(void *platform, int volume) |
| 704 | { |
| 705 | struct platform_data *my_data = (struct platform_data *)platform; |
| 706 | struct audio_device *adev = my_data->adev; |
| 707 | struct mixer_ctl *ctl; |
sangwoo | 53b2cf0 | 2013-07-25 19:18:44 -0700 | [diff] [blame] | 708 | const char *mixer_ctl_name = "Voice Rx Gain"; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 709 | int vol_index = 0, ret = 0; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 710 | uint32_t set_values[ ] = {0, |
| 711 | ALL_SESSION_VSID, |
| 712 | DEFAULT_VOLUME_RAMP_DURATION_MS}; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 713 | |
| 714 | // Voice volume levels are mapped to adsp volume levels as follows. |
| 715 | // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1 0 -> 0 |
| 716 | // 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] | 717 | vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX); |
| 718 | set_values[0] = vol_index; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 719 | |
| 720 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 721 | if (!ctl) { |
| 722 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 723 | __func__, mixer_ctl_name); |
| 724 | return -EINVAL; |
| 725 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 726 | ALOGV("Setting voice volume index: %d", set_values[0]); |
| 727 | mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 728 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 729 | if (my_data->csd != NULL) { |
| 730 | ret = my_data->csd->volume(ALL_SESSION_VSID, volume); |
| 731 | if (ret < 0) { |
| 732 | ALOGE("%s: csd_volume error %d", __func__, ret); |
| 733 | } |
| 734 | } |
| 735 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 736 | } |
| 737 | |
| 738 | int platform_set_mic_mute(void *platform, bool state) |
| 739 | { |
| 740 | struct platform_data *my_data = (struct platform_data *)platform; |
| 741 | struct audio_device *adev = my_data->adev; |
| 742 | struct mixer_ctl *ctl; |
| 743 | const char *mixer_ctl_name = "Voice Tx Mute"; |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 744 | int ret = 0; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 745 | uint32_t set_values[ ] = {0, |
| 746 | ALL_SESSION_VSID, |
| 747 | DEFAULT_VOLUME_RAMP_DURATION_MS}; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 748 | |
| 749 | if (adev->mode == AUDIO_MODE_IN_CALL) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 750 | set_values[0] = state; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 751 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 752 | if (!ctl) { |
| 753 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 754 | __func__, mixer_ctl_name); |
| 755 | return -EINVAL; |
| 756 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 757 | ALOGV("Setting voice mute state: %d", state); |
| 758 | mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 759 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 760 | if (my_data->csd != NULL) { |
| 761 | ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state); |
| 762 | if (ret < 0) { |
| 763 | ALOGE("%s: csd_mic_mute error %d", __func__, ret); |
| 764 | } |
| 765 | } |
| 766 | } |
| 767 | return ret; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 768 | } |
| 769 | |
| 770 | snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices) |
| 771 | { |
| 772 | struct platform_data *my_data = (struct platform_data *)platform; |
| 773 | struct audio_device *adev = my_data->adev; |
| 774 | audio_mode_t mode = adev->mode; |
| 775 | snd_device_t snd_device = SND_DEVICE_NONE; |
| 776 | |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 777 | audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? |
| 778 | AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; |
| 779 | int channel_count = popcount(channel_mask); |
| 780 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 781 | ALOGV("%s: enter: output devices(%#x)", __func__, devices); |
| 782 | if (devices == AUDIO_DEVICE_NONE || |
| 783 | devices & AUDIO_DEVICE_BIT_IN) { |
| 784 | ALOGV("%s: Invalid output devices (%#x)", __func__, devices); |
| 785 | goto exit; |
| 786 | } |
| 787 | |
| 788 | if (mode == AUDIO_MODE_IN_CALL) { |
| 789 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 790 | devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 791 | if (adev->voice.tty_mode == TTY_MODE_FULL) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 792 | snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 793 | } else if (adev->voice.tty_mode == TTY_MODE_VCO) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 794 | snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 795 | } else if (adev->voice.tty_mode == TTY_MODE_HCO) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 796 | snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 797 | } else if (audio_extn_get_anc_enabled()) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 798 | if (audio_extn_should_use_fb_anc()) |
| 799 | snd_device = SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET; |
| 800 | else |
| 801 | snd_device = SND_DEVICE_OUT_VOICE_ANC_HEADSET; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 802 | } else { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 803 | snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES; |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 804 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 805 | } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 806 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 807 | snd_device = SND_DEVICE_OUT_BT_SCO_WB; |
| 808 | else |
| 809 | snd_device = SND_DEVICE_OUT_BT_SCO; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 810 | } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { |
| 811 | snd_device = SND_DEVICE_OUT_VOICE_SPEAKER; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 812 | } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 813 | devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
| 814 | snd_device = SND_DEVICE_OUT_USB_HEADSET; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 815 | } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { |
| 816 | snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 817 | } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { |
Ravi Kumar Alamanda | ceb4082 | 2013-11-06 11:01:47 -0800 | [diff] [blame] | 818 | if (audio_extn_should_use_handset_anc(channel_count)) |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 819 | snd_device = SND_DEVICE_OUT_ANC_HANDSET; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 820 | else |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 821 | snd_device = SND_DEVICE_OUT_VOICE_HANDSET; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 822 | } |
| 823 | if (snd_device != SND_DEVICE_NONE) { |
| 824 | goto exit; |
| 825 | } |
| 826 | } |
| 827 | |
| 828 | if (popcount(devices) == 2) { |
| 829 | if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE | |
| 830 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 831 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; |
| 832 | } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET | |
| 833 | AUDIO_DEVICE_OUT_SPEAKER)) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 834 | if (audio_extn_get_anc_enabled()) |
| 835 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET; |
| 836 | else |
| 837 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 838 | } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL | |
| 839 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 840 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 841 | } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET | |
| 842 | AUDIO_DEVICE_OUT_SPEAKER)) { |
| 843 | snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 844 | } else { |
| 845 | ALOGE("%s: Invalid combo device(%#x)", __func__, devices); |
| 846 | goto exit; |
| 847 | } |
| 848 | if (snd_device != SND_DEVICE_NONE) { |
| 849 | goto exit; |
| 850 | } |
| 851 | } |
| 852 | |
| 853 | if (popcount(devices) != 1) { |
| 854 | ALOGE("%s: Invalid output devices(%#x)", __func__, devices); |
| 855 | goto exit; |
| 856 | } |
| 857 | |
| 858 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 859 | devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 860 | if (devices & AUDIO_DEVICE_OUT_WIRED_HEADSET |
| 861 | && audio_extn_get_anc_enabled()) { |
| 862 | if (audio_extn_should_use_fb_anc()) |
| 863 | snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET; |
| 864 | else |
| 865 | snd_device = SND_DEVICE_OUT_ANC_HEADSET; |
| 866 | } |
| 867 | else |
| 868 | snd_device = SND_DEVICE_OUT_HEADPHONES; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 869 | } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { |
| 870 | if (adev->speaker_lr_swap) |
| 871 | snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE; |
| 872 | else |
| 873 | snd_device = SND_DEVICE_OUT_SPEAKER; |
| 874 | } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 875 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 876 | snd_device = SND_DEVICE_OUT_BT_SCO_WB; |
| 877 | else |
| 878 | snd_device = SND_DEVICE_OUT_BT_SCO; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 879 | } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { |
| 880 | snd_device = SND_DEVICE_OUT_HDMI ; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 881 | } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 882 | devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
| 883 | snd_device = SND_DEVICE_OUT_USB_HEADSET; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 884 | } else if (devices & AUDIO_DEVICE_OUT_FM_TX) { |
| 885 | snd_device = SND_DEVICE_OUT_TRANSMISSION_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 886 | } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { |
| 887 | snd_device = SND_DEVICE_OUT_HANDSET; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 888 | } else if (devices & AUDIO_DEVICE_OUT_PROXY) { |
| 889 | ALOGD("%s: setting sink capability for Proxy", __func__); |
| 890 | audio_extn_set_afe_proxy_channel_mixer(adev); |
| 891 | snd_device = SND_DEVICE_OUT_AFE_PROXY; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 892 | } else { |
| 893 | ALOGE("%s: Unknown device(s) %#x", __func__, devices); |
| 894 | } |
| 895 | exit: |
| 896 | ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]); |
| 897 | return snd_device; |
| 898 | } |
| 899 | |
| 900 | snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device) |
| 901 | { |
| 902 | struct platform_data *my_data = (struct platform_data *)platform; |
| 903 | struct audio_device *adev = my_data->adev; |
| 904 | audio_source_t source = (adev->active_input == NULL) ? |
| 905 | AUDIO_SOURCE_DEFAULT : adev->active_input->source; |
| 906 | |
| 907 | audio_mode_t mode = adev->mode; |
| 908 | audio_devices_t in_device = ((adev->active_input == NULL) ? |
| 909 | AUDIO_DEVICE_NONE : adev->active_input->device) |
| 910 | & ~AUDIO_DEVICE_BIT_IN; |
| 911 | audio_channel_mask_t channel_mask = (adev->active_input == NULL) ? |
| 912 | AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask; |
| 913 | snd_device_t snd_device = SND_DEVICE_NONE; |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 914 | int channel_count = popcount(channel_mask); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 915 | |
| 916 | ALOGV("%s: enter: out_device(%#x) in_device(%#x)", |
| 917 | __func__, out_device, in_device); |
| 918 | if (mode == AUDIO_MODE_IN_CALL) { |
| 919 | if (out_device == AUDIO_DEVICE_NONE) { |
| 920 | ALOGE("%s: No output device set for voice call", __func__); |
| 921 | goto exit; |
| 922 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 923 | if (adev->voice.tty_mode != TTY_MODE_OFF) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 924 | if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || |
| 925 | out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 926 | switch (adev->voice.tty_mode) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 927 | case TTY_MODE_FULL: |
| 928 | snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC; |
| 929 | break; |
| 930 | case TTY_MODE_VCO: |
| 931 | snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC; |
| 932 | break; |
| 933 | case TTY_MODE_HCO: |
| 934 | snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC; |
| 935 | break; |
| 936 | default: |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 937 | ALOGE("%s: Invalid TTY mode (%#x)", |
| 938 | __func__, adev->voice.tty_mode); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 939 | } |
| 940 | goto exit; |
| 941 | } |
| 942 | } |
| 943 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE || |
| 944 | out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { |
Apoorv Raghuvanshi | 9eaf94e | 2013-10-04 16:13:44 -0700 | [diff] [blame] | 945 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE && |
| 946 | audio_extn_should_use_handset_anc(channel_count)) { |
| 947 | snd_device = SND_DEVICE_IN_AANC_HANDSET_MIC; |
| 948 | } else if (my_data->fluence_type == FLUENCE_NONE || |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 949 | my_data->fluence_in_voice_call == false) { |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 950 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 951 | } else { |
Ravi Kumar Alamanda | ceb4082 | 2013-11-06 11:01:47 -0800 | [diff] [blame] | 952 | snd_device = SND_DEVICE_IN_VOICE_DMIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 953 | adev->acdb_settings |= DMIC_FLAG; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 954 | } |
| 955 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
| 956 | snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC; |
| 957 | } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 958 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 959 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 960 | else |
| 961 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 962 | } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 963 | if (my_data->fluence_type != FLUENCE_NONE && |
| 964 | my_data->fluence_in_voice_call && |
| 965 | my_data->fluence_in_spkr_mode) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 966 | if(my_data->fluence_type & FLUENCE_QUAD_MIC) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 967 | adev->acdb_settings |= QMIC_FLAG; |
| 968 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC; |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 969 | } else { |
| 970 | adev->acdb_settings |= DMIC_FLAG; |
| 971 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 972 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 973 | } else { |
| 974 | snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC; |
| 975 | } |
| 976 | } |
| 977 | } else if (source == AUDIO_SOURCE_CAMCORDER) { |
| 978 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC || |
| 979 | in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 980 | snd_device = SND_DEVICE_IN_CAMCORDER_MIC; |
| 981 | } |
| 982 | } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) { |
| 983 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 984 | if (channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 985 | snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 986 | else if (my_data->fluence_in_voice_rec) |
| 987 | snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 988 | |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 989 | if (snd_device == SND_DEVICE_NONE) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 990 | snd_device = SND_DEVICE_IN_VOICE_REC_MIC; |
Mingming Yin | 8e5a4f6 | 2013-10-07 15:23:41 -0700 | [diff] [blame] | 991 | else |
| 992 | adev->acdb_settings |= DMIC_FLAG; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 993 | } |
| 994 | } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION) { |
| 995 | if (out_device & AUDIO_DEVICE_OUT_SPEAKER) |
| 996 | in_device = AUDIO_DEVICE_IN_BACK_MIC; |
| 997 | if (adev->active_input) { |
| 998 | if (adev->active_input->enable_aec) { |
| 999 | if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1000 | if(my_data->fluence_type & FLUENCE_DUAL_MIC) |
| 1001 | snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC; |
| 1002 | else |
| 1003 | snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1004 | } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1005 | if(my_data->fluence_type & FLUENCE_DUAL_MIC) |
| 1006 | snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC; |
| 1007 | else |
| 1008 | snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1009 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
| 1010 | snd_device = SND_DEVICE_IN_HEADSET_MIC_AEC; |
| 1011 | } |
| 1012 | set_echo_reference(adev->mixer, "SLIM_RX"); |
| 1013 | } else |
| 1014 | set_echo_reference(adev->mixer, "NONE"); |
| 1015 | } |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1016 | } else if (source == AUDIO_SOURCE_MIC) { |
| 1017 | if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1018 | if(my_data->fluence_type & FLUENCE_DUAL_MIC && |
| 1019 | my_data->fluence_in_audio_rec) |
| 1020 | snd_device = SND_DEVICE_IN_SPEAKER_DMIC; |
| 1021 | else |
| 1022 | snd_device = SND_DEVICE_IN_SPEAKER_MIC; |
| 1023 | } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
| 1024 | if(my_data->fluence_type & FLUENCE_DUAL_MIC && |
| 1025 | my_data->fluence_in_audio_rec) |
| 1026 | snd_device = SND_DEVICE_IN_HANDSET_DMIC; |
| 1027 | else |
| 1028 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1029 | } |
Mingming Yin | ab42978 | 2013-11-07 11:16:55 -0800 | [diff] [blame] | 1030 | } else if (source == AUDIO_SOURCE_FM_RX || |
| 1031 | source == AUDIO_SOURCE_FM_RX_A2DP) { |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1032 | snd_device = SND_DEVICE_IN_CAPTURE_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1033 | } else if (source == AUDIO_SOURCE_DEFAULT) { |
| 1034 | goto exit; |
| 1035 | } |
| 1036 | |
| 1037 | |
| 1038 | if (snd_device != SND_DEVICE_NONE) { |
| 1039 | goto exit; |
| 1040 | } |
| 1041 | |
| 1042 | if (in_device != AUDIO_DEVICE_NONE && |
| 1043 | !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) && |
| 1044 | !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) { |
| 1045 | if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 1046 | if (audio_extn_ssr_get_enabled() && channel_count == 6) |
| 1047 | snd_device = SND_DEVICE_IN_QUAD_MIC; |
Ravi Kumar Alamanda | fae4211 | 2013-11-07 23:31:54 -0800 | [diff] [blame] | 1048 | else if (channel_count == 2) |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 1049 | snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC; |
Apoorv Raghuvanshi | 6178a3f | 2013-10-19 12:38:54 -0700 | [diff] [blame] | 1050 | else |
| 1051 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1052 | } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { |
| 1053 | snd_device = SND_DEVICE_IN_SPEAKER_MIC; |
| 1054 | } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { |
| 1055 | snd_device = SND_DEVICE_IN_HEADSET_MIC; |
| 1056 | } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1057 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1058 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 1059 | else |
| 1060 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1061 | } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) { |
| 1062 | snd_device = SND_DEVICE_IN_HDMI_MIC; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1063 | } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET || |
| 1064 | in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) { |
| 1065 | snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; |
Apoorv Raghuvanshi | 6e26284 | 2013-10-06 14:39:35 -0700 | [diff] [blame] | 1066 | } else if (in_device & AUDIO_DEVICE_IN_FM_RX) { |
| 1067 | snd_device = SND_DEVICE_IN_CAPTURE_FM; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1068 | } else { |
| 1069 | ALOGE("%s: Unknown input device(s) %#x", __func__, in_device); |
| 1070 | ALOGW("%s: Using default handset-mic", __func__); |
| 1071 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1072 | } |
| 1073 | } else { |
| 1074 | if (out_device & AUDIO_DEVICE_OUT_EARPIECE) { |
| 1075 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1076 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { |
| 1077 | snd_device = SND_DEVICE_IN_HEADSET_MIC; |
| 1078 | } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { |
Apoorv Raghuvanshi | 6bd8dbf | 2013-10-19 18:37:52 -0700 | [diff] [blame] | 1079 | if (channel_count > 1) |
| 1080 | snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC; |
| 1081 | else |
| 1082 | snd_device = SND_DEVICE_IN_SPEAKER_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1083 | } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { |
| 1084 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1085 | } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1086 | if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ) |
| 1087 | snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB; |
| 1088 | else |
| 1089 | snd_device = SND_DEVICE_IN_BT_SCO_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1090 | } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) { |
| 1091 | snd_device = SND_DEVICE_IN_HDMI_MIC; |
Apoorv Raghuvanshi | 5792d4b | 2013-10-07 18:40:05 -0700 | [diff] [blame] | 1092 | } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET || |
| 1093 | out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { |
| 1094 | snd_device = SND_DEVICE_IN_USB_HEADSET_MIC; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1095 | } else { |
| 1096 | ALOGE("%s: Unknown output device(s) %#x", __func__, out_device); |
| 1097 | ALOGW("%s: Using default handset-mic", __func__); |
| 1098 | snd_device = SND_DEVICE_IN_HANDSET_MIC; |
| 1099 | } |
| 1100 | } |
| 1101 | exit: |
| 1102 | ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]); |
| 1103 | return snd_device; |
| 1104 | } |
| 1105 | |
| 1106 | int platform_set_hdmi_channels(void *platform, int channel_count) |
| 1107 | { |
| 1108 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1109 | struct audio_device *adev = my_data->adev; |
| 1110 | struct mixer_ctl *ctl; |
| 1111 | const char *channel_cnt_str = NULL; |
| 1112 | const char *mixer_ctl_name = "HDMI_RX Channels"; |
| 1113 | switch (channel_count) { |
| 1114 | case 8: |
| 1115 | channel_cnt_str = "Eight"; break; |
| 1116 | case 7: |
| 1117 | channel_cnt_str = "Seven"; break; |
| 1118 | case 6: |
| 1119 | channel_cnt_str = "Six"; break; |
| 1120 | case 5: |
| 1121 | channel_cnt_str = "Five"; break; |
| 1122 | case 4: |
| 1123 | channel_cnt_str = "Four"; break; |
| 1124 | case 3: |
| 1125 | channel_cnt_str = "Three"; break; |
| 1126 | default: |
| 1127 | channel_cnt_str = "Two"; break; |
| 1128 | } |
| 1129 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1130 | if (!ctl) { |
| 1131 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1132 | __func__, mixer_ctl_name); |
| 1133 | return -EINVAL; |
| 1134 | } |
| 1135 | ALOGV("HDMI channel count: %s", channel_cnt_str); |
| 1136 | mixer_ctl_set_enum_by_string(ctl, channel_cnt_str); |
| 1137 | return 0; |
| 1138 | } |
| 1139 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1140 | int platform_edid_get_max_channels(void *platform) |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1141 | { |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1142 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1143 | struct audio_device *adev = my_data->adev; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1144 | char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE]; |
| 1145 | char *sad = block; |
| 1146 | int num_audio_blocks; |
| 1147 | int channel_count; |
| 1148 | int max_channels = 0; |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1149 | int i, ret, count; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1150 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1151 | struct mixer_ctl *ctl; |
| 1152 | |
| 1153 | ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL); |
| 1154 | if (!ctl) { |
| 1155 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1156 | __func__, AUDIO_DATA_BLOCK_MIXER_CTL); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1157 | return 0; |
| 1158 | } |
| 1159 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1160 | mixer_ctl_update(ctl); |
| 1161 | |
| 1162 | count = mixer_ctl_get_num_values(ctl); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1163 | |
| 1164 | /* Read SAD blocks, clamping the maximum size for safety */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1165 | if (count > (int)sizeof(block)) |
| 1166 | count = (int)sizeof(block); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1167 | |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1168 | ret = mixer_ctl_get_array(ctl, block, count); |
| 1169 | if (ret != 0) { |
| 1170 | ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__); |
| 1171 | return 0; |
| 1172 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1173 | |
| 1174 | /* Calculate the number of SAD blocks */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1175 | num_audio_blocks = count / SAD_BLOCK_SIZE; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1176 | |
| 1177 | for (i = 0; i < num_audio_blocks; i++) { |
| 1178 | /* Only consider LPCM blocks */ |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1179 | if ((sad[0] >> 3) != EDID_FORMAT_LPCM) { |
| 1180 | sad += 3; |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1181 | continue; |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 1182 | } |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1183 | |
| 1184 | channel_count = (sad[0] & 0x7) + 1; |
| 1185 | if (channel_count > max_channels) |
| 1186 | max_channels = channel_count; |
| 1187 | |
| 1188 | /* Advance to next block */ |
| 1189 | sad += 3; |
| 1190 | } |
| 1191 | |
| 1192 | return max_channels; |
| 1193 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1194 | |
| 1195 | static int platform_set_slowtalk(struct platform_data *my_data, bool state) |
| 1196 | { |
| 1197 | int ret = 0; |
| 1198 | struct audio_device *adev = my_data->adev; |
| 1199 | struct mixer_ctl *ctl; |
| 1200 | const char *mixer_ctl_name = "Slowtalk Enable"; |
| 1201 | uint32_t set_values[ ] = {0, |
| 1202 | ALL_SESSION_VSID}; |
| 1203 | |
| 1204 | set_values[0] = state; |
| 1205 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1206 | if (!ctl) { |
| 1207 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1208 | __func__, mixer_ctl_name); |
| 1209 | ret = -EINVAL; |
| 1210 | } else { |
| 1211 | ALOGV("Setting slowtalk state: %d", state); |
| 1212 | ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values)); |
| 1213 | my_data->slowtalk = state; |
| 1214 | } |
| 1215 | |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame^] | 1216 | if (my_data->csd != NULL) { |
| 1217 | ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state); |
| 1218 | if (ret < 0) { |
| 1219 | ALOGE("%s: csd_client_disable_device, failed, error %d", |
| 1220 | __func__, ret); |
| 1221 | } |
| 1222 | } |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1223 | return ret; |
| 1224 | } |
| 1225 | |
| 1226 | int platform_set_parameters(void *platform, struct str_parms *parms) |
| 1227 | { |
| 1228 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1229 | char *str; |
| 1230 | char value[32]; |
| 1231 | int val; |
| 1232 | int ret = 0; |
| 1233 | |
| 1234 | ALOGV("%s: enter: %s", __func__, str_parms_to_str(parms)); |
| 1235 | |
| 1236 | ret = str_parms_get_int(parms, AUDIO_PARAMETER_KEY_BTSCO, &val); |
| 1237 | if (ret >= 0) { |
| 1238 | str_parms_del(parms, AUDIO_PARAMETER_KEY_BTSCO); |
| 1239 | pthread_mutex_lock(&my_data->adev->lock); |
| 1240 | my_data->btsco_sample_rate = val; |
| 1241 | pthread_mutex_unlock(&my_data->adev->lock); |
| 1242 | } |
| 1243 | |
| 1244 | ret = str_parms_get_int(parms, AUDIO_PARAMETER_KEY_SLOWTALK, &val); |
| 1245 | if (ret >= 0) { |
| 1246 | str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK); |
| 1247 | pthread_mutex_lock(&my_data->adev->lock); |
| 1248 | ret = platform_set_slowtalk(my_data, val); |
| 1249 | if (ret) |
| 1250 | ALOGE("%s: Failed to set slow talk err: %d", __func__, ret); |
| 1251 | pthread_mutex_unlock(&my_data->adev->lock); |
| 1252 | } |
| 1253 | |
| 1254 | ALOGV("%s: exit with code(%d)", __func__, ret); |
| 1255 | return ret; |
| 1256 | } |
| 1257 | |
Shiv Maliyappanahalli | da10764 | 2013-10-17 11:16:13 -0700 | [diff] [blame] | 1258 | int platform_set_incall_recoding_session_id(void *platform, |
| 1259 | uint32_t session_id) |
| 1260 | { |
| 1261 | int ret = 0; |
| 1262 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1263 | struct audio_device *adev = my_data->adev; |
| 1264 | struct mixer_ctl *ctl; |
| 1265 | const char *mixer_ctl_name = "Voc VSID"; |
| 1266 | int num_ctl_values; |
| 1267 | int i; |
| 1268 | |
| 1269 | ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); |
| 1270 | if (!ctl) { |
| 1271 | ALOGE("%s: Could not get ctl for mixer cmd - %s", |
| 1272 | __func__, mixer_ctl_name); |
| 1273 | ret = -EINVAL; |
| 1274 | } else { |
| 1275 | num_ctl_values = mixer_ctl_get_num_values(ctl); |
| 1276 | for (i = 0; i < num_ctl_values; i++) { |
| 1277 | if (mixer_ctl_set_value(ctl, i, session_id)) { |
| 1278 | ALOGV("Error: invalid session_id: %x", session_id); |
| 1279 | ret = -EINVAL; |
| 1280 | break; |
| 1281 | } |
| 1282 | } |
| 1283 | } |
| 1284 | |
| 1285 | return ret; |
| 1286 | } |
| 1287 | |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1288 | void platform_get_parameters(void *platform, |
| 1289 | struct str_parms *query, |
| 1290 | struct str_parms *reply) |
| 1291 | { |
| 1292 | struct platform_data *my_data = (struct platform_data *)platform; |
| 1293 | char *str = NULL; |
| 1294 | char value[256] = {0}; |
| 1295 | int ret; |
| 1296 | int fluence_type; |
| 1297 | |
| 1298 | ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_FLUENCE_TYPE, |
| 1299 | value, sizeof(value)); |
| 1300 | if (ret >= 0) { |
| 1301 | pthread_mutex_lock(&my_data->adev->lock); |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1302 | if (my_data->fluence_type & FLUENCE_QUAD_MIC) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1303 | strlcpy(value, "fluencepro", sizeof(value)); |
Ravi Kumar Alamanda | b034ddb | 2013-11-06 15:52:18 -0800 | [diff] [blame] | 1304 | } else if (my_data->fluence_type & FLUENCE_DUAL_MIC) { |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 1305 | strlcpy(value, "fluence", sizeof(value)); |
| 1306 | } else { |
| 1307 | strlcpy(value, "none", sizeof(value)); |
| 1308 | } |
| 1309 | pthread_mutex_unlock(&my_data->adev->lock); |
| 1310 | |
| 1311 | str_parms_add_str(reply, AUDIO_PARAMETER_KEY_FLUENCE_TYPE, value); |
| 1312 | } |
| 1313 | |
| 1314 | ALOGV("%s: exit: returns - %s", __func__, str_parms_to_str(reply)); |
| 1315 | } |
| 1316 | |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 1317 | /* Delay in Us */ |
| 1318 | int64_t platform_render_latency(audio_usecase_t usecase) |
| 1319 | { |
| 1320 | switch (usecase) { |
| 1321 | case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER: |
| 1322 | return DEEP_BUFFER_PLATFORM_DELAY; |
| 1323 | case USECASE_AUDIO_PLAYBACK_LOW_LATENCY: |
| 1324 | return LOW_LATENCY_PLATFORM_DELAY; |
| 1325 | default: |
| 1326 | return 0; |
| 1327 | } |
| 1328 | } |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1329 | |
| 1330 | int platform_get_usecase_from_source(int source) |
| 1331 | { |
Mingming Yin | ab42978 | 2013-11-07 11:16:55 -0800 | [diff] [blame] | 1332 | ALOGV("%s: input source :%d", __func__, source); |
| 1333 | if(source == AUDIO_SOURCE_FM_RX_A2DP) |
Preetam Singh Ranawat | de84f1a | 2013-11-01 14:58:16 -0700 | [diff] [blame] | 1334 | return USECASE_AUDIO_RECORD_FM_VIRTUAL; |
| 1335 | else |
| 1336 | return USECASE_AUDIO_RECORD; |
| 1337 | } |