Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 1 | /* |
Aalique Grahame | 22e4910 | 2018-12-18 14:23:57 -0800 | [diff] [blame] | 2 | * Copyright (c) 2013-2019, The Linux Foundation. All rights reserved. |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 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 | |
Ben Romberger | 5588688 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 20 | #ifndef AUDIO_PLATFORM_API_H |
| 21 | #define AUDIO_PLATFORM_API_H |
Vidyakumar Athota | 21b3bb9 | 2014-04-25 11:08:08 -0700 | [diff] [blame] | 22 | #include <sound/voice_params.h> |
Aniket Kumar Lata | f56b640 | 2016-10-27 12:03:18 -0700 | [diff] [blame] | 23 | #include "audio_hw.h" |
| 24 | #include "voice.h" |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 25 | |
Mingming Yin | 3ee55c6 | 2014-08-04 14:23:35 -0700 | [diff] [blame] | 26 | #define CODEC_BACKEND_DEFAULT_BIT_WIDTH 16 |
| 27 | #define CODEC_BACKEND_DEFAULT_SAMPLE_RATE 48000 |
Ashish Jain | b26edfb | 2016-08-25 00:10:11 +0530 | [diff] [blame] | 28 | #define CODEC_BACKEND_DEFAULT_CHANNELS 2 |
Kuirong Wang | 0b947f7 | 2016-09-29 11:03:09 -0700 | [diff] [blame] | 29 | #define CODEC_BACKEND_DEFAULT_TX_CHANNELS 1 |
Ashish Jain | a052e57 | 2016-11-07 16:41:07 +0530 | [diff] [blame] | 30 | #define SAMPLE_RATE_8000 8000 |
| 31 | #define SAMPLE_RATE_11025 11025 |
| 32 | #define sample_rate_multiple(sr, base) ((sr % base)== 0?true:false) |
Aniket Kumar Lata | f56b640 | 2016-10-27 12:03:18 -0700 | [diff] [blame] | 33 | #define MAX_VOLUME_CAL_STEPS 15 |
Surendar karka | 3056979 | 2018-05-08 12:02:21 +0530 | [diff] [blame] | 34 | #define LICENSE_STR_MAX_LEN (64) |
| 35 | #define PRODUCT_FFV "ffv" |
| 36 | #define PRODUCT_ALLPLAY "allplay" |
Vignesh Kulothungan | 5539688 | 2017-04-20 14:37:02 -0700 | [diff] [blame] | 37 | |
| 38 | typedef enum { |
| 39 | PLATFORM, |
| 40 | ACDB_EXTN, |
| 41 | } caller_t; |
Aniket Kumar Lata | f56b640 | 2016-10-27 12:03:18 -0700 | [diff] [blame] | 42 | |
Garmond Leung | 438932f | 2017-10-04 19:35:18 -0700 | [diff] [blame] | 43 | struct audio_backend_cfg { |
| 44 | unsigned int sample_rate; |
| 45 | unsigned int channels; |
| 46 | unsigned int bit_width; |
| 47 | bool passthrough_enabled; |
| 48 | audio_format_t format; |
| 49 | }; |
| 50 | |
Aniket Kumar Lata | f56b640 | 2016-10-27 12:03:18 -0700 | [diff] [blame] | 51 | struct amp_db_and_gain_table { |
| 52 | float amp; |
| 53 | float db; |
| 54 | uint32_t level; |
| 55 | }; |
Mingming Yin | 3ee55c6 | 2014-08-04 14:23:35 -0700 | [diff] [blame] | 56 | |
Naresh Tanniru | dcb47c5 | 2018-06-25 16:23:32 +0530 | [diff] [blame] | 57 | struct mic_info { |
| 58 | char device_id[AUDIO_MICROPHONE_ID_MAX_LEN]; |
| 59 | size_t channel_count; |
| 60 | audio_microphone_channel_mapping_t channel_mapping[AUDIO_CHANNEL_COUNT_MAX]; |
| 61 | }; |
| 62 | |
Sidipotu Ashok | e6f78cb | 2015-11-05 14:42:20 +0530 | [diff] [blame] | 63 | enum { |
| 64 | NATIVE_AUDIO_MODE_SRC = 1, |
| 65 | NATIVE_AUDIO_MODE_TRUE_44_1, |
Preetam Singh Ranawat | cb6212e | 2016-07-19 18:33:53 +0530 | [diff] [blame] | 66 | NATIVE_AUDIO_MODE_MULTIPLE_44_1, |
Sidipotu Ashok | e6f78cb | 2015-11-05 14:42:20 +0530 | [diff] [blame] | 67 | NATIVE_AUDIO_MODE_INVALID |
| 68 | }; |
| 69 | |
| 70 | typedef struct { |
| 71 | bool platform_na_prop_enabled; |
| 72 | bool ui_na_prop_enabled; |
| 73 | int na_mode; |
| 74 | } native_audio_prop; |
| 75 | |
Siena Richard | 7c2db77 | 2016-12-21 11:32:34 -0800 | [diff] [blame] | 76 | #define BE_DAI_NAME_MAX_LENGTH 24 |
| 77 | struct be_dai_name_struct { |
| 78 | unsigned int be_id; |
| 79 | char be_name[BE_DAI_NAME_MAX_LENGTH]; |
| 80 | }; |
| 81 | |
Aditya Bavanari | 29bcea2 | 2017-10-03 20:10:35 +0530 | [diff] [blame] | 82 | typedef struct acdb_audio_cal_cfg { |
| 83 | uint32_t persist; |
| 84 | uint32_t snd_dev_id; |
| 85 | audio_devices_t dev_id; |
| 86 | int32_t acdb_dev_id; |
| 87 | uint32_t app_type; |
| 88 | uint32_t topo_id; |
| 89 | uint32_t sampling_rate; |
| 90 | uint32_t cal_type; |
| 91 | uint32_t module_id; |
| 92 | #ifdef INSTANCE_ID_ENABLED |
| 93 | uint16_t instance_id; |
| 94 | uint16_t reserved; |
| 95 | #endif |
| 96 | uint32_t param_id; |
| 97 | } acdb_audio_cal_cfg_t; |
| 98 | |
Dhananjay Kumar | 429eb45 | 2018-12-10 22:26:53 +0530 | [diff] [blame] | 99 | |
| 100 | struct audio_custom_mtmx_params_info { |
| 101 | uint32_t id; |
| 102 | uint32_t ip_channels; |
| 103 | uint32_t op_channels; |
| 104 | uint32_t usecase_id; |
| 105 | uint32_t snd_device; |
| 106 | }; |
| 107 | |
| 108 | struct audio_custom_mtmx_params { |
| 109 | struct listnode list; |
| 110 | struct audio_custom_mtmx_params_info info; |
| 111 | uint32_t coeffs[0]; |
| 112 | }; |
| 113 | |
Haynes Mathew George | 3a1f1fb | 2016-08-09 15:43:13 -0700 | [diff] [blame] | 114 | enum card_status_t; |
| 115 | |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 116 | void *platform_init(struct audio_device *adev); |
| 117 | void platform_deinit(void *platform); |
| 118 | const char *platform_get_snd_device_name(snd_device_t snd_device); |
Aniket Kumar Lata | f56b640 | 2016-10-27 12:03:18 -0700 | [diff] [blame] | 119 | |
| 120 | /* return true if adding entry success |
| 121 | return false if adding entry fails */ |
| 122 | |
| 123 | bool platform_add_gain_level_mapping(struct amp_db_and_gain_table *tbl_entry); |
| 124 | |
| 125 | /* return 0 if no custome mapping table found or when error detected |
| 126 | use default mapping in this case |
| 127 | return > 0 indicates number of entries in mapping table */ |
| 128 | |
| 129 | int platform_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl, |
| 130 | int table_size); |
| 131 | |
Ravi Kumar Alamanda | 48c921d | 2013-10-29 06:07:44 -0700 | [diff] [blame] | 132 | int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device, |
| 133 | char *device_name); |
Banajit Goswami | 20cdd21 | 2015-09-11 01:11:30 -0700 | [diff] [blame] | 134 | void platform_add_backend_name(char *mixer_path, snd_device_t snd_device, |
| 135 | struct audio_usecase *usecase); |
vivek mehta | a76401a | 2015-04-24 14:12:15 -0700 | [diff] [blame] | 136 | bool platform_send_gain_dep_cal(void *platform, int level); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 137 | int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type); |
Ben Romberger | 61764e3 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 138 | int platform_get_snd_device_index(char *snd_device_index_name); |
Venkata Narendra Kumar Gutta | 88fd0bc | 2014-03-27 19:47:56 +0530 | [diff] [blame] | 139 | int platform_set_fluence_type(void *platform, char *value); |
| 140 | int platform_get_fluence_type(void *platform, char *value, uint32_t len); |
Ben Romberger | 5588688 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 141 | int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id); |
Subhash Chandra Bose Naripeddy | 19dc03b | 2014-03-10 14:43:05 -0700 | [diff] [blame] | 142 | int platform_get_snd_device_acdb_id(snd_device_t snd_device); |
Amit Shekhar | 5a39c91 | 2014-10-14 15:39:30 -0700 | [diff] [blame] | 143 | int platform_set_snd_device_bit_width(snd_device_t snd_device, unsigned int bit_width); |
Vikram Panduranga | df59cae | 2017-08-03 18:04:55 -0700 | [diff] [blame] | 144 | int platform_set_effect_config_data(snd_device_t snd_device, |
| 145 | struct audio_effect_config effect_config, |
| 146 | effect_type_t effect_type); |
| 147 | int platform_get_effect_config_data(snd_device_t snd_device, |
| 148 | struct audio_effect_config *effect_config, |
| 149 | effect_type_t effect_type); |
Amit Shekhar | 5a39c91 | 2014-10-14 15:39:30 -0700 | [diff] [blame] | 150 | int platform_get_snd_device_bit_width(snd_device_t snd_device); |
Dhanalakshmi Siddani | 21be3ac | 2016-12-29 14:31:08 +0530 | [diff] [blame] | 151 | int platform_set_acdb_metainfo_key(void *platform, char *name, int key); |
Ramu Gottipati | 62f6d9b | 2018-05-01 15:21:38 +0530 | [diff] [blame] | 152 | void platform_release_acdb_metainfo_key(void *platform); |
Dhanalakshmi Siddani | 21be3ac | 2016-12-29 14:31:08 +0530 | [diff] [blame] | 153 | int platform_get_meta_info_key_from_list(void *platform, char *mod_name); |
Sidipotu Ashok | e6f78cb | 2015-11-05 14:42:20 +0530 | [diff] [blame] | 154 | int platform_set_native_support(int na_mode); |
Apoorv Raghuvanshi | 2149216 | 2015-02-19 18:19:36 -0800 | [diff] [blame] | 155 | int platform_get_native_support(); |
Preetam Singh Ranawat | 2d0e463 | 2015-02-02 12:40:59 +0530 | [diff] [blame] | 156 | int platform_send_audio_calibration(void *platform, struct audio_usecase *usecase, |
Subhash Chandra Bose Naripeddy | 5427467 | 2014-03-10 14:51:02 -0700 | [diff] [blame] | 157 | int app_type, int sample_rate); |
| 158 | int platform_get_default_app_type(void *platform); |
Srikanth Uyyala | a1e3235 | 2015-10-09 14:48:04 +0530 | [diff] [blame] | 159 | int platform_get_default_app_type_v2(void *platform, usecase_type_t type); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 160 | int platform_switch_voice_call_device_pre(void *platform); |
Vidyakumar Athota | 545dbd3 | 2013-11-13 17:30:53 -0800 | [diff] [blame] | 161 | int platform_switch_voice_call_enable_device_config(void *platform, |
| 162 | snd_device_t out_snd_device, |
| 163 | snd_device_t in_snd_device); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 164 | int platform_switch_voice_call_device_post(void *platform, |
| 165 | snd_device_t out_snd_device, |
| 166 | snd_device_t in_snd_device); |
Vidyakumar Athota | 1fd2179 | 2013-11-15 14:50:57 -0800 | [diff] [blame] | 167 | int platform_switch_voice_call_usecase_route_post(void *platform, |
| 168 | snd_device_t out_snd_device, |
| 169 | snd_device_t in_snd_device); |
Vidyakumar Athota | d9d9ff3 | 2013-11-13 11:46:52 -0800 | [diff] [blame] | 170 | int platform_start_voice_call(void *platform, uint32_t vsid); |
| 171 | int platform_stop_voice_call(void *platform, uint32_t vsid); |
Vignesh Kulothungan | 7d37431 | 2018-02-21 17:12:00 -0800 | [diff] [blame] | 172 | int platform_set_mic_break_det(void *platform, bool enable); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 173 | int platform_set_voice_volume(void *platform, int volume); |
Aalique Grahame | 22e4910 | 2018-12-18 14:23:57 -0800 | [diff] [blame] | 174 | void platform_set_speaker_gain_in_combo(struct audio_device *adev, |
| 175 | snd_device_t snd_device, |
| 176 | bool enable); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 177 | int platform_set_mic_mute(void *platform, bool state); |
Helen Zeng | 6a16ad7 | 2014-02-23 22:04:44 -0800 | [diff] [blame] | 178 | int platform_get_sample_rate(void *platform, uint32_t *rate); |
Shiv Maliyappanahalli | c6fd8ee | 2014-03-07 15:31:55 -0800 | [diff] [blame] | 179 | int platform_set_device_mute(void *platform, bool state, char *dir); |
Apoorv Raghuvanshi | f59bb22 | 2015-02-18 12:23:23 -0800 | [diff] [blame] | 180 | snd_device_t platform_get_output_snd_device(void *platform, struct stream_out *out); |
Eric Laurent | b23d528 | 2013-05-14 15:27:20 -0700 | [diff] [blame] | 181 | snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device); |
| 182 | int platform_set_hdmi_channels(void *platform, int channel_count); |
Haynes Mathew George | 47cd4cb | 2013-07-19 11:58:50 -0700 | [diff] [blame] | 183 | int platform_edid_get_max_channels(void *platform); |
Aalique Grahame | 22e4910 | 2018-12-18 14:23:57 -0800 | [diff] [blame] | 184 | void platform_add_operator_specific_device(snd_device_t snd_device, |
| 185 | const char *operator, |
| 186 | const char *mixer_path, |
| 187 | unsigned int acdb_id); |
Shiv Maliyappanahalli | 34b585f | 2013-10-01 15:49:05 -0700 | [diff] [blame] | 188 | void platform_get_parameters(void *platform, struct str_parms *query, |
| 189 | struct str_parms *reply); |
| 190 | int platform_set_parameters(void *platform, struct str_parms *parms); |
Vidyakumar Athota | 2850d53 | 2013-11-19 16:02:12 -0800 | [diff] [blame] | 191 | int platform_set_incall_recording_session_id(void *platform, uint32_t session_id, |
| 192 | int rec_mode); |
Aalique Grahame | 22e4910 | 2018-12-18 14:23:57 -0800 | [diff] [blame] | 193 | #ifndef INCALL_STEREO_CAPTURE_ENABLED |
| 194 | #define platform_set_incall_recording_session_channels(p, sc) (0) |
| 195 | #else |
| 196 | int platform_set_incall_recording_session_channels(void *platform, |
| 197 | uint32_t session_channels); |
| 198 | #endif |
Vidyakumar Athota | 2850d53 | 2013-11-19 16:02:12 -0800 | [diff] [blame] | 199 | int platform_stop_incall_recording_usecase(void *platform); |
| 200 | int platform_start_incall_music_usecase(void *platform); |
| 201 | int platform_stop_incall_music_usecase(void *platform); |
Vidyakumar Athota | 21b3bb9 | 2014-04-25 11:08:08 -0700 | [diff] [blame] | 202 | int platform_update_lch(void *platform, struct voice_session *session, |
| 203 | enum voice_lch_mode lch_mode); |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 204 | /* returns the latency for a usecase in Us */ |
| 205 | int64_t platform_render_latency(audio_usecase_t usecase); |
Mingming Yin | e62d784 | 2013-10-25 16:26:03 -0700 | [diff] [blame] | 206 | int platform_update_usecase_from_source(int source, audio_usecase_t usecase); |
Haynes Mathew George | 7ff216f | 2013-09-11 19:51:41 -0700 | [diff] [blame] | 207 | |
Dhananjay Kumar | 45b7174 | 2014-05-29 21:47:27 +0530 | [diff] [blame] | 208 | bool platform_listen_device_needs_event(snd_device_t snd_device); |
| 209 | bool platform_listen_usecase_needs_event(audio_usecase_t uc_id); |
Kiran Kandi | de144c8 | 2013-11-20 15:58:32 -0800 | [diff] [blame] | 210 | |
Ravi Kumar Alamanda | 8fa6b19 | 2014-09-09 16:06:42 -0700 | [diff] [blame] | 211 | bool platform_sound_trigger_device_needs_event(snd_device_t snd_device); |
| 212 | bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id); |
| 213 | |
Sidipotu Ashok | 9f0b16e | 2016-04-28 13:48:28 +0530 | [diff] [blame] | 214 | int platform_set_snd_device_backend(snd_device_t snd_device, const char * backend, |
| 215 | const char * hw_interface); |
Siena Richard | 7c2db77 | 2016-12-21 11:32:34 -0800 | [diff] [blame] | 216 | int platform_get_snd_device_backend_index(snd_device_t device); |
Naresh Tanniru | 6160c71 | 2017-04-17 15:43:48 +0530 | [diff] [blame] | 217 | const char * platform_get_snd_device_backend_interface(snd_device_t device); |
Aalique Grahame | 22e4910 | 2018-12-18 14:23:57 -0800 | [diff] [blame] | 218 | void platform_add_app_type(const char *uc_type, |
| 219 | const char *mode, |
| 220 | int bw, int app_type, int max_sr); |
Haynes Mathew George | f4da6fe | 2014-06-20 19:14:25 -0700 | [diff] [blame] | 221 | |
Ravi Kumar Alamanda | 14b0f2d | 2015-06-28 21:04:09 -0700 | [diff] [blame] | 222 | /* From platform_info.c */ |
Vignesh Kulothungan | 5539688 | 2017-04-20 14:37:02 -0700 | [diff] [blame] | 223 | int platform_info_init(const char *filename, void *, caller_t); |
Ben Romberger | 61764e3 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 224 | |
Dhananjay Kumar | e6293dd | 2017-05-25 17:25:30 +0530 | [diff] [blame] | 225 | void platform_snd_card_update(void *platform, card_status_t scard_status); |
Ben Romberger | feca4b8 | 2015-07-07 20:40:44 -0700 | [diff] [blame] | 226 | |
ApurupaPattapu | c6a3a9e | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 227 | struct audio_offload_info_t; |
| 228 | uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info); |
Garmond Leung | 438932f | 2017-10-04 19:35:18 -0700 | [diff] [blame] | 229 | int platform_get_codec_backend_cfg(struct audio_device* adev, |
| 230 | snd_device_t snd_device, |
| 231 | struct audio_backend_cfg *backend_cfg); |
ApurupaPattapu | c6a3a9e | 2014-01-10 14:46:02 -0800 | [diff] [blame] | 232 | |
Apoorv Raghuvanshi | 2149216 | 2015-02-19 18:19:36 -0800 | [diff] [blame] | 233 | bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev, |
| 234 | struct audio_usecase *usecase, snd_device_t snd_device); |
Manish Dewangan | ba9fcfa | 2016-03-24 16:20:06 +0530 | [diff] [blame] | 235 | bool platform_check_and_set_capture_codec_backend_cfg(struct audio_device* adev, |
| 236 | struct audio_usecase *usecase, snd_device_t snd_device); |
Haynes Mathew George | f4da6fe | 2014-06-20 19:14:25 -0700 | [diff] [blame] | 237 | int platform_get_usecase_index(const char * usecase); |
| 238 | int platform_set_usecase_pcm_id(audio_usecase_t usecase, int32_t type, int32_t pcm_id); |
Apoorv Raghuvanshi | 924b302 | 2015-07-06 15:07:14 -0700 | [diff] [blame] | 239 | void platform_set_echo_reference(struct audio_device *adev, bool enable, audio_devices_t out_device); |
Vignesh Kulothungan | 3b5fae5 | 2017-09-25 12:16:30 -0700 | [diff] [blame] | 240 | int platform_check_and_set_swap_lr_channels(struct audio_device *adev, bool swap_channels); |
| 241 | int platform_set_swap_channels(struct audio_device *adev, bool swap_channels); |
Pradnya Chaphekar | 8a9dcd8 | 2014-09-09 09:49:10 -0700 | [diff] [blame] | 242 | void platform_get_device_to_be_id_map(int **be_id_map, int *length); |
Haynes Mathew George | f4da6fe | 2014-06-20 19:14:25 -0700 | [diff] [blame] | 243 | |
Pradnya Chaphekar | 4403bd7 | 2014-09-09 09:50:01 -0700 | [diff] [blame] | 244 | int platform_set_channel_allocation(void *platform, int channel_alloc); |
| 245 | int platform_get_edid_info(void *platform); |
Revathi Uddaraju | 0553e8f | 2017-11-30 14:56:11 +0530 | [diff] [blame] | 246 | int platform_get_supported_copp_sampling_rate(uint32_t stream_sr); |
Pradnya Chaphekar | 4403bd7 | 2014-09-09 09:50:01 -0700 | [diff] [blame] | 247 | int platform_set_channel_map(void *platform, int ch_count, char *ch_map, |
Rohit kumar | 4dbd2c0 | 2019-02-04 16:26:33 +0530 | [diff] [blame] | 248 | int snd_id, int be_idx); |
Naresh Tanniru | 29bce4e | 2017-04-27 17:54:30 +0530 | [diff] [blame] | 249 | int platform_set_stream_channel_map(void *platform, audio_channel_mask_t channel_mask, |
| 250 | int snd_id, uint8_t *input_channel_map); |
Varun Balaraj | e49253e | 2017-07-06 19:48:56 +0530 | [diff] [blame] | 251 | int platform_set_stream_pan_scale_params(void *platform, |
| 252 | int snd_id, |
| 253 | struct mix_matrix_params mm_params); |
| 254 | int platform_set_stream_downmix_params(void *platform, |
| 255 | int snd_id, |
| 256 | snd_device_t snd_device, |
| 257 | struct mix_matrix_params mm_params); |
Rohit kumar | 4dbd2c0 | 2019-02-04 16:26:33 +0530 | [diff] [blame] | 258 | int platform_set_edid_channels_configuration(void *platform, int channels, |
| 259 | int backend_idx, snd_device_t snd_device); |
Dieter Luecking | 5d57def | 2018-09-07 14:23:37 +0200 | [diff] [blame] | 260 | bool platform_spkr_use_default_sample_rate(void *platform); |
Pradnya Chaphekar | 4403bd7 | 2014-09-09 09:50:01 -0700 | [diff] [blame] | 261 | unsigned char platform_map_to_edid_format(int format); |
| 262 | bool platform_is_edid_supported_format(void *platform, int format); |
Mingming Yin | 3a941d4 | 2016-02-17 18:08:05 -0800 | [diff] [blame] | 263 | bool platform_is_edid_supported_sample_rate(void *platform, int sample_rate); |
Pradnya Chaphekar | 4403bd7 | 2014-09-09 09:50:01 -0700 | [diff] [blame] | 264 | void platform_cache_edid(void * platform); |
Mingming Yin | 2185465 | 2016-04-13 11:54:02 -0700 | [diff] [blame] | 265 | void platform_invalidate_hdmi_config(void * platform); |
| 266 | int platform_set_hdmi_config(void *platform, uint32_t channel_count, |
| 267 | uint32_t sample_rate, bool enable_passthrough); |
Pradnya Chaphekar | 80a8cfb | 2014-10-20 16:17:01 -0700 | [diff] [blame] | 268 | int platform_set_device_params(struct stream_out *out, int param, int value); |
Karthik Reddy Katta | 508eca4 | 2015-05-11 13:43:18 +0530 | [diff] [blame] | 269 | int platform_set_audio_device_interface(const char * device_name, const char *intf_name, |
| 270 | const char * codec_type); |
Banajit Goswami | 20cdd21 | 2015-09-11 01:11:30 -0700 | [diff] [blame] | 271 | void platform_set_gsm_mode(void *platform, bool enable); |
Xiaojun Sang | 040cc9f | 2015-08-03 19:38:28 +0800 | [diff] [blame] | 272 | bool platform_can_enable_spkr_prot_on_device(snd_device_t snd_device); |
| 273 | int platform_get_spkr_prot_acdb_id(snd_device_t snd_device); |
| 274 | int platform_get_spkr_prot_snd_device(snd_device_t snd_device); |
Rohit kumar | f412040 | 2016-08-05 19:19:48 +0530 | [diff] [blame] | 275 | int platform_get_vi_feedback_snd_device(snd_device_t snd_device); |
Venkata Narendra Kumar Gutta | 7f4817f | 2016-01-29 14:15:53 +0530 | [diff] [blame] | 276 | int platform_spkr_prot_is_wsa_analog_mode(void *adev); |
Haynes Mathew George | bfe8ff4 | 2016-09-22 17:38:16 -0700 | [diff] [blame] | 277 | int platform_split_snd_device(void *platform, |
| 278 | snd_device_t snd_device, |
| 279 | int *num_devices, |
| 280 | snd_device_t *new_snd_devices); |
Sidipotu Ashok | 9f0b16e | 2016-04-28 13:48:28 +0530 | [diff] [blame] | 281 | |
| 282 | bool platform_check_backends_match(snd_device_t snd_device1, snd_device_t snd_device2); |
Kuirong Wang | 1cad714 | 2016-05-24 15:21:56 -0700 | [diff] [blame] | 283 | int platform_set_sidetone(struct audio_device *adev, |
| 284 | snd_device_t out_snd_device, |
| 285 | bool enable, |
| 286 | char * str); |
Vidyakumar Athota | ea269c6 | 2016-10-31 09:05:59 -0700 | [diff] [blame] | 287 | void platform_update_aanc_path(struct audio_device *adev, |
| 288 | snd_device_t out_snd_device, |
| 289 | bool enable, |
| 290 | char * str); |
Ashish Jain | f1eaa58 | 2016-05-23 20:54:24 +0530 | [diff] [blame] | 291 | bool platform_supports_true_32bit(); |
Preetam Singh Ranawat | b0c0dd7 | 2016-08-18 00:32:06 +0530 | [diff] [blame] | 292 | bool platform_check_if_backend_has_to_be_disabled(snd_device_t new_snd_device, snd_device_t cuurent_snd_device); |
Preetam Singh Ranawat | cb6212e | 2016-07-19 18:33:53 +0530 | [diff] [blame] | 293 | bool platform_check_codec_dsd_support(void *platform); |
Preetam Singh Ranawat | b0c0dd7 | 2016-08-18 00:32:06 +0530 | [diff] [blame] | 294 | bool platform_check_codec_asrc_support(void *platform); |
Preetam Singh Ranawat | cb6212e | 2016-07-19 18:33:53 +0530 | [diff] [blame] | 295 | int platform_get_backend_index(snd_device_t snd_device); |
Shiv Maliyappanahalli | c065640 | 2016-09-03 14:13:26 -0700 | [diff] [blame] | 296 | int platform_get_ext_disp_type(void *platform); |
Garmond Leung | e3b6d48 | 2016-10-25 16:48:01 -0700 | [diff] [blame] | 297 | void platform_invalidate_hdmi_config(void *platform); |
Siddartha Shaik | 44dd770 | 2017-06-14 12:13:25 +0530 | [diff] [blame] | 298 | void platform_invalidate_backend_config(void * platform,snd_device_t snd_device); |
Weiyin Jiang | aa80acd | 2016-09-21 16:42:11 +0800 | [diff] [blame] | 299 | |
Aditya Bavanari | 29bcea2 | 2017-10-03 20:10:35 +0530 | [diff] [blame] | 300 | #ifdef INSTANCE_ID_ENABLED |
| 301 | void platform_make_cal_cfg(acdb_audio_cal_cfg_t* cal, int acdb_dev_id, |
| 302 | int acdb_device_type, int app_type, int topology_id, |
| 303 | int sample_rate, uint32_t module_id, uint16_t instance_id, |
| 304 | uint32_t param_id, bool persist); |
| 305 | #else |
| 306 | void platform_make_cal_cfg(acdb_audio_cal_cfg_t* cal, int acdb_dev_id, |
| 307 | int acdb_device_type, int app_type, int topology_id, |
| 308 | int sample_rate, uint32_t module_id, uint32_t param_id, bool persist); |
| 309 | #endif |
| 310 | |
| 311 | int platform_send_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal, |
Weiyin Jiang | aa80acd | 2016-09-21 16:42:11 +0800 | [diff] [blame] | 312 | void* data, int length, bool persist); |
| 313 | |
Aditya Bavanari | 29bcea2 | 2017-10-03 20:10:35 +0530 | [diff] [blame] | 314 | int platform_get_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal, |
Weiyin Jiang | aa80acd | 2016-09-21 16:42:11 +0800 | [diff] [blame] | 315 | void* data, int* length, bool persist); |
| 316 | |
Aditya Bavanari | 29bcea2 | 2017-10-03 20:10:35 +0530 | [diff] [blame] | 317 | int platform_store_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal, |
Weiyin Jiang | aa80acd | 2016-09-21 16:42:11 +0800 | [diff] [blame] | 318 | void* data, int length); |
| 319 | |
Aditya Bavanari | 29bcea2 | 2017-10-03 20:10:35 +0530 | [diff] [blame] | 320 | int platform_retrieve_audio_cal(void* platform, acdb_audio_cal_cfg_t* cal, |
Weiyin Jiang | aa80acd | 2016-09-21 16:42:11 +0800 | [diff] [blame] | 321 | void* data, int* length); |
| 322 | |
Lakshman Chaluvaraju | 22ba9f1 | 2016-09-12 11:42:10 +0530 | [diff] [blame] | 323 | unsigned char* platform_get_license(void* platform, int* size); |
Divya Narayanan Poojary | 45f1919 | 2016-09-30 18:52:13 +0530 | [diff] [blame] | 324 | int platform_get_max_mic_count(void *platform); |
Ashish Jain | a052e57 | 2016-11-07 16:41:07 +0530 | [diff] [blame] | 325 | void platform_check_and_update_copp_sample_rate(void *platform, snd_device_t snd_device, |
| 326 | unsigned int stream_sr,int *sample_rate); |
Satish Babu Patakokila | c3c5d43 | 2017-07-04 22:48:59 +0530 | [diff] [blame] | 327 | int platform_get_max_codec_backend(); |
Haynes Mathew George | ef51488 | 2017-05-01 17:46:23 -0700 | [diff] [blame] | 328 | int platform_get_mmap_data_fd(void *platform, int dev, int dir, |
| 329 | int *fd, uint32_t *size); |
Garmond Leung | e2433c3 | 2017-09-28 21:51:22 -0700 | [diff] [blame] | 330 | int platform_get_ec_ref_loopback_snd_device(int channel_count); |
Aditya Bavanari | 71b6d53 | 2018-01-16 17:48:08 +0530 | [diff] [blame] | 331 | const char * platform_get_snd_card_name_for_acdb_loader(const char *snd_card_name); |
Naresh Tanniru | dcb47c5 | 2018-06-25 16:23:32 +0530 | [diff] [blame] | 332 | |
| 333 | bool platform_set_microphone_characteristic(void *platform, |
| 334 | struct audio_microphone_characteristic_t mic); |
| 335 | bool platform_set_microphone_map(void *platform, snd_device_t in_snd_device, |
| 336 | const struct mic_info *info); |
| 337 | int platform_get_microphones(void *platform, |
| 338 | struct audio_microphone_characteristic_t *mic_array, |
| 339 | size_t *mic_count); |
| 340 | int platform_get_active_microphones(void *platform, unsigned int channels, |
| 341 | audio_usecase_t usecase, |
| 342 | struct audio_microphone_characteristic_t *mic_array, |
| 343 | size_t *mic_count); |
Naresh Tanniru | cb5b578 | 2018-10-12 20:42:07 +0530 | [diff] [blame] | 344 | |
Surendar karka | 3056979 | 2018-05-08 12:02:21 +0530 | [diff] [blame] | 345 | int platform_get_license_by_product(void *platform, const char* product_name, int *product_id, char* product_license); |
Vignesh Kulothungan | a692727 | 2019-02-20 15:17:07 -0800 | [diff] [blame] | 346 | int platform_get_haptics_pcm_device_id(); |
Dhananjay Kumar | 429eb45 | 2018-12-10 22:26:53 +0530 | [diff] [blame] | 347 | struct audio_custom_mtmx_params * |
| 348 | platform_get_custom_mtmx_params(void *platform, |
| 349 | struct audio_custom_mtmx_params_info *info); |
| 350 | int platform_add_custom_mtmx_params(void *platform, |
| 351 | struct audio_custom_mtmx_params_info *info); |
Ben Romberger | 5588688 | 2014-01-10 13:49:02 -0800 | [diff] [blame] | 352 | #endif // AUDIO_PLATFORM_API_H |