Merge "hal: support for sound trigger LAB and concurrency" (805c8ed9) · Commits · e / devices / FP5 / android_hardware_qcom_audio

hal/Android.mk

+7 −0

Original line number	Diff line number	Diff line
		@@ -171,6 +171,13 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_LISTEN)),true)
		LOCAL_SRC_FILES += audio_extn/listen.c
		endif

		ifeq ($(strip $(BOARD_SUPPORTS_SOUND_TRIGGER)),true)
		LOCAL_CFLAGS += -DSOUND_TRIGGER_ENABLED
		LOCAL_CFLAGS += -DSOUND_TRIGGER_PLATFORM_NAME=$(TARGET_BOARD_PLATFORM)
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/sound_trigger
		LOCAL_SRC_FILES += audio_extn/soundtrigger.c
		endif

		ifeq ($(strip $(AUDIO_FEATURE_ENABLED_AUXPCM_BT)),true)
		LOCAL_CFLAGS += -DAUXPCM_BT_ENABLED
		endif

hal/audio_extn/audio_extn.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -457,6 +457,7 @@ void audio_extn_set_parameters(struct audio_device *adev,
		audio_extn_set_fluence_parameters(adev, parms);
		audio_extn_set_afe_proxy_parameters(adev, parms);
		audio_extn_fm_set_parameters(adev, parms);
		audio_extn_sound_trigger_set_parameters(adev, parms);
		audio_extn_listen_set_parameters(adev, parms);
		audio_extn_hfp_set_parameters(adev, parms);
		audio_extn_ddp_set_parameters(adev, parms);

hal/audio_extn/audio_extn.h

+30 −0

Original line number	Diff line number	Diff line
		@@ -177,6 +177,36 @@ void audio_extn_listen_set_parameters(struct audio_device *adev,
		struct str_parms *parms);
		#endif /* AUDIO_LISTEN_ENABLED */

		#ifndef SOUND_TRIGGER_ENABLED
		#define audio_extn_sound_trigger_init(adev) (0)
		#define audio_extn_sound_trigger_deinit(adev) (0)
		#define audio_extn_sound_trigger_update_device_status(snd_dev, event) (0)
		#define audio_extn_sound_trigger_update_stream_status(uc_info, event) (0)
		#define audio_extn_sound_trigger_set_parameters(adev, parms) (0)
		#define audio_extn_sound_trigger_check_and_get_session(in) (0)
		#define audio_extn_sound_trigger_stop_lab(in) (0)
		#else

		enum st_event_type {
		ST_EVENT_SND_DEVICE_FREE,
		ST_EVENT_SND_DEVICE_BUSY,
		ST_EVENT_STREAM_FREE,
		ST_EVENT_STREAM_BUSY
		};
		typedef enum st_event_type st_event_type_t;

		int audio_extn_sound_trigger_init(struct audio_device *adev);
		void audio_extn_sound_trigger_deinit(struct audio_device *adev);
		void audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,
		st_event_type_t event);
		void audio_extn_sound_trigger_update_stream_status(struct audio_usecase *uc_info,
		st_event_type_t event);
		void audio_extn_sound_trigger_set_parameters(struct audio_device *adev,
		struct str_parms *parms);
		void audio_extn_sound_trigger_check_and_get_session(struct stream_in *in);
		void audio_extn_sound_trigger_stop_lab(struct stream_in *in);
		#endif

		#ifndef AUXPCM_BT_ENABLED
		#define audio_extn_read_xml(adev, mixer_card, MIXER_XML_PATH, \
		MIXER_XML_PATH_AUXPCM) (-ENOSYS)

hal/audio_extn/soundtrigger.c

0 → 100644

+352 −0

