hal: support for sound trigger LAB and concurrency
Sound trigger lookahead buffering data is read through audio hal.
Also the audio hal has to inform sound trigger hal about concurrencies
and subsytsem restart events. Audio Hal uses proprietary interface
defined by sound trigger for communication with sound trigger hal.
Change-Id: Id344077b40b481a953769518f8a6ac0adc13b709
diff --git a/hal/audio_extn/soundtrigger.c b/hal/audio_extn/soundtrigger.c
new file mode 100644
index 0000000..c6d7077
--- /dev/null
+++ b/hal/audio_extn/soundtrigger.c
@@ -0,0 +1,352 @@
+/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#define LOG_TAG "soundtrigger"
+/* #define LOG_NDEBUG 0 */
+#define LOG_NDDEBUG 0
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <cutils/log.h>
+#include "audio_hw.h"
+#include "audio_extn.h"
+#include "platform.h"
+#include "platform_api.h"
+#include "sound_trigger_prop_intf.h"
+
+#define XSTR(x) STR(x)
+#define STR(x) #x
+
+struct sound_trigger_info {
+ struct sound_trigger_session_info st_ses;
+ bool lab_stopped;
+ struct listnode list;
+};
+
+struct sound_trigger_audio_device {
+ void *lib_handle;
+ struct audio_device *adev;
+ sound_trigger_hw_call_back_t st_callback;
+ struct listnode st_ses_list;
+ pthread_mutex_t lock;
+};
+
+static struct sound_trigger_audio_device *st_dev;
+
+static struct sound_trigger_info *
+get_sound_trigger_info(int capture_handle)
+{
+ struct sound_trigger_info *st_ses_info = NULL;
+ struct listnode *node;
+ ALOGD("%s: list %d capture_handle %d", __func__,
+ list_empty(&st_dev->st_ses_list), capture_handle);
+ list_for_each(node, &st_dev->st_ses_list) {
+ st_ses_info = node_to_item(node, struct sound_trigger_info , list);
+ if (st_ses_info->st_ses.capture_handle == capture_handle)
+ return st_ses_info;
+ }
+ return NULL;
+}
+
+int audio_hw_call_back(sound_trigger_event_type_t event,
+ sound_trigger_event_info_t* config)
+{
+ int status = 0;
+ struct sound_trigger_info *st_ses_info;
+
+ if (!st_dev)
+ return -EINVAL;
+
+ pthread_mutex_lock(&st_dev->lock);
+ switch (event) {
+ case ST_EVENT_SESSION_REGISTER:
+ if (!config) {
+ ALOGE("%s: NULL config", __func__);
+ status = -EINVAL;
+ break;
+ }
+ st_ses_info= calloc(1, sizeof(struct sound_trigger_info ));
+ if (!st_ses_info) {
+ ALOGE("%s: st_ses_info alloc failed", __func__);
+ status = -ENOMEM;
+ break;
+ }
+ memcpy(&st_ses_info->st_ses, &config->st_ses, sizeof (config->st_ses));
+ ALOGV("%s: add capture_handle %d pcm %p", __func__,
+ st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
+ list_add_tail(&st_dev->st_ses_list, &st_ses_info->list);
+ break;
+
+ case ST_EVENT_SESSION_DEREGISTER:
+ if (!config) {
+ ALOGE("%s: NULL config", __func__);
+ status = -EINVAL;
+ break;
+ }
+ st_ses_info = get_sound_trigger_info(config->st_ses.capture_handle);
+ if (!st_ses_info) {
+ ALOGE("%s: pcm %p not in the list!", __func__, config->st_ses.pcm);
+ status = -EINVAL;
+ break;
+ }
+ ALOGV("%s: remove capture_handle %d pcm %p", __func__,
+ st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
+ list_remove(&st_ses_info->list);
+ free(st_ses_info);
+ break;
+ default:
+ ALOGW("%s: Unknown event %d", __func__, event);
+ break;
+ }
+ pthread_mutex_unlock(&st_dev->lock);
+ return status;
+}
+
+void audio_extn_sound_trigger_stop_lab(struct stream_in *in)
+{
+ int status = 0;
+ struct sound_trigger_info *st_ses_info = NULL;
+ audio_event_info_t event;
+
+ if (!st_dev || !in)
+ return;
+
+ pthread_mutex_lock(&st_dev->lock);
+ st_ses_info = get_sound_trigger_info(in->capture_handle);
+ if (st_ses_info) {
+ event.u.ses_info = st_ses_info->st_ses;
+ ALOGV("%s: AUDIO_EVENT_STOP_LAB pcm %p", __func__, st_ses_info->st_ses.pcm);
+ st_dev->st_callback(AUDIO_EVENT_STOP_LAB, &event);
+ }
+ pthread_mutex_unlock(&st_dev->lock);
+}
+void audio_extn_sound_trigger_check_and_get_session(struct stream_in *in)
+{
+ struct sound_trigger_info *st_ses_info = NULL;
+ struct listnode *node;
+
+ if (!st_dev || !in)
+ return;
+
+ pthread_mutex_lock(&st_dev->lock);
+ in->is_st_session = false;
+ ALOGV("%s: list %d capture_handle %d", __func__,
+ list_empty(&st_dev->st_ses_list), in->capture_handle);
+ list_for_each(node, &st_dev->st_ses_list) {
+ st_ses_info = node_to_item(node, struct sound_trigger_info , list);
+ if (st_ses_info->st_ses.capture_handle == in->capture_handle) {
+ in->pcm = st_ses_info->st_ses.pcm;
+ in->config = st_ses_info->st_ses.config;
+ in->channel_mask = audio_channel_in_mask_from_count(in->config.channels);
+ in->is_st_session = true;
+ ALOGD("%s: capture_handle %d is sound trigger", __func__, in->capture_handle);
+ break;
+ }
+ }
+ pthread_mutex_unlock(&st_dev->lock);
+}
+
+void audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,
+ st_event_type_t event)
+{
+ bool raise_event = false;
+ int device_type = -1;
+
+ if (!st_dev)
+ return;
+
+ if (snd_device >= SND_DEVICE_OUT_BEGIN &&
+ snd_device < SND_DEVICE_OUT_END)
+ device_type = PCM_PLAYBACK;
+ else if (snd_device >= SND_DEVICE_IN_BEGIN &&
+ snd_device < SND_DEVICE_IN_END)
+ device_type = PCM_CAPTURE;
+ else {
+ ALOGE("%s: invalid device 0x%x, for event %d",
+ __func__, snd_device, event);
+ return;
+ }
+
+ raise_event = platform_sound_trigger_device_needs_event(snd_device);
+ ALOGI("%s: device 0x%x of type %d for Event %d, with Raise=%d",
+ __func__, snd_device, device_type, event, raise_event);
+ if (raise_event && (device_type == PCM_CAPTURE)) {
+ switch(event) {
+ case ST_EVENT_SND_DEVICE_FREE:
+ st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_INACTIVE, NULL);
+ break;
+ case ST_EVENT_SND_DEVICE_BUSY:
+ st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_ACTIVE, NULL);
+ break;
+ default:
+ ALOGW("%s:invalid event %d for device 0x%x",
+ __func__, event, snd_device);
+ }
+ }/*Events for output device, if required can be placed here in else*/
+}
+
+void audio_extn_sound_trigger_update_stream_status(struct audio_usecase *uc_info,
+ st_event_type_t event)
+{
+ bool raise_event = false;
+ audio_usecase_t uc_id;
+ int usecase_type = -1;
+
+ if (!st_dev) {
+ return;
+ }
+
+ if (uc_info == NULL) {
+ ALOGE("%s: usecase is NULL!!!", __func__);
+ return;
+ }
+ uc_id = uc_info->id;
+ usecase_type = uc_info->type;
+
+ raise_event = platform_sound_trigger_usecase_needs_event(uc_id);
+ ALOGD("%s: uc_id %d of type %d for Event %d, with Raise=%d",
+ __func__, uc_id, usecase_type, event, raise_event);
+ if (raise_event && (usecase_type == PCM_PLAYBACK)) {
+ switch(event) {
+ case ST_EVENT_STREAM_FREE:
+ st_dev->st_callback(AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE, NULL);
+ break;
+ case ST_EVENT_STREAM_BUSY:
+ st_dev->st_callback(AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE, NULL);
+ break;
+ default:
+ ALOGW("%s:invalid event %d, for usecase %d",
+ __func__, event, uc_id);
+ }
+ }/*Events for capture usecase, if required can be placed here in else*/
+}
+
+void audio_extn_sound_trigger_set_parameters(struct audio_device *adev __unused,
+ struct str_parms *params)
+{
+ audio_event_info_t event;
+ char value[32];
+ int ret;
+
+ if(!st_dev || !params) {
+ ALOGE("%s: str_params NULL", __func__);
+ return;
+ }
+
+ ret = str_parms_get_str(params, "SND_CARD_STATUS", value,
+ sizeof(value));
+ if (ret > 0) {
+ if (strstr(value, "OFFLINE")) {
+ event.u.status = SND_CARD_STATUS_OFFLINE;
+ st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+ }
+ else if (strstr(value, "ONLINE")) {
+ event.u.status = SND_CARD_STATUS_ONLINE;
+ st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+ }
+ else
+ ALOGE("%s: unknown snd_card_status", __func__);
+ }
+
+ ret = str_parms_get_str(params, "CPE_STATUS", value, sizeof(value));
+ if (ret > 0) {
+ if (strstr(value, "OFFLINE")) {
+ event.u.status = CPE_STATUS_OFFLINE;
+ st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+ }
+ else if (strstr(value, "ONLINE")) {
+ event.u.status = CPE_STATUS_ONLINE;
+ st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+ }
+ else
+ ALOGE("%s: unknown CPE status", __func__);
+ }
+}
+
+int audio_extn_sound_trigger_init(struct audio_device *adev)
+{
+ int status = 0;
+ char sound_trigger_lib[100];
+ void *lib_handle;
+
+ ALOGI("%s: Enter", __func__);
+
+ st_dev = (struct sound_trigger_audio_device*)
+ calloc(1, sizeof(struct sound_trigger_audio_device));
+ if (!st_dev) {
+ ALOGE("%s: ERROR. sound trigger alloc failed", __func__);
+ return -ENOMEM;
+ }
+
+ snprintf(sound_trigger_lib, sizeof(sound_trigger_lib),
+ "/system/vendor/lib/hw/sound_trigger.primary.%s.so",
+ XSTR(SOUND_TRIGGER_PLATFORM_NAME));
+
+ st_dev->lib_handle = dlopen(sound_trigger_lib, RTLD_NOW);
+
+ if (st_dev->lib_handle == NULL) {
+ ALOGE("%s: DLOPEN failed for %s. error = %s", __func__, sound_trigger_lib,
+ dlerror());
+ status = -EINVAL;
+ goto cleanup;
+ }
+ ALOGI("%s: DLOPEN successful for %s", __func__, sound_trigger_lib);
+
+ st_dev->st_callback = (sound_trigger_hw_call_back_t)
+ dlsym(st_dev->lib_handle, "sound_trigger_hw_call_back");
+
+ if (st_dev->st_callback == NULL) {
+ ALOGE("%s: ERROR. dlsym Error:%s sound_trigger_hw_call_back", __func__,
+ dlerror());
+ goto cleanup;
+ }
+
+ st_dev->adev = adev;
+ list_init(&st_dev->st_ses_list);
+
+ return 0;
+
+cleanup:
+ if (st_dev->lib_handle)
+ dlclose(st_dev->lib_handle);
+ free(st_dev);
+ st_dev = NULL;
+ return status;
+
+}
+
+void audio_extn_sound_trigger_deinit(struct audio_device *adev)
+{
+ ALOGI("%s: Enter", __func__);
+ if (st_dev && (st_dev->adev == adev) && st_dev->lib_handle) {
+ dlclose(st_dev->lib_handle);
+ free(st_dev);
+ st_dev = NULL;
+ }
+}