1 /*
2  * Copyright (C) 2014 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 #define LOG_TAG "voice"
18 /*#define LOG_NDEBUG 0*/
19 #define LOG_NDDEBUG 0
20 
21 #include <stdlib.h>
22 #include <errno.h>
23 #include <math.h>
24 #include <cutils/log.h>
25 #include <cutils/str_parms.h>
26 
27 #include "audio_hw.h"
28 #include "voice.h"
29 #include "voice_extn/voice_extn.h"
30 #include "platform.h"
31 #include "platform_api.h"
32 
33 struct pcm_config pcm_config_voice_call = {
34     .channels = 1,
35     .rate = 8000,
36     .period_size = 160,
37     .period_count = 2,
38     .format = PCM_FORMAT_S16_LE,
39 };
40 
voice_get_session_from_use_case(struct audio_device * adev,audio_usecase_t usecase_id)41 static struct voice_session *voice_get_session_from_use_case(struct audio_device *adev,
42                               audio_usecase_t usecase_id)
43 {
44     struct voice_session *session = NULL;
45     int ret = 0;
46 
47     ret = voice_extn_get_session_from_use_case(adev, usecase_id, &session);
48     if (ret == -ENOSYS) {
49         session = &adev->voice.session[VOICE_SESS_IDX];
50     }
51 
52     return session;
53 }
54 
voice_is_sidetone_device(snd_device_t out_device,char * mixer_path)55 static bool voice_is_sidetone_device(snd_device_t out_device,
56             char *mixer_path)
57 {
58     bool is_sidetone_dev = true;
59 
60     switch (out_device) {
61     case SND_DEVICE_OUT_VOICE_HAC_HANDSET:
62         strlcpy(mixer_path, "sidetone-hac-handset", MIXER_PATH_MAX_LENGTH);
63         break;
64     case SND_DEVICE_OUT_VOICE_HANDSET:
65         strlcpy(mixer_path, "sidetone-handset", MIXER_PATH_MAX_LENGTH);
66         break;
67     case SND_DEVICE_OUT_VOICE_HEADPHONES:
68         strlcpy(mixer_path, "sidetone-headphones", MIXER_PATH_MAX_LENGTH);
69         break;
70     default:
71         is_sidetone_dev = false;
72         break;
73     }
74 
75     return is_sidetone_dev;
76 }
77 
voice_set_sidetone(struct audio_device * adev,snd_device_t out_snd_device,bool enable)78 void voice_set_sidetone(struct audio_device *adev,
79         snd_device_t out_snd_device, bool enable)
80 {
81     char mixer_path[MIXER_PATH_MAX_LENGTH];
82     bool is_sidetone_dev;
83 
84     ALOGD("%s: %s, out_snd_device: %d\n",
85           __func__, (enable ? "enable" : "disable"),
86           out_snd_device);
87 
88     is_sidetone_dev = voice_is_sidetone_device(out_snd_device, mixer_path);
89 
90     if (!is_sidetone_dev) {
91         ALOGD("%s: device %d does not support sidetone\n",
92               __func__, out_snd_device);
93         return;
94     }
95 
96     ALOGD("%s: sidetone out device = %s\n",
97           __func__, mixer_path);
98 
99     if (enable)
100         audio_route_apply_and_update_path(adev->audio_route, mixer_path);
101     else
102         audio_route_reset_and_update_path(adev->audio_route, mixer_path);
103 
104     return;
105 }
106 
voice_stop_usecase(struct audio_device * adev,audio_usecase_t usecase_id)107 int voice_stop_usecase(struct audio_device *adev, audio_usecase_t usecase_id)
108 {
109     int i, ret = 0;
110     struct audio_usecase *uc_info;
111     struct voice_session *session = NULL;
112 
113     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);
114 
115     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
116 
117     uc_info = get_usecase_from_list(adev, usecase_id);
118     if (uc_info == NULL) {
119         ALOGE("%s: Could not find the usecase (%d) in the list",
120               __func__, usecase_id);
121         return -EINVAL;
122     }
123 
124     session->state.current = CALL_INACTIVE;
125 
126     /* Disable sidetone only when no calls are active */
127     if (!voice_is_call_state_active(adev))
128         voice_set_sidetone(adev, uc_info->out_snd_device, false);
129 
130     ret = platform_stop_voice_call(adev->platform, session->vsid);
131 
132     /* 1. Close the PCM devices */
133     if (session->pcm_rx) {
134         pcm_close(session->pcm_rx);
135         session->pcm_rx = NULL;
136     }
137     if (session->pcm_tx) {
138         pcm_close(session->pcm_tx);
139         session->pcm_tx = NULL;
140     }
141 
142     /* 2. Get and set stream specific mixer controls */
143     disable_audio_route(adev, uc_info);
144 
145     /* 3. Disable the rx and tx devices */
146     disable_snd_device(adev, uc_info->out_snd_device);
147     disable_snd_device(adev, uc_info->in_snd_device);
148 
149     list_remove(&uc_info->list);
150     free(uc_info);
151 
152     ALOGD("%s: exit: status(%d)", __func__, ret);
153     return ret;
154 }
155 
voice_start_usecase(struct audio_device * adev,audio_usecase_t usecase_id)156 int voice_start_usecase(struct audio_device *adev, audio_usecase_t usecase_id)
157 {
158     int i, ret = 0;
159     struct audio_usecase *uc_info;
160     int pcm_dev_rx_id, pcm_dev_tx_id;
161     struct voice_session *session = NULL;
162     struct pcm_config voice_config = pcm_config_voice_call;
163 
164     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);
165 
166     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
167     uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
168     uc_info->id = usecase_id;
169     uc_info->type = VOICE_CALL;
170     uc_info->stream.out = adev->current_call_output ;
171     uc_info->devices = adev->current_call_output ->devices;
172     uc_info->in_snd_device = SND_DEVICE_NONE;
173     uc_info->out_snd_device = SND_DEVICE_NONE;
174 
175     list_add_tail(&adev->usecase_list, &uc_info->list);
176 
177     select_devices(adev, usecase_id);
178 
179     pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
180     pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);
181 
182     if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0) {
183         ALOGE("%s: Invalid PCM devices (rx: %d tx: %d) for the usecase(%d)",
184               __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
185         ret = -EIO;
186         goto error_start_voice;
187     }
188 
189     ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
190           __func__, adev->snd_card, pcm_dev_tx_id);
191     session->pcm_tx = pcm_open(adev->snd_card,
192                                pcm_dev_tx_id,
193                                PCM_IN, &voice_config);
194     if (session->pcm_tx && !pcm_is_ready(session->pcm_tx)) {
195         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_tx));
196         ret = -EIO;
197         goto error_start_voice;
198     }
199 
200     ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
201           __func__, adev->snd_card, pcm_dev_rx_id);
202     session->pcm_rx = pcm_open(adev->snd_card,
203                                pcm_dev_rx_id,
204                                PCM_OUT, &voice_config);
205     if (session->pcm_rx && !pcm_is_ready(session->pcm_rx)) {
206         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_rx));
207         ret = -EIO;
208         goto error_start_voice;
209     }
210 
211     pcm_start(session->pcm_tx);
212     pcm_start(session->pcm_rx);
213 
214     /* Enable sidetone only when no calls are already active */
215     if (!voice_is_call_state_active(adev))
216         voice_set_sidetone(adev, uc_info->out_snd_device, true);
217 
218     voice_set_volume(adev, adev->voice.volume);
219 
220     ret = platform_start_voice_call(adev->platform, session->vsid);
221     if (ret < 0) {
222         ALOGE("%s: platform_start_voice_call error %d\n", __func__, ret);
223         goto error_start_voice;
224     }
225 
226     session->state.current = CALL_ACTIVE;
227     goto done;
228 
229 error_start_voice:
230     voice_stop_usecase(adev, usecase_id);
231 
232 done:
233     ALOGD("%s: exit: status(%d)", __func__, ret);
234     return ret;
235 }
236 
voice_is_call_state_active(struct audio_device * adev)237 bool voice_is_call_state_active(struct audio_device *adev)
238 {
239     bool call_state = false;
240     int ret = 0;
241 
242     ret = voice_extn_is_call_state_active(adev, &call_state);
243     if (ret == -ENOSYS) {
244         call_state = (adev->voice.session[VOICE_SESS_IDX].state.current == CALL_ACTIVE) ? true : false;
245     }
246 
247     return call_state;
248 }
249 
voice_is_in_call(struct audio_device * adev)250 bool voice_is_in_call(struct audio_device *adev)
251 {
252     return adev->voice.in_call;
253 }
254 
voice_is_in_call_rec_stream(struct stream_in * in)255 bool voice_is_in_call_rec_stream(struct stream_in *in)
256 {
257     bool in_call_rec = false;
258     int ret = 0;
259 
260     ret = voice_extn_is_in_call_rec_stream(in, &in_call_rec);
261     if (ret == -ENOSYS) {
262         in_call_rec = false;
263     }
264 
265     return in_call_rec;
266 }
267 
voice_get_active_session_id(struct audio_device * adev)268 uint32_t voice_get_active_session_id(struct audio_device *adev)
269 {
270     int ret = 0;
271     uint32_t session_id;
272 
273     ret = voice_extn_get_active_session_id(adev, &session_id);
274     if (ret == -ENOSYS) {
275         session_id = VOICE_VSID;
276     }
277     return session_id;
278 }
279 
voice_check_and_set_incall_rec_usecase(struct audio_device * adev,struct stream_in * in)280 int voice_check_and_set_incall_rec_usecase(struct audio_device *adev,
281                                            struct stream_in *in)
282 {
283     int ret = 0;
284     uint32_t session_id;
285     int usecase_id;
286     int rec_mode = INCALL_REC_NONE;
287 
288     if (voice_is_call_state_active(adev)) {
289         switch (in->source) {
290         case AUDIO_SOURCE_VOICE_UPLINK:
291             in->usecase = USECASE_INCALL_REC_UPLINK;
292             rec_mode = INCALL_REC_UPLINK;
293             break;
294         case AUDIO_SOURCE_VOICE_DOWNLINK:
295             in->usecase = USECASE_INCALL_REC_DOWNLINK;
296             rec_mode = INCALL_REC_DOWNLINK;
297             break;
298         case AUDIO_SOURCE_VOICE_CALL:
299             in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK;
300             rec_mode = INCALL_REC_UPLINK_AND_DOWNLINK;
301             break;
302         default:
303             ALOGV("%s: Source type %d doesnt match incall recording criteria",
304                   __func__, in->source);
305             return ret;
306         }
307 
308         session_id = voice_get_active_session_id(adev);
309         ret = platform_set_incall_recording_session_id(adev->platform,
310                                                        session_id, rec_mode);
311         ALOGV("%s: Update usecase to %d",__func__, in->usecase);
312     } else {
313         ALOGV("%s: voice call not active", __func__);
314     }
315 
316     return ret;
317 }
318 
voice_check_and_stop_incall_rec_usecase(struct audio_device * adev,struct stream_in * in)319 int voice_check_and_stop_incall_rec_usecase(struct audio_device *adev,
320                                             struct stream_in *in)
321 {
322     int ret = 0;
323 
324     if (in->source == AUDIO_SOURCE_VOICE_UPLINK ||
325         in->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
326         in->source == AUDIO_SOURCE_VOICE_CALL) {
327         ret = platform_stop_incall_recording_usecase(adev->platform);
328         ALOGV("%s: Stop In-call recording", __func__);
329     }
330 
331     return ret;
332 }
333 
voice_check_and_set_incall_music_usecase(struct audio_device * adev,struct stream_out * out)334 int voice_check_and_set_incall_music_usecase(struct audio_device *adev,
335                                              struct stream_out *out)
336 {
337     int ret = 0;
338 
339     ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
340     if (ret == -ENOSYS) {
341         /* Incall music delivery is used only for LCH call state */
342         ret = -EINVAL;
343     }
344 
345     return ret;
346 }
347 
voice_set_mic_mute(struct audio_device * adev,bool state)348 int voice_set_mic_mute(struct audio_device *adev, bool state)
349 {
350     int err = 0;
351 
352     adev->voice.mic_mute = state;
353     if (adev->mode == AUDIO_MODE_IN_CALL ||
354         adev->mode == AUDIO_MODE_IN_COMMUNICATION)
355         err = platform_set_mic_mute(adev->platform, state);
356 
357     return err;
358 }
359 
voice_get_mic_mute(struct audio_device * adev)360 bool voice_get_mic_mute(struct audio_device *adev)
361 {
362     return adev->voice.mic_mute;
363 }
364 
voice_set_volume(struct audio_device * adev,float volume)365 int voice_set_volume(struct audio_device *adev, float volume)
366 {
367     int vol, err = 0;
368 
369     adev->voice.volume = volume;
370     if (adev->mode == AUDIO_MODE_IN_CALL) {
371         if (volume < 0.0) {
372             volume = 0.0;
373         } else if (volume > 1.0) {
374             volume = 1.0;
375         }
376 
377         vol = lrint(volume * 100.0);
378 
379         // Voice volume levels from android are mapped to driver volume levels as follows.
380         // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
381         // So adjust the volume to get the correct volume index in driver
382         vol = 100 - vol;
383 
384         err = platform_set_voice_volume(adev->platform, vol);
385     }
386 
387     return err;
388 }
389 
voice_start_call(struct audio_device * adev)390 int voice_start_call(struct audio_device *adev)
391 {
392     int ret = 0;
393 
394     adev->voice.in_call = true;
395 
396     voice_set_mic_mute(adev, adev->voice.mic_mute);
397 
398     ret = voice_extn_start_call(adev);
399     if (ret == -ENOSYS) {
400         ret = voice_start_usecase(adev, USECASE_VOICE_CALL);
401     }
402 
403     return ret;
404 }
405 
voice_stop_call(struct audio_device * adev)406 int voice_stop_call(struct audio_device *adev)
407 {
408     int ret = 0;
409 
410     adev->voice.in_call = false;
411     ret = voice_extn_stop_call(adev);
412     if (ret == -ENOSYS) {
413         ret = voice_stop_usecase(adev, USECASE_VOICE_CALL);
414     }
415 
416     return ret;
417 }
418 
voice_get_parameters(struct audio_device * adev,struct str_parms * query,struct str_parms * reply)419 void voice_get_parameters(struct audio_device *adev,
420                           struct str_parms *query,
421                           struct str_parms *reply)
422 {
423     voice_extn_get_parameters(adev, query, reply);
424 }
425 
voice_set_parameters(struct audio_device * adev,struct str_parms * parms)426 int voice_set_parameters(struct audio_device *adev, struct str_parms *parms)
427 {
428     char *str;
429     char value[32];
430     int val;
431     int ret = 0, err;
432     char *kv_pairs = str_parms_to_str(parms);
433 
434     ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
435 
436     ret = voice_extn_set_parameters(adev, parms);
437     if (ret != 0) {
438         if (ret == -ENOSYS) {
439             ret = 0; /* ignore error */
440         } else {
441             goto done;
442         }
443     }
444 
445     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
446     if (err >= 0) {
447         int tty_mode;
448         str_parms_del(parms, AUDIO_PARAMETER_KEY_TTY_MODE);
449         if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
450             tty_mode = TTY_MODE_OFF;
451         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
452             tty_mode = TTY_MODE_VCO;
453         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
454             tty_mode = TTY_MODE_HCO;
455         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
456             tty_mode = TTY_MODE_FULL;
457         else {
458             ret = -EINVAL;
459             goto done;
460         }
461 
462         if (tty_mode != adev->voice.tty_mode) {
463             adev->voice.tty_mode = tty_mode;
464             adev->acdb_settings = (adev->acdb_settings & TTY_MODE_CLEAR) | tty_mode;
465             if (voice_is_call_state_active(adev))
466                voice_update_devices_for_all_voice_usecases(adev);
467         }
468     }
469 
470     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HAC,
471                             value, sizeof(value));
472     if (err >= 0) {
473         bool hac = false;
474         str_parms_del(parms, AUDIO_PARAMETER_KEY_HAC);
475         if (strcmp(value, AUDIO_PARAMETER_VALUE_HAC_ON) == 0)
476             hac = true;
477 
478         if (hac != adev->voice.hac) {
479             adev->voice.hac = hac;
480             if (voice_is_in_call(adev))
481                 voice_update_devices_for_all_voice_usecases(adev);
482         }
483      }
484 
485     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC,
486                             value, sizeof(value));
487     if (err >= 0) {
488         str_parms_del(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC);
489         if (strcmp(value, AUDIO_PARAMETER_VALUE_TRUE) == 0)
490             platform_start_incall_music_usecase(adev->platform);
491         else
492             platform_stop_incall_music_usecase(adev->platform);
493      }
494 
495 done:
496     ALOGV("%s: exit with code(%d)", __func__, ret);
497     free(kv_pairs);
498     return ret;
499 }
500 
voice_init(struct audio_device * adev)501 void voice_init(struct audio_device *adev)
502 {
503     int i = 0;
504 
505     memset(&adev->voice, 0, sizeof(adev->voice));
506     adev->voice.tty_mode = TTY_MODE_OFF;
507     adev->voice.hac = false;
508     adev->voice.volume = 1.0f;
509     adev->voice.mic_mute = false;
510     adev->voice.in_call = false;
511     for (i = 0; i < MAX_VOICE_SESSIONS; i++) {
512         adev->voice.session[i].pcm_rx = NULL;
513         adev->voice.session[i].pcm_tx = NULL;
514         adev->voice.session[i].state.current = CALL_INACTIVE;
515         adev->voice.session[i].state.new = CALL_INACTIVE;
516         adev->voice.session[i].vsid = VOICE_VSID;
517     }
518 
519     voice_extn_init(adev);
520 }
521 
voice_update_devices_for_all_voice_usecases(struct audio_device * adev)522 void voice_update_devices_for_all_voice_usecases(struct audio_device *adev)
523 {
524     struct listnode *node;
525     struct audio_usecase *usecase;
526 
527     list_for_each(node, &adev->usecase_list) {
528         usecase = node_to_item(node, struct audio_usecase, list);
529         if (usecase->type == VOICE_CALL) {
530             ALOGV("%s: updating device for usecase:%s", __func__,
531                   use_case_table[usecase->id]);
532             usecase->stream.out = adev->current_call_output;
533             select_devices(adev, usecase->id);
534         }
535     }
536 }
537 
538 
539