Original line number	Diff line number	Diff line
		/* 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;
		}
		}

hal/audio_hw.c

+38 −14

Original line number	Diff line number	Diff line
		@@ -288,6 +288,7 @@ int enable_audio_route(struct audio_device *adev,
		audio_extn_dolby_set_dmid(adev);
		audio_extn_dolby_set_endpoint(adev);
		#endif
		audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);
		audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_BUSY);
		audio_extn_utils_send_audio_calibration(adev, usecase);
		audio_extn_utils_send_app_type_cfg(usecase);
		@@ -317,6 +318,7 @@ int disable_audio_route(struct audio_device *adev,
		platform_add_backend_name(mixer_path, snd_device);
		ALOGV("%s: reset and update mixer path: %s", __func__, mixer_path);
		audio_route_reset_and_update_path(adev->audio_route, mixer_path);
		audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_FREE);
		audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_FREE);
		ALOGV("%s: exit", __func__);
		return 0;
		@@ -372,10 +374,14 @@ int enable_snd_device(struct audio_device *adev,
		snd_device, device_name);
		/* due to the possibility of calibration overwrite between listen
		and audio, notify listen hal before audio calibration is sent */
		audio_extn_sound_trigger_update_device_status(snd_device,
		ST_EVENT_SND_DEVICE_BUSY);
		audio_extn_listen_update_device_status(snd_device,
		LISTEN_EVENT_SND_DEVICE_BUSY);
		if (platform_get_snd_device_acdb_id(snd_device) < 0) {
		adev->snd_dev_ref_cnt[snd_device]--;
		audio_extn_sound_trigger_update_device_status(snd_device,
		ST_EVENT_SND_DEVICE_FREE);
		audio_extn_listen_update_device_status(snd_device,
		LISTEN_EVENT_SND_DEVICE_FREE);
		return -EINVAL;
		@@ -428,6 +434,9 @@ int disable_snd_device(struct audio_device *adev,
		audio_route_reset_and_update_path(adev->audio_route, device_name);
		audio_extn_dev_arbi_release(snd_device);
		}

		audio_extn_sound_trigger_update_device_status(snd_device,
		ST_EVENT_SND_DEVICE_FREE);
		audio_extn_listen_update_device_status(snd_device,
		LISTEN_EVENT_SND_DEVICE_FREE);
		}
		@@ -2101,7 +2110,6 @@ static int in_standby(struct audio_stream *stream)
		ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
		stream, in->usecase, use_case_table[in->usecase]);


		if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
		/* Ignore standby in case of voip call because the voip input
		* stream is closed in adev_close_input_stream()
		@@ -2111,6 +2119,12 @@ static int in_standby(struct audio_stream *stream)
		}

		pthread_mutex_lock(&in->lock);
		if (!in->standby && in->is_st_session) {
		ALOGD("%s: sound trigger pcm stop lab", __func__);
		audio_extn_sound_trigger_stop_lab(in);
		in->standby = 1;
		}

		if (!in->standby) {
		pthread_mutex_lock(&adev->lock);
		in->standby = true;
		@@ -2172,7 +2186,7 @@ static int in_set_parameters(struct audio_stream stream, const char kvpairs)
		if ((in->device != val) && (val != 0)) {
		in->device = val;
		/* If recording is in progress, change the tx device to new device */
		if (!in->standby)
		if (!in->standby && !in->is_st_session)
		ret = select_devices(adev, in->usecase);
		}
		}
		@@ -2236,6 +2250,7 @@ static ssize_t in_read(struct audio_stream_in stream, void buffer,
		}

		if (in->standby) {
		if (!in->is_st_session) {
		pthread_mutex_lock(&adev->lock);
		if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
		ret = voice_extn_compress_voip_start_input_stream(in);
		@@ -2245,6 +2260,7 @@ static ssize_t in_read(struct audio_stream_in stream, void buffer,
		if (ret != 0) {
		goto exit;
		}
		}
		in->standby = 0;
		}

		@@ -2283,7 +2299,7 @@ exit:
		}
		memset(buffer, 0, bytes);
		in_standby(&in->stream.common);
		ALOGV("%s: read failed - sleeping for buffer duration", __func__);
		ALOGV("%s: read failed status %d- sleeping for buffer duration", __func__, ret);
		usleep(bytes * 1000000 / audio_stream_frame_size(&in->stream.common) /
		in_get_sample_rate(&in->stream.common));
		}
		@@ -2898,8 +2914,8 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
		}

		ALOGD("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x)\
		stream_handle(%p)",__func__, config->sample_rate, config->channel_mask,
		devices, &in->stream);
		stream_handle(%p) io_handle(%d)",__func__, config->sample_rate, config->channel_mask,
		devices, &in->stream, handle);

		pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);

		@@ -2924,6 +2940,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
		in->dev = adev;
		in->standby = 1;
		in->channel_mask = config->channel_mask;
		in->capture_handle = handle;

		/* Update config params with the requested sample rate and channels */
		in->usecase = USECASE_AUDIO_RECORD;
		@@ -2955,6 +2972,10 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
		in->config.period_size = buffer_size / frame_size;
		}

		/* This stream could be for sound trigger lab,
		get sound trigger pcm if present */
		audio_extn_sound_trigger_check_and_get_session(in);

		*stream_in = &in->stream;
		ALOGV("%s: exit", __func__);
		return ret;
		@@ -2987,11 +3008,12 @@ static void adev_close_input_stream(struct audio_hw_device *dev,
		if (audio_extn_ssr_get_enabled() && (popcount(in->channel_mask) == 6)) {
		audio_extn_ssr_deinit();
		}
		free(stream);

		if(audio_extn_compr_cap_enabled() &&
		audio_extn_compr_cap_format_supported(in->config.format))
		audio_extn_compr_cap_deinit();

		free(stream);
		return;
		}

		@@ -3010,6 +3032,7 @@ static int adev_close(hw_device_t *device)
		pthread_mutex_lock(&adev_init_lock);

		if ((--audio_device_ref_count) == 0) {
		audio_extn_sound_trigger_deinit(adev);
		audio_extn_listen_deinit(adev);
		audio_extn_utils_release_streams_output_cfg_list(&adev->streams_output_cfg_list);
		audio_route_free(adev->audio_route);
		@@ -3118,6 +3141,7 @@ static int adev_open(const hw_module_t module, const char name,
		}
		}
		audio_extn_listen_init(adev, adev->snd_card);
		audio_extn_sound_trigger_init(adev);

		if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) {
		adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);