1 /*
2 * Copyright (C) 2015 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 #define LOG_TAG "soundtrigger"
17 /* #define LOG_NDEBUG 0 */
18 #define LOG_NDDEBUG 0
19
20 #include <errno.h>
21 #include <stdbool.h>
22 #include <stdlib.h>
23 #include <dlfcn.h>
24 #include <pthread.h>
25 #include <unistd.h>
26 #include <log/log.h>
27 #include "audio_hw.h"
28 #include "audio_extn.h"
29 #include "platform.h"
30 #include "platform_api.h"
31
32 /*-------------------- Begin: AHAL-STHAL Interface ---------------------------*/
33 /*
34 * Maintain the proprietary interface between AHAL and STHAL locally to avoid
35 * the compilation dependency of interface header file from STHAL.
36 */
37
38 #define MAKE_HAL_VERSION(maj, min) ((((maj) & 0xff) << 8) | ((min) & 0xff))
39 #define MAJOR_VERSION(ver) (((ver) & 0xff00) >> 8)
40 #define MINOR_VERSION(ver) ((ver) & 0x00ff)
41
42 /* Proprietary interface version used for compatibility with STHAL */
43 #define STHAL_PROP_API_VERSION_1_0 MAKE_HAL_VERSION(1, 0)
44 #define STHAL_PROP_API_CURRENT_VERSION STHAL_PROP_API_VERSION_1_0
45
46 #define ST_EVENT_CONFIG_MAX_STR_VALUE 32
47
48 typedef enum {
49 ST_EVENT_SESSION_REGISTER,
50 ST_EVENT_SESSION_DEREGISTER
51 } sound_trigger_event_type_t;
52
53 typedef enum {
54 AUDIO_EVENT_CAPTURE_DEVICE_INACTIVE,
55 AUDIO_EVENT_CAPTURE_DEVICE_ACTIVE,
56 AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE,
57 AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE,
58 AUDIO_EVENT_STOP_LAB,
59 AUDIO_EVENT_SSR,
60 AUDIO_EVENT_NUM_ST_SESSIONS,
61 AUDIO_EVENT_READ_SAMPLES,
62 AUDIO_EVENT_DEVICE_CONNECT,
63 AUDIO_EVENT_DEVICE_DISCONNECT,
64 AUDIO_EVENT_SVA_EXEC_MODE,
65 AUDIO_EVENT_SVA_EXEC_MODE_STATUS,
66 AUDIO_EVENT_CAPTURE_STREAM_INACTIVE,
67 AUDIO_EVENT_CAPTURE_STREAM_ACTIVE,
68 } audio_event_type_t;
69
70 typedef enum {
71 USECASE_TYPE_PCM_PLAYBACK,
72 USECASE_TYPE_PCM_CAPTURE,
73 USECASE_TYPE_VOICE_CALL,
74 USECASE_TYPE_VOIP_CALL,
75 } audio_stream_usecase_type_t;
76
77 typedef enum {
78 SND_CARD_STATUS_OFFLINE,
79 SND_CARD_STATUS_ONLINE,
80 CPE_STATUS_OFFLINE,
81 CPE_STATUS_ONLINE,
82 SLPI_STATUS_OFFLINE,
83 SLPI_STATUS_ONLINE,
84 } ssr_event_status_t;
85
86 struct sound_trigger_session_info {
87 void* p_ses; /* opaque pointer to st_session obj */
88 int capture_handle;
89 struct pcm *pcm;
90 struct pcm_config config;
91 };
92
93 struct audio_read_samples_info {
94 struct sound_trigger_session_info *ses_info;
95 void *buf;
96 size_t num_bytes;
97 };
98
99 struct audio_hal_usecase {
100 audio_stream_usecase_type_t type;
101 };
102
103 struct sound_trigger_event_info {
104 struct sound_trigger_session_info st_ses;
105 };
106
107 struct audio_event_info {
108 union {
109 ssr_event_status_t status;
110 int value;
111 struct sound_trigger_session_info ses_info;
112 struct audio_read_samples_info aud_info;
113 char str_value[ST_EVENT_CONFIG_MAX_STR_VALUE];
114 struct audio_hal_usecase usecase;
115 }u;
116 };
117
118 /* STHAL callback which is called by AHAL */
119 typedef int (*sound_trigger_hw_call_back_t)(audio_event_type_t,
120 struct audio_event_info*);
121
122 /*---------------- End: AHAL-STHAL Interface ----------------------------------*/
123
124 #define XSTR(x) STR(x)
125 #define STR(x) #x
126
127 #define DLSYM(handle, ptr, symbol, err) \
128 do { \
129 ptr = dlsym(handle, #symbol); \
130 if (ptr == NULL) { \
131 ALOGE("%s: dlsym %s failed . %s", __func__, #symbol, dlerror()); \
132 err = -ENODEV; \
133 } \
134 } while(0)
135
136 #ifdef __LP64__
137 #define SOUND_TRIGGER_LIBRARY_PATH "/vendor/lib64/hw/sound_trigger.primary.%s.so"
138 #else
139 #define SOUND_TRIGGER_LIBRARY_PATH "/vendor/lib/hw/sound_trigger.primary.%s.so"
140 #endif
141
142 /*
143 * Current proprietary API version used by AHAL. Queried by STHAL
144 * for compatibility check with AHAL
145 */
146 const unsigned int sthal_prop_api_version = STHAL_PROP_API_CURRENT_VERSION;
147
148 struct sound_trigger_info {
149 struct sound_trigger_session_info st_ses;
150 bool lab_stopped;
151 struct listnode list;
152 };
153
154 struct sound_trigger_audio_device {
155 void *lib_handle;
156 struct audio_device *adev;
157 sound_trigger_hw_call_back_t st_callback;
158 struct listnode st_ses_list;
159 pthread_mutex_t lock;
160 unsigned int sthal_prop_api_version;
161 };
162
163 static struct sound_trigger_audio_device *st_dev;
164
165 static struct sound_trigger_info *
get_sound_trigger_info(int capture_handle)166 get_sound_trigger_info(int capture_handle)
167 {
168 struct sound_trigger_info *st_ses_info = NULL;
169 struct listnode *node;
170 ALOGV("%s: list empty %d capture_handle %d", __func__,
171 list_empty(&st_dev->st_ses_list), capture_handle);
172 list_for_each(node, &st_dev->st_ses_list) {
173 st_ses_info = node_to_item(node, struct sound_trigger_info , list);
174 if (st_ses_info->st_ses.capture_handle == capture_handle)
175 return st_ses_info;
176 }
177 return NULL;
178 }
179
populate_usecase(struct audio_hal_usecase * usecase,struct audio_usecase * uc_info)180 static int populate_usecase(struct audio_hal_usecase *usecase,
181 struct audio_usecase *uc_info)
182 {
183 int status = 0;
184
185 switch (uc_info->type) {
186 case PCM_PLAYBACK:
187 if (uc_info->id == USECASE_AUDIO_PLAYBACK_VOIP)
188 usecase->type = USECASE_TYPE_VOIP_CALL;
189 else
190 usecase->type = USECASE_TYPE_PCM_PLAYBACK;
191 break;
192
193 case PCM_CAPTURE:
194 if (uc_info->id == USECASE_AUDIO_RECORD_VOIP)
195 usecase->type = USECASE_TYPE_VOIP_CALL;
196 else
197 usecase->type = USECASE_TYPE_PCM_CAPTURE;
198 break;
199
200 case VOICE_CALL:
201 usecase->type = USECASE_TYPE_VOICE_CALL;
202 break;
203
204 default:
205 ALOGE("%s: unsupported usecase type %d", __func__, uc_info->type);
206 status = -EINVAL;
207 }
208 return status;
209 }
210
stdev_snd_mon_cb(void * stream __unused,struct str_parms * parms)211 static void stdev_snd_mon_cb(void * stream __unused, struct str_parms * parms)
212 {
213 if (!parms)
214 return;
215
216 audio_extn_sound_trigger_set_parameters(NULL, parms);
217 return;
218 }
219
audio_hw_call_back(sound_trigger_event_type_t event,struct sound_trigger_event_info * config)220 int audio_hw_call_back(sound_trigger_event_type_t event,
221 struct sound_trigger_event_info* config)
222 {
223 int status = 0;
224 struct sound_trigger_info *st_ses_info;
225
226 if (!st_dev)
227 return -EINVAL;
228
229 pthread_mutex_lock(&st_dev->lock);
230 switch (event) {
231 case ST_EVENT_SESSION_REGISTER:
232 if (!config) {
233 ALOGE("%s: NULL config", __func__);
234 status = -EINVAL;
235 break;
236 }
237 st_ses_info= calloc(1, sizeof(struct sound_trigger_info ));
238 if (!st_ses_info) {
239 ALOGE("%s: st_ses_info alloc failed", __func__);
240 status = -ENOMEM;
241 break;
242 }
243 memcpy(&st_ses_info->st_ses, &config->st_ses, sizeof (config->st_ses));
244 ALOGV("%s: add capture_handle %d pcm %p", __func__,
245 st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
246 list_add_tail(&st_dev->st_ses_list, &st_ses_info->list);
247 break;
248
249 case ST_EVENT_SESSION_DEREGISTER:
250 if (!config) {
251 ALOGE("%s: NULL config", __func__);
252 status = -EINVAL;
253 break;
254 }
255 st_ses_info = get_sound_trigger_info(config->st_ses.capture_handle);
256 if (!st_ses_info) {
257 ALOGE("%s: pcm %p not in the list!", __func__, config->st_ses.pcm);
258 status = -EINVAL;
259 break;
260 }
261 ALOGV("%s: remove capture_handle %d pcm %p", __func__,
262 st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
263 list_remove(&st_ses_info->list);
264 free(st_ses_info);
265 break;
266 default:
267 ALOGW("%s: Unknown event %d", __func__, event);
268 break;
269 }
270 pthread_mutex_unlock(&st_dev->lock);
271 return status;
272 }
273
audio_extn_sound_trigger_read(struct stream_in * in,void * buffer,size_t bytes)274 int audio_extn_sound_trigger_read(struct stream_in *in, void *buffer,
275 size_t bytes)
276 {
277 int ret = -1;
278 struct sound_trigger_info *st_info = NULL;
279 struct audio_event_info event;
280
281 if (!st_dev)
282 return ret;
283
284 if (!in->is_st_session_active) {
285 ALOGE(" %s: Sound trigger is not active", __func__);
286 goto exit;
287 }
288 if (in->standby)
289 in->standby = false;
290
291 pthread_mutex_lock(&st_dev->lock);
292 st_info = get_sound_trigger_info(in->capture_handle);
293 pthread_mutex_unlock(&st_dev->lock);
294 if (st_info) {
295 event.u.aud_info.ses_info = &st_info->st_ses;
296 event.u.aud_info.buf = buffer;
297 event.u.aud_info.num_bytes = bytes;
298 ret = st_dev->st_callback(AUDIO_EVENT_READ_SAMPLES, &event);
299 }
300
301 exit:
302 if (ret) {
303 if (-ENETRESET == ret)
304 in->is_st_session_active = false;
305 memset(buffer, 0, bytes);
306 ALOGV("%s: read failed status %d - sleep", __func__, ret);
307 usleep((bytes * 1000000) / (audio_stream_in_frame_size((struct audio_stream_in *)in) *
308 in->config.rate));
309 }
310 return ret;
311 }
312
audio_extn_sound_trigger_stop_lab(struct stream_in * in)313 void audio_extn_sound_trigger_stop_lab(struct stream_in *in)
314 {
315 struct sound_trigger_info *st_ses_info = NULL;
316 struct audio_event_info event;
317
318 if (!st_dev || !in || !in->is_st_session_active)
319 return;
320
321 pthread_mutex_lock(&st_dev->lock);
322 st_ses_info = get_sound_trigger_info(in->capture_handle);
323 pthread_mutex_unlock(&st_dev->lock);
324 if (st_ses_info) {
325 event.u.ses_info = st_ses_info->st_ses;
326 ALOGV("%s: AUDIO_EVENT_STOP_LAB pcm %p", __func__, st_ses_info->st_ses.pcm);
327 st_dev->st_callback(AUDIO_EVENT_STOP_LAB, &event);
328 in->is_st_session_active = false;
329 }
330 }
331
audio_extn_sound_trigger_check_and_get_session(struct stream_in * in)332 void audio_extn_sound_trigger_check_and_get_session(struct stream_in *in)
333 {
334 struct sound_trigger_info *st_ses_info = NULL;
335 struct listnode *node;
336
337 if (!st_dev || !in)
338 return;
339
340 pthread_mutex_lock(&st_dev->lock);
341 in->is_st_session = false;
342 ALOGV("%s: list %d capture_handle %d", __func__,
343 list_empty(&st_dev->st_ses_list), in->capture_handle);
344 list_for_each(node, &st_dev->st_ses_list) {
345 st_ses_info = node_to_item(node, struct sound_trigger_info , list);
346 if (st_ses_info->st_ses.capture_handle == in->capture_handle) {
347 in->pcm = st_ses_info->st_ses.pcm;
348 in->config = st_ses_info->st_ses.config;
349 in->channel_mask = audio_channel_in_mask_from_count(in->config.channels);
350 in->is_st_session = true;
351 in->is_st_session_active = true;
352 ALOGV("%s: capture_handle %d is sound trigger", __func__, in->capture_handle);
353 break;
354 }
355 }
356 pthread_mutex_unlock(&st_dev->lock);
357 }
358
audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,st_event_type_t event)359 void audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,
360 st_event_type_t event)
361 {
362 int device_type = -1;
363
364 if (!st_dev)
365 return;
366
367 if (snd_device >= SND_DEVICE_OUT_BEGIN &&
368 snd_device < SND_DEVICE_OUT_END) {
369 device_type = PCM_PLAYBACK;
370 } else if (snd_device >= SND_DEVICE_IN_BEGIN &&
371 snd_device < SND_DEVICE_IN_END) {
372 if (snd_device == SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)
373 return;
374 device_type = PCM_CAPTURE;
375 } else {
376 ALOGE("%s: invalid device 0x%x, for event %d",
377 __func__, snd_device, event);
378 return;
379 }
380
381 ALOGV("%s: device 0x%x of type %d for Event %d",
382 __func__, snd_device, device_type, event);
383 if (device_type == PCM_CAPTURE) {
384 switch(event) {
385 case ST_EVENT_SND_DEVICE_FREE:
386 st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_INACTIVE, NULL);
387 break;
388 case ST_EVENT_SND_DEVICE_BUSY:
389 st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_ACTIVE, NULL);
390 break;
391 default:
392 ALOGW("%s:invalid event %d for device 0x%x",
393 __func__, event, snd_device);
394 }
395 }/*Events for output device, if required can be placed here in else*/
396 }
397
audio_extn_sound_trigger_update_stream_status(struct audio_usecase * uc_info,st_event_type_t event)398 void audio_extn_sound_trigger_update_stream_status(struct audio_usecase *uc_info,
399 st_event_type_t event)
400 {
401 bool raise_event = false;
402 struct audio_event_info ev_info;
403 audio_event_type_t ev;
404
405 if (!st_dev)
406 return;
407
408 if (st_dev->sthal_prop_api_version < STHAL_PROP_API_VERSION_1_0)
409 return;
410
411 if (uc_info == NULL) {
412 ALOGE("%s: null usecase", __func__);
413 return;
414 }
415
416 bool valid_type =
417 (uc_info->type == PCM_PLAYBACK &&
418 platform_snd_device_has_speaker(uc_info->out_snd_device)) ||
419 (uc_info->type == PCM_CAPTURE) ||
420 (uc_info->type == VOICE_CALL);
421
422 if (valid_type && platform_sound_trigger_usecase_needs_event(uc_info->id)) {
423 ALOGV("%s: uc_id %d of type %d for Event %d, with Raise=%d",
424 __func__, uc_info->id, uc_info->type, event, raise_event);
425 if (uc_info->type == PCM_CAPTURE || uc_info->type == VOICE_CALL) {
426 ev = (event == ST_EVENT_STREAM_BUSY) ? AUDIO_EVENT_CAPTURE_STREAM_ACTIVE :
427 AUDIO_EVENT_CAPTURE_STREAM_INACTIVE;
428 } else {
429 ev = (event == ST_EVENT_STREAM_BUSY) ? AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE :
430 AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE;
431 }
432 if (!populate_usecase(&ev_info.u.usecase, uc_info)) {
433 ALOGI("%s: send event %d: usecase id %d, type %d",
434 __func__, ev, uc_info->id, uc_info->type);
435 st_dev->st_callback(ev, &ev_info);
436 }
437 }
438 }
439
audio_extn_sound_trigger_set_parameters(struct audio_device * adev __unused,struct str_parms * params)440 void audio_extn_sound_trigger_set_parameters(struct audio_device *adev __unused,
441 struct str_parms *params)
442 {
443 struct audio_event_info event;
444 char value[32];
445 int ret, val;
446
447 if(!st_dev || !params) {
448 ALOGE("%s: str_params NULL", __func__);
449 return;
450 }
451
452 ret = str_parms_get_str(params, "SND_CARD_STATUS", value,
453 sizeof(value));
454 if (ret > 0) {
455 if (strstr(value, "OFFLINE")) {
456 event.u.status = SND_CARD_STATUS_OFFLINE;
457 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
458 }
459 else if (strstr(value, "ONLINE")) {
460 event.u.status = SND_CARD_STATUS_ONLINE;
461 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
462 }
463 else
464 ALOGE("%s: unknown snd_card_status", __func__);
465 }
466
467 ret = str_parms_get_str(params, "CPE_STATUS", value, sizeof(value));
468 if (ret > 0) {
469 if (strstr(value, "OFFLINE")) {
470 event.u.status = CPE_STATUS_OFFLINE;
471 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
472 }
473 else if (strstr(value, "ONLINE")) {
474 event.u.status = CPE_STATUS_ONLINE;
475 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
476 }
477 else
478 ALOGE("%s: unknown CPE status", __func__);
479 }
480
481 ret = str_parms_get_int(params, "SVA_NUM_SESSIONS", &val);
482 if (ret >= 0) {
483 event.u.value = val;
484 st_dev->st_callback(AUDIO_EVENT_NUM_ST_SESSIONS, &event);
485 }
486
487 ret = str_parms_get_str(params, "SLPI_STATUS", value, sizeof(value));
488 if (ret > 0) {
489 if (strstr(value, "OFFLINE")) {
490 event.u.status = SLPI_STATUS_OFFLINE;
491 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
492 } else if (strstr(value, "ONLINE")) {
493 event.u.status = SLPI_STATUS_ONLINE;
494 st_dev->st_callback(AUDIO_EVENT_SSR, &event);
495 } else {
496 ALOGE("%s: unknown SLPI status", __func__);
497 }
498 }
499 }
500
audio_extn_sound_trigger_init(struct audio_device * adev)501 int audio_extn_sound_trigger_init(struct audio_device *adev)
502 {
503 int status = 0;
504 char sound_trigger_lib[100];
505 void *sthal_prop_api_version;
506
507 ALOGV("%s: Enter", __func__);
508
509 st_dev = (struct sound_trigger_audio_device*)
510 calloc(1, sizeof(struct sound_trigger_audio_device));
511 if (!st_dev) {
512 ALOGE("%s: ERROR. sound trigger alloc failed", __func__);
513 return -ENOMEM;
514 }
515
516 snprintf(sound_trigger_lib, sizeof(sound_trigger_lib),
517 SOUND_TRIGGER_LIBRARY_PATH,
518 XSTR(SOUND_TRIGGER_PLATFORM_NAME));
519
520 st_dev->lib_handle = dlopen(sound_trigger_lib, RTLD_NOW);
521
522 if (st_dev->lib_handle == NULL) {
523 ALOGE("%s: error %s", __func__, dlerror());
524 status = -ENODEV;
525 goto cleanup;
526 }
527 ALOGV("%s: DLOPEN successful for %s", __func__, sound_trigger_lib);
528
529 DLSYM(st_dev->lib_handle, st_dev->st_callback, sound_trigger_hw_call_back,
530 status);
531 if (status)
532 goto cleanup;
533
534 DLSYM(st_dev->lib_handle, sthal_prop_api_version,
535 sthal_prop_api_version, status);
536 if (status) {
537 st_dev->sthal_prop_api_version = 0;
538 status = 0; /* passthru for backward compability */
539 } else {
540 st_dev->sthal_prop_api_version = *(int*)sthal_prop_api_version;
541 if (MAJOR_VERSION(st_dev->sthal_prop_api_version) !=
542 MAJOR_VERSION(STHAL_PROP_API_CURRENT_VERSION)) {
543 ALOGE("%s: Incompatible API versions ahal:0x%x != sthal:0x%x",
544 __func__, STHAL_PROP_API_CURRENT_VERSION,
545 st_dev->sthal_prop_api_version);
546 goto cleanup;
547 }
548 ALOGD("%s: sthal is using proprietary API version 0x%04x", __func__,
549 st_dev->sthal_prop_api_version);
550 }
551
552 st_dev->adev = adev;
553 list_init(&st_dev->st_ses_list);
554 audio_extn_snd_mon_register_listener(st_dev, stdev_snd_mon_cb);
555
556 return 0;
557
558 cleanup:
559 if (st_dev->lib_handle)
560 dlclose(st_dev->lib_handle);
561 free(st_dev);
562 st_dev = NULL;
563 return status;
564 }
565
audio_extn_sound_trigger_deinit(struct audio_device * adev)566 void audio_extn_sound_trigger_deinit(struct audio_device *adev)
567 {
568 ALOGV("%s: Enter", __func__);
569 if (st_dev && (st_dev->adev == adev) && st_dev->lib_handle) {
570 audio_extn_snd_mon_unregister_listener(st_dev);
571 dlclose(st_dev->lib_handle);
572 free(st_dev);
573 st_dev = NULL;
574 }
575 }
576