1 /* 2 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. 3 * Not a contribution. 4 * 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 #ifndef QCOM_AUDIO_HW_H 21 #define QCOM_AUDIO_HW_H 22 23 #include <cutils/list.h> 24 #include <hardware/audio.h> 25 #include <tinyalsa/asoundlib.h> 26 #include <tinycompress/tinycompress.h> 27 28 #include <audio_route/audio_route.h> 29 #include "audio_defs.h" 30 #include "voice.h" 31 32 #define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so" 33 #define OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH "/system/lib/soundfx/libqcompostprocbundle.so" 34 35 /* Flags used to initialize acdb_settings variable that goes to ACDB library */ 36 #define NONE_FLAG 0x00000000 37 #define ANC_FLAG 0x00000001 38 #define DMIC_FLAG 0x00000002 39 #define QMIC_FLAG 0x00000004 40 #define TTY_MODE_OFF 0x00000010 41 #define TTY_MODE_FULL 0x00000020 42 #define TTY_MODE_VCO 0x00000040 43 #define TTY_MODE_HCO 0x00000080 44 #define TTY_MODE_CLEAR 0xFFFFFF0F 45 #define FLUENCE_MODE_CLEAR 0xFFFFFFF0 46 47 #define ACDB_DEV_TYPE_OUT 1 48 #define ACDB_DEV_TYPE_IN 2 49 50 #define MAX_SUPPORTED_CHANNEL_MASKS 2 51 #define DEFAULT_HDMI_OUT_CHANNELS 2 52 53 #define SND_CARD_STATE_OFFLINE 0 54 #define SND_CARD_STATE_ONLINE 1 55 typedef int snd_device_t; 56 57 /* These are the supported use cases by the hardware. 58 * Each usecase is mapped to a specific PCM device. 59 * Refer to pcm_device_table[]. 60 */ 61 enum { 62 USECASE_INVALID = -1, 63 /* Playback usecases */ 64 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER = 0, 65 USECASE_AUDIO_PLAYBACK_LOW_LATENCY, 66 USECASE_AUDIO_PLAYBACK_MULTI_CH, 67 USECASE_AUDIO_PLAYBACK_OFFLOAD, 68 #ifdef MULTIPLE_OFFLOAD_ENABLED 69 USECASE_AUDIO_PLAYBACK_OFFLOAD2, 70 USECASE_AUDIO_PLAYBACK_OFFLOAD3, 71 USECASE_AUDIO_PLAYBACK_OFFLOAD4, 72 USECASE_AUDIO_PLAYBACK_OFFLOAD5, 73 USECASE_AUDIO_PLAYBACK_OFFLOAD6, 74 USECASE_AUDIO_PLAYBACK_OFFLOAD7, 75 USECASE_AUDIO_PLAYBACK_OFFLOAD8, 76 USECASE_AUDIO_PLAYBACK_OFFLOAD9, 77 #endif 78 79 /* FM usecase */ 80 USECASE_AUDIO_PLAYBACK_FM, 81 82 /* HFP Use case*/ 83 USECASE_AUDIO_HFP_SCO, 84 USECASE_AUDIO_HFP_SCO_WB, 85 86 /* Capture usecases */ 87 USECASE_AUDIO_RECORD, 88 USECASE_AUDIO_RECORD_COMPRESS, 89 USECASE_AUDIO_RECORD_LOW_LATENCY, 90 USECASE_AUDIO_RECORD_FM_VIRTUAL, 91 92 /* Voice usecase */ 93 USECASE_VOICE_CALL, 94 95 /* Voice extension usecases */ 96 USECASE_VOICE2_CALL, 97 USECASE_VOLTE_CALL, 98 USECASE_QCHAT_CALL, 99 USECASE_VOWLAN_CALL, 100 USECASE_COMPRESS_VOIP_CALL, 101 102 USECASE_INCALL_REC_UPLINK, 103 USECASE_INCALL_REC_DOWNLINK, 104 USECASE_INCALL_REC_UPLINK_AND_DOWNLINK, 105 USECASE_INCALL_REC_UPLINK_COMPRESS, 106 USECASE_INCALL_REC_DOWNLINK_COMPRESS, 107 USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS, 108 109 USECASE_INCALL_MUSIC_UPLINK, 110 USECASE_INCALL_MUSIC_UPLINK2, 111 112 USECASE_AUDIO_SPKR_CALIB_RX, 113 USECASE_AUDIO_SPKR_CALIB_TX, 114 115 USECASE_AUDIO_PLAYBACK_AFE_PROXY, 116 USECASE_AUDIO_RECORD_AFE_PROXY, 117 118 AUDIO_USECASE_MAX 119 }; 120 121 const char * const use_case_table[AUDIO_USECASE_MAX]; 122 123 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 124 125 /* 126 * tinyAlsa library interprets period size as number of frames 127 * one frame = channel_count * sizeof (pcm sample) 128 * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes 129 * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes 130 * We should take care of returning proper size when AudioFlinger queries for 131 * the buffer size of an input/output stream 132 */ 133 134 enum { 135 OFFLOAD_CMD_EXIT, /* exit compress offload thread loop*/ 136 OFFLOAD_CMD_DRAIN, /* send a full drain request to DSP */ 137 OFFLOAD_CMD_PARTIAL_DRAIN, /* send a partial drain request to DSP */ 138 OFFLOAD_CMD_WAIT_FOR_BUFFER, /* wait for buffer released by DSP */ 139 }; 140 141 enum { 142 OFFLOAD_STATE_IDLE, 143 OFFLOAD_STATE_PLAYING, 144 OFFLOAD_STATE_PAUSED, 145 }; 146 147 struct offload_cmd { 148 struct listnode node; 149 int cmd; 150 int data[]; 151 }; 152 153 struct stream_app_type_cfg { 154 int sample_rate; 155 uint32_t bit_width; 156 int app_type; 157 }; 158 159 struct stream_out { 160 struct audio_stream_out stream; 161 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 162 pthread_cond_t cond; 163 struct pcm_config config; 164 struct compr_config compr_config; 165 struct pcm *pcm; 166 struct compress *compr; 167 int standby; 168 int pcm_device_id; 169 unsigned int sample_rate; 170 audio_channel_mask_t channel_mask; 171 audio_format_t format; 172 audio_devices_t devices; 173 audio_output_flags_t flags; 174 audio_usecase_t usecase; 175 /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */ 176 audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1]; 177 bool muted; 178 uint64_t written; /* total frames written, not cleared when entering standby */ 179 audio_io_handle_t handle; 180 struct stream_app_type_cfg app_type_cfg; 181 182 int non_blocking; 183 int playback_started; 184 int offload_state; 185 pthread_cond_t offload_cond; 186 pthread_t offload_thread; 187 struct listnode offload_cmd_list; 188 bool offload_thread_blocked; 189 190 stream_callback_t offload_callback; 191 void *offload_cookie; 192 struct compr_gapless_mdata gapless_mdata; 193 int send_new_metadata; 194 unsigned int bit_width; 195 196 struct audio_device *dev; 197 }; 198 199 struct stream_in { 200 struct audio_stream_in stream; 201 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 202 struct pcm_config config; 203 struct pcm *pcm; 204 int standby; 205 int source; 206 int pcm_device_id; 207 audio_devices_t device; 208 audio_channel_mask_t channel_mask; 209 audio_usecase_t usecase; 210 bool enable_aec; 211 bool enable_ns; 212 audio_format_t format; 213 audio_io_handle_t capture_handle; 214 bool is_st_session; 215 216 struct audio_device *dev; 217 }; 218 219 typedef enum { 220 PCM_PLAYBACK, 221 PCM_CAPTURE, 222 VOICE_CALL, 223 VOIP_CALL, 224 PCM_HFP_CALL 225 } usecase_type_t; 226 227 union stream_ptr { 228 struct stream_in *in; 229 struct stream_out *out; 230 }; 231 232 struct audio_usecase { 233 struct listnode list; 234 audio_usecase_t id; 235 usecase_type_t type; 236 audio_devices_t devices; 237 snd_device_t out_snd_device; 238 snd_device_t in_snd_device; 239 union stream_ptr stream; 240 }; 241 242 struct sound_card_status { 243 pthread_mutex_t lock; 244 int state; 245 }; 246 247 struct stream_format { 248 struct listnode list; 249 audio_format_t format; 250 }; 251 252 struct stream_sample_rate { 253 struct listnode list; 254 uint32_t sample_rate; 255 }; 256 257 struct streams_output_cfg { 258 struct listnode list; 259 audio_output_flags_t flags; 260 struct listnode format_list; 261 struct listnode sample_rate_list; 262 struct stream_app_type_cfg app_type_cfg; 263 }; 264 265 struct audio_device { 266 struct audio_hw_device device; 267 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 268 struct mixer *mixer; 269 audio_mode_t mode; 270 audio_devices_t out_device; 271 struct stream_in *active_input; 272 struct stream_out *primary_output; 273 struct stream_out *voice_tx_output; 274 struct stream_out *current_call_output; 275 bool bluetooth_nrec; 276 bool screen_off; 277 int *snd_dev_ref_cnt; 278 struct listnode usecase_list; 279 struct listnode streams_output_cfg_list; 280 struct audio_route *audio_route; 281 int acdb_settings; 282 bool speaker_lr_swap; 283 struct voice voice; 284 unsigned int cur_hdmi_channels; 285 unsigned int cur_wfd_channels; 286 bool bt_wb_speech_enabled; 287 288 int snd_card; 289 unsigned int cur_codec_backend_samplerate; 290 unsigned int cur_codec_backend_bit_width; 291 void *platform; 292 unsigned int offload_usecases_state; 293 void *visualizer_lib; 294 int (*visualizer_start_output)(audio_io_handle_t, int); 295 int (*visualizer_stop_output)(audio_io_handle_t, int); 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 struct sound_card_status snd_card_status; 301 }; 302 303 int select_devices(struct audio_device *adev, 304 audio_usecase_t uc_id); 305 int disable_audio_route(struct audio_device *adev, 306 struct audio_usecase *usecase); 307 int disable_snd_device(struct audio_device *adev, 308 snd_device_t snd_device); 309 int enable_snd_device(struct audio_device *adev, 310 snd_device_t snd_device); 311 312 int enable_audio_route(struct audio_device *adev, 313 struct audio_usecase *usecase); 314 315 struct audio_usecase *get_usecase_from_list(struct audio_device *adev, 316 audio_usecase_t uc_id); 317 318 bool is_offload_usecase(audio_usecase_t uc_id); 319 320 int pcm_ioctl(struct pcm *pcm, int request, ...); 321 322 int get_snd_card_state(struct audio_device *adev); 323 audio_usecase_t get_usecase_id_from_usecase_type(struct audio_device *adev, 324 usecase_type_t type); 325 326 #define LITERAL_TO_STRING(x) #x 327 #define CHECK(condition) LOG_ALWAYS_FATAL_IF(!(condition), "%s",\ 328 __FILE__ ":" LITERAL_TO_STRING(__LINE__)\ 329 " ASSERT_FATAL(" #condition ") failed.") 330 331 /* 332 * NOTE: when multiple mutexes have to be acquired, always take the 333 * stream_in or stream_out mutex first, followed by the audio_device mutex. 334 */ 335 336 #endif // QCOM_AUDIO_HW_H 337