1 /* 2 * Copyright (C) 2013-2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef QCOM_AUDIO_HW_H 18 #define QCOM_AUDIO_HW_H 19 20 #include <cutils/str_parms.h> 21 #include <cutils/list.h> 22 #include <hardware/audio.h> 23 24 #include <tinyalsa/asoundlib.h> 25 #include <tinycompress/tinycompress.h> 26 27 #include <audio_route/audio_route.h> 28 #include "voice.h" 29 30 // dlopen() does not go through default library path search if there is a "/" in the library name. 31 #ifdef __LP64__ 32 #define VISUALIZER_LIBRARY_PATH "/system/lib64/soundfx/libqcomvisualizer.so" 33 #define OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH "/system/lib64/soundfx/libqcompostprocbundle.so" 34 #else 35 #define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so" 36 #define OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH "/system/lib/soundfx/libqcompostprocbundle.so" 37 #endif 38 #define ADM_LIBRARY_PATH "libadm.so" 39 40 /* Flags used to initialize acdb_settings variable that goes to ACDB library */ 41 #define DMIC_FLAG 0x00000002 42 #define TTY_MODE_OFF 0x00000010 43 #define TTY_MODE_FULL 0x00000020 44 #define TTY_MODE_VCO 0x00000040 45 #define TTY_MODE_HCO 0x00000080 46 #define TTY_MODE_CLEAR 0xFFFFFF0F 47 48 #define ACDB_DEV_TYPE_OUT 1 49 #define ACDB_DEV_TYPE_IN 2 50 51 #define MAX_SUPPORTED_CHANNEL_MASKS 2 52 #define DEFAULT_HDMI_OUT_CHANNELS 2 53 54 typedef enum card_status_t { 55 CARD_STATUS_OFFLINE, 56 CARD_STATUS_ONLINE 57 } card_status_t; 58 59 /* These are the supported use cases by the hardware. 60 * Each usecase is mapped to a specific PCM device. 61 * Refer to pcm_device_table[]. 62 */ 63 enum { 64 USECASE_INVALID = -1, 65 /* Playback usecases */ 66 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER = 0, 67 USECASE_AUDIO_PLAYBACK_LOW_LATENCY, 68 USECASE_AUDIO_PLAYBACK_MULTI_CH, 69 USECASE_AUDIO_PLAYBACK_OFFLOAD, 70 USECASE_AUDIO_PLAYBACK_TTS, 71 USECASE_AUDIO_PLAYBACK_ULL, 72 73 /* HFP Use case*/ 74 USECASE_AUDIO_HFP_SCO, 75 USECASE_AUDIO_HFP_SCO_WB, 76 77 /* Capture usecases */ 78 USECASE_AUDIO_RECORD, 79 USECASE_AUDIO_RECORD_LOW_LATENCY, 80 81 /* Voice extension usecases 82 * 83 * Following usecase are specific to voice session names created by 84 * MODEM and APPS on 8992/8994/8084/8974 platforms. 85 */ 86 USECASE_VOICE_CALL, /* Usecase setup for voice session on first subscription for DSDS/DSDA */ 87 USECASE_VOICE2_CALL, /* Usecase setup for voice session on second subscription for DSDS/DSDA */ 88 USECASE_VOLTE_CALL, /* Usecase setup for VoLTE session on first subscription */ 89 USECASE_QCHAT_CALL, /* Usecase setup for QCHAT session */ 90 USECASE_VOWLAN_CALL, /* Usecase setup for VoWLAN session */ 91 92 /* 93 * Following usecase are specific to voice session names created by 94 * MODEM and APPS on 8996 platforms. 95 */ 96 97 USECASE_VOICEMMODE1_CALL, /* Usecase setup for Voice/VoLTE/VoWLAN sessions on first 98 * subscription for DSDS/DSDA 99 */ 100 USECASE_VOICEMMODE2_CALL, /* Usecase setup for voice/VoLTE/VoWLAN sessions on second 101 * subscription for DSDS/DSDA 102 */ 103 104 USECASE_INCALL_REC_UPLINK, 105 USECASE_INCALL_REC_DOWNLINK, 106 USECASE_INCALL_REC_UPLINK_AND_DOWNLINK, 107 108 USECASE_AUDIO_SPKR_CALIB_RX, 109 USECASE_AUDIO_SPKR_CALIB_TX, 110 111 USECASE_AUDIO_PLAYBACK_AFE_PROXY, 112 USECASE_AUDIO_RECORD_AFE_PROXY, 113 USECASE_AUDIO_DSM_FEEDBACK, 114 115 AUDIO_USECASE_MAX 116 }; 117 118 const char * const use_case_table[AUDIO_USECASE_MAX]; 119 120 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 121 122 /* 123 * tinyAlsa library interprets period size as number of frames 124 * one frame = channel_count * sizeof (pcm sample) 125 * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes 126 * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes 127 * We should take care of returning proper size when AudioFlinger queries for 128 * the buffer size of an input/output stream 129 */ 130 131 enum { 132 OFFLOAD_CMD_EXIT, /* exit compress offload thread loop*/ 133 OFFLOAD_CMD_DRAIN, /* send a full drain request to DSP */ 134 OFFLOAD_CMD_PARTIAL_DRAIN, /* send a partial drain request to DSP */ 135 OFFLOAD_CMD_WAIT_FOR_BUFFER, /* wait for buffer released by DSP */ 136 OFFLOAD_CMD_ERROR, /* offload playback hit some error */ 137 }; 138 139 enum { 140 OFFLOAD_STATE_IDLE, 141 OFFLOAD_STATE_PLAYING, 142 OFFLOAD_STATE_PAUSED, 143 }; 144 145 struct offload_cmd { 146 struct listnode node; 147 int cmd; 148 int data[]; 149 }; 150 151 struct stream_out { 152 struct audio_stream_out stream; 153 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 154 pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by playback thread */ 155 pthread_cond_t cond; 156 struct pcm_config config; 157 struct compr_config compr_config; 158 struct pcm *pcm; 159 struct compress *compr; 160 int standby; 161 int pcm_device_id; 162 unsigned int sample_rate; 163 audio_channel_mask_t channel_mask; 164 audio_format_t format; 165 audio_devices_t devices; 166 audio_output_flags_t flags; 167 audio_usecase_t usecase; 168 /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */ 169 audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1]; 170 bool muted; 171 uint64_t written; /* total frames written, not cleared when entering standby */ 172 audio_io_handle_t handle; 173 174 int non_blocking; 175 int playback_started; 176 int offload_state; 177 pthread_cond_t offload_cond; 178 pthread_t offload_thread; 179 struct listnode offload_cmd_list; 180 bool offload_thread_blocked; 181 182 stream_callback_t offload_callback; 183 void *offload_cookie; 184 struct compr_gapless_mdata gapless_mdata; 185 int send_new_metadata; 186 bool realtime; 187 int af_period_multiplier; 188 bool routing_change; 189 struct audio_device *dev; 190 card_status_t card_status; 191 }; 192 193 struct stream_in { 194 struct audio_stream_in stream; 195 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 196 pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by capture thread */ 197 struct pcm_config config; 198 struct pcm *pcm; 199 int standby; 200 int source; 201 int pcm_device_id; 202 audio_devices_t device; 203 audio_channel_mask_t channel_mask; 204 audio_usecase_t usecase; 205 bool enable_aec; 206 bool enable_ns; 207 int64_t frames_read; /* total frames read, not cleared when entering standby */ 208 209 audio_io_handle_t capture_handle; 210 audio_input_flags_t flags; 211 bool is_st_session; 212 bool is_st_session_active; 213 bool realtime; 214 int af_period_multiplier; 215 bool routing_change; 216 struct audio_device *dev; 217 audio_format_t format; 218 card_status_t card_status; 219 }; 220 221 typedef enum { 222 PCM_PLAYBACK, 223 PCM_CAPTURE, 224 VOICE_CALL, 225 PCM_HFP_CALL 226 } usecase_type_t; 227 228 union stream_ptr { 229 struct stream_in *in; 230 struct stream_out *out; 231 }; 232 233 struct audio_usecase { 234 struct listnode list; 235 audio_usecase_t id; 236 usecase_type_t type; 237 audio_devices_t devices; 238 snd_device_t out_snd_device; 239 snd_device_t in_snd_device; 240 union stream_ptr stream; 241 }; 242 243 typedef void* (*adm_init_t)(); 244 typedef void (*adm_deinit_t)(void *); 245 typedef void (*adm_register_output_stream_t)(void *, audio_io_handle_t, audio_output_flags_t); 246 typedef void (*adm_register_input_stream_t)(void *, audio_io_handle_t, audio_input_flags_t); 247 typedef void (*adm_deregister_stream_t)(void *, audio_io_handle_t); 248 typedef void (*adm_request_focus_t)(void *, audio_io_handle_t); 249 typedef void (*adm_abandon_focus_t)(void *, audio_io_handle_t); 250 typedef void (*adm_set_config_t)(void *, audio_io_handle_t, 251 struct pcm *, 252 struct pcm_config *); 253 typedef void (*adm_request_focus_v2_t)(void *, audio_io_handle_t, long); 254 typedef bool (*adm_is_noirq_avail_t)(void *, int, int, int); 255 typedef void (*adm_on_routing_change_t)(void *, audio_io_handle_t); 256 257 struct audio_device { 258 struct audio_hw_device device; 259 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 260 struct mixer *mixer; 261 audio_mode_t mode; 262 struct stream_in *active_input; 263 struct stream_out *primary_output; 264 struct stream_out *voice_tx_output; 265 struct stream_out *current_call_output; 266 bool bluetooth_nrec; 267 bool screen_off; 268 int *snd_dev_ref_cnt; 269 struct listnode usecase_list; 270 struct audio_route *audio_route; 271 int acdb_settings; 272 struct voice voice; 273 unsigned int cur_hdmi_channels; 274 bool bt_wb_speech_enabled; 275 bool mic_muted; 276 bool enable_voicerx; 277 bool enable_hfp; 278 279 int snd_card; 280 void *platform; 281 void *extspk; 282 283 card_status_t card_status; 284 285 void *visualizer_lib; 286 int (*visualizer_start_output)(audio_io_handle_t, int); 287 int (*visualizer_stop_output)(audio_io_handle_t, int); 288 289 /* The pcm_params use_case_table is loaded by adev_verify_devices() upon 290 * calling adev_open(). 291 * 292 * If an entry is not NULL, it can be used to determine if extended precision 293 * or other capabilities are present for the device corresponding to that usecase. 294 */ 295 struct pcm_params *use_case_table[AUDIO_USECASE_MAX]; 296 void *offload_effects_lib; 297 int (*offload_effects_start_output)(audio_io_handle_t, int); 298 int (*offload_effects_stop_output)(audio_io_handle_t, int); 299 300 void *adm_data; 301 void *adm_lib; 302 adm_init_t adm_init; 303 adm_deinit_t adm_deinit; 304 adm_register_input_stream_t adm_register_input_stream; 305 adm_register_output_stream_t adm_register_output_stream; 306 adm_deregister_stream_t adm_deregister_stream; 307 adm_request_focus_t adm_request_focus; 308 adm_abandon_focus_t adm_abandon_focus; 309 adm_set_config_t adm_set_config; 310 adm_request_focus_v2_t adm_request_focus_v2; 311 adm_is_noirq_avail_t adm_is_noirq_avail; 312 adm_on_routing_change_t adm_on_routing_change; 313 314 /* logging */ 315 snd_device_t last_logged_snd_device[AUDIO_USECASE_MAX][2]; /* [out, in] */ 316 }; 317 318 int select_devices(struct audio_device *adev, 319 audio_usecase_t uc_id); 320 321 int disable_audio_route(struct audio_device *adev, 322 struct audio_usecase *usecase); 323 324 int disable_snd_device(struct audio_device *adev, 325 snd_device_t snd_device); 326 327 int enable_snd_device(struct audio_device *adev, 328 snd_device_t snd_device); 329 330 int enable_audio_route(struct audio_device *adev, 331 struct audio_usecase *usecase); 332 333 struct audio_usecase *get_usecase_from_list(struct audio_device *adev, 334 audio_usecase_t uc_id); 335 336 #define LITERAL_TO_STRING(x) #x 337 #define CHECK(condition) LOG_ALWAYS_FATAL_IF(!(condition), "%s",\ 338 __FILE__ ":" LITERAL_TO_STRING(__LINE__)\ 339 " ASSERT_FATAL(" #condition ") failed.") 340 341 /* 342 * NOTE: when multiple mutexes have to be acquired, always take the 343 * stream_in or stream_out mutex first, followed by the audio_device mutex. 344 */ 345 346 #endif // QCOM_AUDIO_HW_H 347