/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "soundtrigger"
/* #define LOG_NDEBUG 0 */
#define LOG_NDDEBUG 0
#include <errno.h>
#include <stdbool.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pthread.h>
#include <unistd.h>
#include <log/log.h>
#include "audio_hw.h"
#include "audio_extn.h"
#include "platform.h"
#include "platform_api.h"
/*-------------------- Begin: AHAL-STHAL Interface ---------------------------*/
/*
* Maintain the proprietary interface between AHAL and STHAL locally to avoid
* the compilation dependency of interface header file from STHAL.
*/
#define MAKE_HAL_VERSION(maj, min) ((((maj) & 0xff) << 8) | ((min) & 0xff))
#define MAJOR_VERSION(ver) (((ver) & 0xff00) >> 8)
#define MINOR_VERSION(ver) ((ver) & 0x00ff)
/* Proprietary interface version used for compatibility with STHAL */
#define STHAL_PROP_API_VERSION_1_0 MAKE_HAL_VERSION(1, 0)
#define STHAL_PROP_API_CURRENT_VERSION STHAL_PROP_API_VERSION_1_0
#define ST_EVENT_CONFIG_MAX_STR_VALUE 32
typedef enum {
ST_EVENT_SESSION_REGISTER,
ST_EVENT_SESSION_DEREGISTER
} sound_trigger_event_type_t;
typedef enum {
AUDIO_EVENT_CAPTURE_DEVICE_INACTIVE,
AUDIO_EVENT_CAPTURE_DEVICE_ACTIVE,
AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE,
AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE,
AUDIO_EVENT_STOP_LAB,
AUDIO_EVENT_SSR,
AUDIO_EVENT_NUM_ST_SESSIONS,
AUDIO_EVENT_READ_SAMPLES,
AUDIO_EVENT_DEVICE_CONNECT,
AUDIO_EVENT_DEVICE_DISCONNECT,
AUDIO_EVENT_SVA_EXEC_MODE,
AUDIO_EVENT_SVA_EXEC_MODE_STATUS,
AUDIO_EVENT_CAPTURE_STREAM_INACTIVE,
AUDIO_EVENT_CAPTURE_STREAM_ACTIVE,
} audio_event_type_t;
typedef enum {
USECASE_TYPE_PCM_PLAYBACK,
USECASE_TYPE_PCM_CAPTURE,
USECASE_TYPE_VOICE_CALL,
USECASE_TYPE_VOIP_CALL,
} audio_stream_usecase_type_t;
typedef enum {
SND_CARD_STATUS_OFFLINE,
SND_CARD_STATUS_ONLINE,
CPE_STATUS_OFFLINE,
CPE_STATUS_ONLINE
} ssr_event_status_t;
struct sound_trigger_session_info {
void* p_ses; /* opaque pointer to st_session obj */
int capture_handle;
struct pcm *pcm;
struct pcm_config config;
};
struct audio_read_samples_info {
struct sound_trigger_session_info *ses_info;
void *buf;
size_t num_bytes;
};
struct audio_hal_usecase {
audio_stream_usecase_type_t type;
};
struct sound_trigger_event_info {
struct sound_trigger_session_info st_ses;
};
struct audio_event_info {
union {
ssr_event_status_t status;
int value;
struct sound_trigger_session_info ses_info;
struct audio_read_samples_info aud_info;
char str_value[ST_EVENT_CONFIG_MAX_STR_VALUE];
struct audio_hal_usecase usecase;
}u;
};
/* STHAL callback which is called by AHAL */
typedef int (*sound_trigger_hw_call_back_t)(audio_event_type_t,
struct audio_event_info*);
/*---------------- End: AHAL-STHAL Interface ----------------------------------*/
#define XSTR(x) STR(x)
#define STR(x) #x
#define DLSYM(handle, ptr, symbol, err) \
do { \
ptr = dlsym(handle, #symbol); \
if (ptr == NULL) { \
ALOGE("%s: dlsym %s failed . %s", __func__, #symbol, dlerror()); \
err = -ENODEV; \
} \
} while(0)
#ifdef __LP64__
#define SOUND_TRIGGER_LIBRARY_PATH "/vendor/lib64/hw/sound_trigger.primary.%s.so"
#else
#define SOUND_TRIGGER_LIBRARY_PATH "/vendor/lib/hw/sound_trigger.primary.%s.so"
#endif
/*
* Current proprietary API version used by AHAL. Queried by STHAL
* for compatibility check with AHAL
*/
const unsigned int sthal_prop_api_version = STHAL_PROP_API_CURRENT_VERSION;
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;
unsigned int sthal_prop_api_version;
};
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;
ALOGV("%s: list empty %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;
}
static int populate_usecase(struct audio_hal_usecase *usecase,
struct audio_usecase *uc_info)
{
int status = 0;
switch (uc_info->type) {
case PCM_PLAYBACK:
if (uc_info->id == USECASE_AUDIO_PLAYBACK_VOIP)
usecase->type = USECASE_TYPE_VOIP_CALL;
else
usecase->type = USECASE_TYPE_PCM_PLAYBACK;
break;
case PCM_CAPTURE:
if (uc_info->id == USECASE_AUDIO_RECORD_VOIP)
usecase->type = USECASE_TYPE_VOIP_CALL;
else
usecase->type = USECASE_TYPE_PCM_CAPTURE;
break;
case VOICE_CALL:
usecase->type = USECASE_TYPE_VOICE_CALL;
break;
default:
ALOGE("%s: unsupported usecase type %d", __func__, uc_info->type);
status = -EINVAL;
}
return status;
}
static void stdev_snd_mon_cb(void * stream __unused, struct str_parms * parms)
{
if (!parms)
return;
audio_extn_sound_trigger_set_parameters(NULL, parms);
return;
}
int audio_hw_call_back(sound_trigger_event_type_t event,
struct sound_trigger_event_info* 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;
}
int audio_extn_sound_trigger_read(struct stream_in *in, void *buffer,
size_t bytes)
{
int ret = -1;
struct sound_trigger_info *st_info = NULL;
struct audio_event_info event;
if (!st_dev)
return ret;
if (!in->is_st_session_active) {
ALOGE(" %s: Sound trigger is not active", __func__);
goto exit;
}
if (in->standby)
in->standby = false;
pthread_mutex_lock(&st_dev->lock);
st_info = get_sound_trigger_info(in->capture_handle);
pthread_mutex_unlock(&st_dev->lock);
if (st_info) {
event.u.aud_info.ses_info = &st_info->st_ses;
event.u.aud_info.buf = buffer;
event.u.aud_info.num_bytes = bytes;
ret = st_dev->st_callback(AUDIO_EVENT_READ_SAMPLES, &event);
}
exit:
if (ret) {
if (-ENETRESET == ret)
in->is_st_session_active = false;
memset(buffer, 0, bytes);
ALOGV("%s: read failed status %d - sleep", __func__, ret);
usleep((bytes * 1000000) / (audio_stream_in_frame_size((struct audio_stream_in *)in) *
in->config.rate));
}
return ret;
}
void audio_extn_sound_trigger_stop_lab(struct stream_in *in)
{
struct sound_trigger_info *st_ses_info = NULL;
struct audio_event_info event;
if (!st_dev || !in || !in->is_st_session_active)
return;
pthread_mutex_lock(&st_dev->lock);
st_ses_info = get_sound_trigger_info(in->capture_handle);
pthread_mutex_unlock(&st_dev->lock);
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);
in->is_st_session_active = false;
}
}
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;
in->is_st_session_active = true;
ALOGV("%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)
{
int device_type = -1;
if (!st_dev)
return;
if (st_dev->sthal_prop_api_version >= STHAL_PROP_API_VERSION_1_0)
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) {
if (snd_device == SND_DEVICE_IN_CAPTURE_VI_FEEDBACK)
return;
device_type = PCM_CAPTURE;
} else {
ALOGE("%s: invalid device 0x%x, for event %d",
__func__, snd_device, event);
return;
}
ALOGV("%s: device 0x%x of type %d for Event %d",
__func__, snd_device, device_type, event);
if (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;
struct audio_event_info ev_info;
audio_event_type_t ev;
if (!st_dev)
return;
if (st_dev->sthal_prop_api_version < STHAL_PROP_API_VERSION_1_0)
return;
if (uc_info == NULL) {
ALOGE("%s: null usecase", __func__);
return;
}
bool valid_type =
(uc_info->type == PCM_PLAYBACK &&
platform_snd_device_has_speaker(uc_info->out_snd_device)) ||
(uc_info->type == PCM_CAPTURE) ||
(uc_info->type == VOICE_CALL);
if (valid_type && platform_sound_trigger_usecase_needs_event(uc_info->id)) {
ALOGV("%s: uc_id %d of type %d for Event %d, with Raise=%d",
__func__, uc_info->id, uc_info->type, event, raise_event);
if (uc_info->type == PCM_CAPTURE) {
ev = (event == ST_EVENT_STREAM_BUSY) ? AUDIO_EVENT_CAPTURE_STREAM_ACTIVE :
AUDIO_EVENT_CAPTURE_STREAM_INACTIVE;
} else {
ev = (event == ST_EVENT_STREAM_BUSY) ? AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE :
AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE;
}
if (!populate_usecase(&ev_info.u.usecase, uc_info)) {
ALOGI("%s: send event %d: usecase id %d, type %d",
__func__, ev, uc_info->id, uc_info->type);
st_dev->st_callback(ev, &ev_info);
}
}
}
void audio_extn_sound_trigger_set_parameters(struct audio_device *adev __unused,
struct str_parms *params)
{
struct audio_event_info event;
char value[32];
int ret, val;
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__);
}
ret = str_parms_get_int(params, "SVA_NUM_SESSIONS", &val);
if (ret >= 0) {
event.u.value = val;
st_dev->st_callback(AUDIO_EVENT_NUM_ST_SESSIONS, &event);
}
}
int audio_extn_sound_trigger_init(struct audio_device *adev)
{
int status = 0;
char sound_trigger_lib[100];
void *sthal_prop_api_version;
ALOGV("%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),
SOUND_TRIGGER_LIBRARY_PATH,
XSTR(SOUND_TRIGGER_PLATFORM_NAME));
st_dev->lib_handle = dlopen(sound_trigger_lib, RTLD_NOW);
if (st_dev->lib_handle == NULL) {
ALOGE("%s: error %s", __func__, dlerror());
status = -ENODEV;
goto cleanup;
}
ALOGV("%s: DLOPEN successful for %s", __func__, sound_trigger_lib);
DLSYM(st_dev->lib_handle, st_dev->st_callback, sound_trigger_hw_call_back,
status);
if (status)
goto cleanup;
DLSYM(st_dev->lib_handle, sthal_prop_api_version,
sthal_prop_api_version, status);
if (status) {
st_dev->sthal_prop_api_version = 0;
status = 0; /* passthru for backward compability */
} else {
st_dev->sthal_prop_api_version = *(int*)sthal_prop_api_version;
if (MAJOR_VERSION(st_dev->sthal_prop_api_version) !=
MAJOR_VERSION(STHAL_PROP_API_CURRENT_VERSION)) {
ALOGE("%s: Incompatible API versions ahal:0x%x != sthal:0x%x",
__func__, STHAL_PROP_API_CURRENT_VERSION,
st_dev->sthal_prop_api_version);
goto cleanup;
}
ALOGD("%s: sthal is using proprietary API version 0x%04x", __func__,
st_dev->sthal_prop_api_version);
}
st_dev->adev = adev;
list_init(&st_dev->st_ses_list);
audio_extn_snd_mon_register_listener(st_dev, stdev_snd_mon_cb);
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)
{
ALOGV("%s: Enter", __func__);
if (st_dev && (st_dev->adev == adev) && st_dev->lib_handle) {
audio_extn_snd_mon_unregister_listener(st_dev);
dlclose(st_dev->lib_handle);
free(st_dev);
st_dev = NULL;
}
}