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 "audio_hw_hfp"
18 /*#define LOG_NDEBUG 0*/
19 #define LOG_NDDEBUG 0
20 
21 #include <errno.h>
22 #include <math.h>
23 #include <cutils/log.h>
24 
25 #include "audio_hw.h"
26 #include "platform.h"
27 #include "platform_api.h"
28 #include <stdlib.h>
29 #include <cutils/str_parms.h>
30 
31 #define AUDIO_PARAMETER_HFP_ENABLE      "hfp_enable"
32 #define AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE "hfp_set_sampling_rate"
33 #define AUDIO_PARAMETER_KEY_HFP_VOLUME "hfp_volume"
34 
35 static int32_t start_hfp(struct audio_device *adev,
36                                struct str_parms *parms);
37 
38 static int32_t stop_hfp(struct audio_device *adev);
39 
40 struct hfp_module {
41     struct pcm *hfp_sco_rx;
42     struct pcm *hfp_sco_tx;
43     struct pcm *hfp_pcm_rx;
44     struct pcm *hfp_pcm_tx;
45     float  hfp_volume;
46     bool   is_hfp_running;
47     audio_usecase_t ucid;
48 };
49 
50 static struct hfp_module hfpmod = {
51     .hfp_sco_rx = NULL,
52     .hfp_sco_tx = NULL,
53     .hfp_pcm_rx = NULL,
54     .hfp_pcm_tx = NULL,
55     .hfp_volume = 0,
56     .is_hfp_running = 0,
57     .ucid = USECASE_AUDIO_HFP_SCO,
58 };
59 static struct pcm_config pcm_config_hfp = {
60     .channels = 1,
61     .rate = 8000,
62     .period_size = 240,
63     .period_count = 2,
64     .format = PCM_FORMAT_S16_LE,
65     .start_threshold = 0,
66     .stop_threshold = INT_MAX,
67     .avail_min = 0,
68 };
69 
hfp_set_volume(struct audio_device * adev,float value)70 static int32_t hfp_set_volume(struct audio_device *adev, float value)
71 {
72     int32_t vol, ret = 0;
73     struct mixer_ctl *ctl;
74 #ifdef EXTERNAL_BT_SUPPORTED
75     const char *mixer_ctl_name = "PRI AUXPCM LOOPBACK Volume";
76 #else
77     const char *mixer_ctl_name = "Internal HFP RX Volume";
78 #endif
79 
80     ALOGV("%s: entry", __func__);
81     ALOGD("%s: (%f)\n", __func__, value);
82 
83     if (value < 0.0) {
84         ALOGW("%s: (%f) Under 0.0, assuming 0.0\n", __func__, value);
85         value = 0.0;
86     } else {
87         value = ((value > 15.000000) ? 1.0 : (value / 15));
88         ALOGW("%s: Volume brought with in range (%f)\n", __func__, value);
89     }
90     vol  = lrint((value * 0x2000) + 0.5);
91     hfpmod.hfp_volume = value;
92 
93     if (!hfpmod.is_hfp_running) {
94         ALOGV("%s: HFP not active, ignoring set_hfp_volume call", __func__);
95         return -EIO;
96     }
97 
98     ALOGD("%s: Setting HFP volume to %d \n", __func__, vol);
99     ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
100     if (!ctl) {
101         ALOGE("%s: Could not get ctl for mixer cmd - %s",
102               __func__, mixer_ctl_name);
103         return -EINVAL;
104     }
105     if(mixer_ctl_set_value(ctl, 0, vol) < 0) {
106         ALOGE("%s: Couldn't set HFP Volume: [%d]", __func__, vol);
107         return -EINVAL;
108     }
109 
110     ALOGV("%s: exit", __func__);
111     return ret;
112 }
113 
start_hfp(struct audio_device * adev,struct str_parms * parms __unused)114 static int32_t start_hfp(struct audio_device *adev,
115                          struct str_parms *parms __unused)
116 {
117     int32_t i, ret = 0;
118     struct audio_usecase *uc_info;
119     int32_t pcm_dev_rx_id, pcm_dev_tx_id, pcm_dev_asm_rx_id, pcm_dev_asm_tx_id;
120 
121     ALOGD("%s: enter", __func__);
122     adev->enable_hfp = true;
123     platform_set_mic_mute(adev->platform, false);
124 
125     uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
126     uc_info->id = hfpmod.ucid;
127     uc_info->type = PCM_HFP_CALL;
128     uc_info->stream.out = adev->primary_output;
129     uc_info->devices = adev->primary_output->devices;
130     uc_info->in_snd_device = SND_DEVICE_NONE;
131     uc_info->out_snd_device = SND_DEVICE_NONE;
132 
133     list_add_tail(&adev->usecase_list, &uc_info->list);
134 
135     select_devices(adev, hfpmod.ucid);
136 
137     pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
138     pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);
139     pcm_dev_asm_rx_id = HFP_ASM_RX_TX;
140     pcm_dev_asm_tx_id = HFP_ASM_RX_TX;
141     if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0 ||
142         pcm_dev_asm_rx_id < 0 || pcm_dev_asm_tx_id < 0 ) {
143         ALOGE("%s: Invalid PCM devices (rx: %d tx: %d asm: rx tx %d) for the usecase(%d)",
144               __func__, pcm_dev_rx_id, pcm_dev_tx_id, pcm_dev_asm_rx_id, uc_info->id);
145         ret = -EIO;
146         goto exit;
147     }
148 
149     ALOGV("%s: HFP PCM devices (hfp rx tx: %d pcm rx tx: %d) for the usecase(%d)",
150               __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
151 
152     ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
153           __func__, adev->snd_card, pcm_dev_rx_id);
154     hfpmod.hfp_sco_rx = pcm_open(adev->snd_card,
155                                   pcm_dev_asm_rx_id,
156                                   PCM_OUT, &pcm_config_hfp);
157     if (hfpmod.hfp_sco_rx && !pcm_is_ready(hfpmod.hfp_sco_rx)) {
158         ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_sco_rx));
159         ret = -EIO;
160         goto exit;
161     }
162     ALOGD("%s: Opening PCM capture device card_id(%d) device_id(%d)",
163           __func__, adev->snd_card, pcm_dev_tx_id);
164     hfpmod.hfp_pcm_rx = pcm_open(adev->snd_card,
165                                    pcm_dev_rx_id,
166                                    PCM_OUT, &pcm_config_hfp);
167     if (hfpmod.hfp_pcm_rx && !pcm_is_ready(hfpmod.hfp_pcm_rx)) {
168         ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_pcm_rx));
169         ret = -EIO;
170         goto exit;
171     }
172     hfpmod.hfp_sco_tx = pcm_open(adev->snd_card,
173                                   pcm_dev_asm_tx_id,
174                                   PCM_IN, &pcm_config_hfp);
175     if (hfpmod.hfp_sco_tx && !pcm_is_ready(hfpmod.hfp_sco_tx)) {
176         ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_sco_tx));
177         ret = -EIO;
178         goto exit;
179     }
180     ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
181           __func__, adev->snd_card, pcm_dev_tx_id);
182     hfpmod.hfp_pcm_tx = pcm_open(adev->snd_card,
183                                    pcm_dev_tx_id,
184                                    PCM_IN, &pcm_config_hfp);
185     if (hfpmod.hfp_pcm_tx && !pcm_is_ready(hfpmod.hfp_pcm_tx)) {
186         ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_pcm_tx));
187         ret = -EIO;
188         goto exit;
189     }
190     pcm_start(hfpmod.hfp_sco_rx);
191     pcm_start(hfpmod.hfp_sco_tx);
192     pcm_start(hfpmod.hfp_pcm_rx);
193     pcm_start(hfpmod.hfp_pcm_tx);
194 
195     hfpmod.is_hfp_running = true;
196     hfp_set_volume(adev, hfpmod.hfp_volume);
197 
198     ALOGD("%s: exit: status(%d)", __func__, ret);
199     return 0;
200 
201 exit:
202     stop_hfp(adev);
203     ALOGE("%s: Problem in HFP start: status(%d)", __func__, ret);
204     return ret;
205 }
206 
stop_hfp(struct audio_device * adev)207 static int32_t stop_hfp(struct audio_device *adev)
208 {
209     int32_t i, ret = 0;
210     struct audio_usecase *uc_info;
211 
212     ALOGD("%s: enter", __func__);
213     hfpmod.is_hfp_running = false;
214 
215     /* 1. Close the PCM devices */
216     if (hfpmod.hfp_sco_rx) {
217         pcm_close(hfpmod.hfp_sco_rx);
218         hfpmod.hfp_sco_rx = NULL;
219     }
220     if (hfpmod.hfp_sco_tx) {
221         pcm_close(hfpmod.hfp_sco_tx);
222         hfpmod.hfp_sco_tx = NULL;
223     }
224     if (hfpmod.hfp_pcm_rx) {
225         pcm_close(hfpmod.hfp_pcm_rx);
226         hfpmod.hfp_pcm_rx = NULL;
227     }
228     if (hfpmod.hfp_pcm_tx) {
229         pcm_close(hfpmod.hfp_pcm_tx);
230         hfpmod.hfp_pcm_tx = NULL;
231     }
232 
233     uc_info = get_usecase_from_list(adev, hfpmod.ucid);
234     if (uc_info == NULL) {
235         ALOGE("%s: Could not find the usecase (%d) in the list",
236               __func__, hfpmod.ucid);
237         return -EINVAL;
238     }
239 
240     /* 2. Get and set stream specific mixer controls */
241     disable_audio_route(adev, uc_info);
242 
243     /* 3. Disable the rx and tx devices */
244     disable_snd_device(adev, uc_info->out_snd_device);
245     disable_snd_device(adev, uc_info->in_snd_device);
246 
247     /* Disable the echo reference for HFP Tx */
248     platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE);
249 
250     /* Set the unmute Tx mixer control */
251     if (voice_get_mic_mute(adev)) {
252         platform_set_mic_mute(adev->platform, false);
253         ALOGD("%s: unMute HFP Tx", __func__);
254     }
255     adev->enable_hfp = false;
256 
257     list_remove(&uc_info->list);
258     free(uc_info);
259 
260     ALOGD("%s: exit: status(%d)", __func__, ret);
261     return ret;
262 }
263 
audio_extn_hfp_is_active(struct audio_device * adev)264 bool audio_extn_hfp_is_active(struct audio_device *adev)
265 {
266     struct audio_usecase *hfp_usecase = NULL;
267     hfp_usecase = get_usecase_from_list(adev, hfpmod.ucid);
268 
269     if (hfp_usecase != NULL)
270         return true;
271     else
272         return false;
273 }
274 
audio_extn_hfp_get_usecase()275 audio_usecase_t audio_extn_hfp_get_usecase()
276 {
277     return hfpmod.ucid;
278 }
279 
audio_extn_hfp_set_parameters(struct audio_device * adev,struct str_parms * parms)280 void audio_extn_hfp_set_parameters(struct audio_device *adev, struct str_parms *parms)
281 {
282     int ret;
283     int rate;
284     int val;
285     float vol;
286     char value[32]={0};
287 
288     ret = str_parms_get_str(parms, AUDIO_PARAMETER_HFP_ENABLE, value,
289                             sizeof(value));
290     if (ret >= 0) {
291            if (!strncmp(value,"true",sizeof(value)))
292                ret = start_hfp(adev,parms);
293            else
294                stop_hfp(adev);
295     }
296     memset(value, 0, sizeof(value));
297     ret = str_parms_get_str(parms,AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE, value,
298                             sizeof(value));
299     if (ret >= 0) {
300            rate = atoi(value);
301            if (rate == 8000){
302                hfpmod.ucid = USECASE_AUDIO_HFP_SCO;
303                pcm_config_hfp.rate = rate;
304            } else if (rate == 16000){
305                hfpmod.ucid = USECASE_AUDIO_HFP_SCO_WB;
306                pcm_config_hfp.rate = rate;
307            } else
308                ALOGE("Unsupported rate..");
309     }
310 
311     if (hfpmod.is_hfp_running) {
312         memset(value, 0, sizeof(value));
313         ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
314                                 value, sizeof(value));
315         if (ret >= 0) {
316             val = atoi(value);
317             if (val > 0)
318                 select_devices(adev, hfpmod.ucid);
319         }
320     }
321 
322     memset(value, 0, sizeof(value));
323     ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_VOLUME,
324                             value, sizeof(value));
325     if (ret >= 0) {
326         if (sscanf(value, "%f", &vol) != 1){
327             ALOGE("%s: error in retrieving hfp volume", __func__);
328             ret = -EIO;
329             goto exit;
330         }
331         ALOGD("%s: set_hfp_volume usecase, Vol: [%f]", __func__, vol);
332         hfp_set_volume(adev, vol);
333     }
334 exit:
335     ALOGV("%s Exit",__func__);
336 }
337