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 const char *mixer_ctl_name = "Internal HFP RX Volume";
75
76 ALOGV("%s: entry", __func__);
77 ALOGD("%s: (%f)\n", __func__, value);
78
79 if (value < 0.0) {
80 ALOGW("%s: (%f) Under 0.0, assuming 0.0\n", __func__, value);
81 value = 0.0;
82 } else {
83 value = ((value > 15.000000) ? 1.0 : (value / 15));
84 ALOGW("%s: Volume brought with in range (%f)\n", __func__, value);
85 }
86 vol = lrint((value * 0x2000) + 0.5);
87 hfpmod.hfp_volume = value;
88
89 if (!hfpmod.is_hfp_running) {
90 ALOGV("%s: HFP not active, ignoring set_hfp_volume call", __func__);
91 return -EIO;
92 }
93
94 ALOGD("%s: Setting HFP volume to %d \n", __func__, vol);
95 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
96 if (!ctl) {
97 ALOGE("%s: Could not get ctl for mixer cmd - %s",
98 __func__, mixer_ctl_name);
99 return -EINVAL;
100 }
101 if(mixer_ctl_set_value(ctl, 0, vol) < 0) {
102 ALOGE("%s: Couldn't set HFP Volume: [%d]", __func__, vol);
103 return -EINVAL;
104 }
105
106 ALOGV("%s: exit", __func__);
107 return ret;
108 }
109
start_hfp(struct audio_device * adev,struct str_parms * parms __unused)110 static int32_t start_hfp(struct audio_device *adev,
111 struct str_parms *parms __unused)
112 {
113 int32_t i, ret = 0;
114 struct audio_usecase *uc_info;
115 int32_t pcm_dev_rx_id, pcm_dev_tx_id, pcm_dev_asm_rx_id, pcm_dev_asm_tx_id;
116
117 ALOGD("%s: enter", __func__);
118
119 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
120 uc_info->id = hfpmod.ucid;
121 uc_info->type = PCM_HFP_CALL;
122 uc_info->stream.out = adev->primary_output;
123 uc_info->devices = adev->primary_output->devices;
124 uc_info->in_snd_device = SND_DEVICE_NONE;
125 uc_info->out_snd_device = SND_DEVICE_NONE;
126
127 list_add_tail(&adev->usecase_list, &uc_info->list);
128
129 select_devices(adev, hfpmod.ucid);
130
131 pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
132 pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);
133 pcm_dev_asm_rx_id = HFP_ASM_RX_TX;
134 pcm_dev_asm_tx_id = HFP_ASM_RX_TX;
135 if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0 ||
136 pcm_dev_asm_rx_id < 0 || pcm_dev_asm_tx_id < 0 ) {
137 ALOGE("%s: Invalid PCM devices (rx: %d tx: %d asm: rx tx %d) for the usecase(%d)",
138 __func__, pcm_dev_rx_id, pcm_dev_tx_id, pcm_dev_asm_rx_id, uc_info->id);
139 ret = -EIO;
140 goto exit;
141 }
142
143 ALOGV("%s: HFP PCM devices (hfp rx tx: %d pcm rx tx: %d) for the usecase(%d)",
144 __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
145
146 ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
147 __func__, adev->snd_card, pcm_dev_rx_id);
148 hfpmod.hfp_sco_rx = pcm_open(adev->snd_card,
149 pcm_dev_asm_rx_id,
150 PCM_OUT, &pcm_config_hfp);
151 if (hfpmod.hfp_sco_rx && !pcm_is_ready(hfpmod.hfp_sco_rx)) {
152 ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_sco_rx));
153 ret = -EIO;
154 goto exit;
155 }
156 ALOGD("%s: Opening PCM capture device card_id(%d) device_id(%d)",
157 __func__, adev->snd_card, pcm_dev_tx_id);
158 hfpmod.hfp_pcm_rx = pcm_open(adev->snd_card,
159 pcm_dev_rx_id,
160 PCM_OUT, &pcm_config_hfp);
161 if (hfpmod.hfp_pcm_rx && !pcm_is_ready(hfpmod.hfp_pcm_rx)) {
162 ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_pcm_rx));
163 ret = -EIO;
164 goto exit;
165 }
166 hfpmod.hfp_sco_tx = pcm_open(adev->snd_card,
167 pcm_dev_asm_tx_id,
168 PCM_IN, &pcm_config_hfp);
169 if (hfpmod.hfp_sco_tx && !pcm_is_ready(hfpmod.hfp_sco_tx)) {
170 ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_sco_tx));
171 ret = -EIO;
172 goto exit;
173 }
174 ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
175 __func__, adev->snd_card, pcm_dev_tx_id);
176 hfpmod.hfp_pcm_tx = pcm_open(adev->snd_card,
177 pcm_dev_tx_id,
178 PCM_IN, &pcm_config_hfp);
179 if (hfpmod.hfp_pcm_tx && !pcm_is_ready(hfpmod.hfp_pcm_tx)) {
180 ALOGE("%s: %s", __func__, pcm_get_error(hfpmod.hfp_pcm_tx));
181 ret = -EIO;
182 goto exit;
183 }
184 pcm_start(hfpmod.hfp_sco_rx);
185 pcm_start(hfpmod.hfp_sco_tx);
186 pcm_start(hfpmod.hfp_pcm_rx);
187 pcm_start(hfpmod.hfp_pcm_tx);
188
189 hfpmod.is_hfp_running = true;
190 hfp_set_volume(adev, hfpmod.hfp_volume);
191
192 ALOGD("%s: exit: status(%d)", __func__, ret);
193 return 0;
194
195 exit:
196 stop_hfp(adev);
197 ALOGE("%s: Problem in HFP start: status(%d)", __func__, ret);
198 return ret;
199 }
200
stop_hfp(struct audio_device * adev)201 static int32_t stop_hfp(struct audio_device *adev)
202 {
203 int32_t i, ret = 0;
204 struct audio_usecase *uc_info;
205
206 ALOGD("%s: enter", __func__);
207 hfpmod.is_hfp_running = false;
208
209 /* 1. Close the PCM devices */
210 if (hfpmod.hfp_sco_rx) {
211 pcm_close(hfpmod.hfp_sco_rx);
212 hfpmod.hfp_sco_rx = NULL;
213 }
214 if (hfpmod.hfp_sco_tx) {
215 pcm_close(hfpmod.hfp_sco_tx);
216 hfpmod.hfp_sco_tx = NULL;
217 }
218 if (hfpmod.hfp_pcm_rx) {
219 pcm_close(hfpmod.hfp_pcm_rx);
220 hfpmod.hfp_pcm_rx = NULL;
221 }
222 if (hfpmod.hfp_pcm_tx) {
223 pcm_close(hfpmod.hfp_pcm_tx);
224 hfpmod.hfp_pcm_tx = NULL;
225 }
226
227 uc_info = get_usecase_from_list(adev, hfpmod.ucid);
228 if (uc_info == NULL) {
229 ALOGE("%s: Could not find the usecase (%d) in the list",
230 __func__, hfpmod.ucid);
231 return -EINVAL;
232 }
233
234 /* 2. Get and set stream specific mixer controls */
235 disable_audio_route(adev, uc_info);
236
237 /* 3. Disable the rx and tx devices */
238 disable_snd_device(adev, uc_info->out_snd_device);
239 disable_snd_device(adev, uc_info->in_snd_device);
240
241 list_remove(&uc_info->list);
242 free(uc_info);
243
244 ALOGD("%s: exit: status(%d)", __func__, ret);
245 return ret;
246 }
247
audio_extn_hfp_is_active(struct audio_device * adev)248 bool audio_extn_hfp_is_active(struct audio_device *adev)
249 {
250 struct audio_usecase *hfp_usecase = NULL;
251 hfp_usecase = get_usecase_from_list(adev, hfpmod.ucid);
252
253 if (hfp_usecase != NULL)
254 return true;
255 else
256 return false;
257 }
258
audio_extn_hfp_get_usecase()259 audio_usecase_t audio_extn_hfp_get_usecase()
260 {
261 return hfpmod.ucid;
262 }
263
audio_extn_hfp_set_parameters(struct audio_device * adev,struct str_parms * parms)264 void audio_extn_hfp_set_parameters(struct audio_device *adev, struct str_parms *parms)
265 {
266 int ret;
267 int rate;
268 int val;
269 float vol;
270 char value[32]={0};
271
272 ret = str_parms_get_str(parms, AUDIO_PARAMETER_HFP_ENABLE, value,
273 sizeof(value));
274 if (ret >= 0) {
275 if (!strncmp(value,"true",sizeof(value)))
276 ret = start_hfp(adev,parms);
277 else
278 stop_hfp(adev);
279 }
280 memset(value, 0, sizeof(value));
281 ret = str_parms_get_str(parms,AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE, value,
282 sizeof(value));
283 if (ret >= 0) {
284 rate = atoi(value);
285 if (rate == 8000){
286 hfpmod.ucid = USECASE_AUDIO_HFP_SCO;
287 pcm_config_hfp.rate = rate;
288 } else if (rate == 16000){
289 hfpmod.ucid = USECASE_AUDIO_HFP_SCO_WB;
290 pcm_config_hfp.rate = rate;
291 } else
292 ALOGE("Unsupported rate..");
293 }
294
295 if (hfpmod.is_hfp_running) {
296 memset(value, 0, sizeof(value));
297 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
298 value, sizeof(value));
299 if (ret >= 0) {
300 val = atoi(value);
301 if (val > 0)
302 select_devices(adev, hfpmod.ucid);
303 }
304 }
305
306 memset(value, 0, sizeof(value));
307 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_VOLUME,
308 value, sizeof(value));
309 if (ret >= 0) {
310 if (sscanf(value, "%f", &vol) != 1){
311 ALOGE("%s: error in retrieving hfp volume", __func__);
312 ret = -EIO;
313 goto exit;
314 }
315 ALOGD("%s: set_hfp_volume usecase, Vol: [%f]", __func__, vol);
316 hfp_set_volume(adev, vol);
317 }
318 exit:
319 ALOGV("%s Exit",__func__);
320 }
321