3
0
replicant-device_samsung_ga.../tinyalsa_audio/audio_hw.c
codeworkx 605c54b82e audio: update for mr1
Change-Id: I92348574296ab03c0f57b0dfa81bcded7ddb89cb
2012-12-02 15:39:09 +01:00

517 lines
13 KiB
C

/*
* Copyright (C) 2012 Paul Kocialkowski <contact@paulk.fr>
*
* This is based on Galaxy Nexus audio.primary.tuna implementation:
* Copyright 2011, The Android Open-Source Project
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define LOG_TAG "TinyALSA-Audio Hardware"
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <sys/time.h>
#include <cutils/str_parms.h>
#include <cutils/log.h>
#ifdef YAMAHA_MC1N2_AUDIO
#include <yamaha-mc1n2-audio.h>
#endif
#include "audio_hw.h"
#include "mixer.h"
/*
* Functions
*/
static int audio_hw_init_check(const struct audio_hw_device *dev)
{
struct tinyalsa_audio_device *device;
ALOGD("%s(%p)", __func__, dev);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
return 0;
}
static int audio_hw_set_voice_volume(struct audio_hw_device *dev, float volume)
{
struct tinyalsa_audio_device *device;
audio_devices_t device_modem;
ALOGD("%s(%p, %f)++", __func__, dev, volume);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
if(volume != device->voice_volume) {
pthread_mutex_lock(&device->lock);
if(device->mode == AUDIO_MODE_IN_CALL) {
if(device->ril_interface != NULL)
device_modem = device->ril_interface->device_current;
else if(device->stream_out != NULL)
device_modem = device->stream_out->device_current;
else
device_modem = AUDIO_DEVICE_OUT_EARPIECE;
tinyalsa_mixer_set_voice_volume(device->mixer,
device_modem, volume);
if(device->ril_interface != NULL)
audio_ril_interface_set_voice_volume(device->ril_interface, device_modem, volume);
}
device->voice_volume = volume;
pthread_mutex_unlock(&device->lock);
}
ALOGD("%s(%p, %f)--", __func__, dev, volume);
return 0;
}
static int audio_hw_set_master_volume(struct audio_hw_device *dev, float volume)
{
struct tinyalsa_audio_device *device;
ALOGD("%s(%p, %f)++", __func__, dev, volume);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
pthread_mutex_lock(&device->lock);
tinyalsa_mixer_set_master_volume(device->mixer, volume);
pthread_mutex_unlock(&device->lock);
ALOGD("%s(%p, %f)--", __func__, dev, volume);
return 0;
}
static int audio_hw_set_mode(struct audio_hw_device *dev, int mode)
{
struct tinyalsa_audio_ril_interface *ril_interface;
struct tinyalsa_audio_device *device;
audio_devices_t device_modem;
int rc;
ALOGD("%s(%p, %d)++", __func__, dev, mode);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(mode != device->mode) {
pthread_mutex_lock(&device->lock);
if(mode == AUDIO_MODE_IN_CALL) {
tinyalsa_mixer_set_modem_state(device->mixer, 1);
if(device->stream_out != NULL)
device_modem = device->stream_out->device_current;
else
device_modem = AUDIO_DEVICE_OUT_EARPIECE;
tinyalsa_mixer_set_device(device->mixer, device_modem);
#ifdef YAMAHA_MC1N2_AUDIO
rc = yamaha_mc1n2_audio_modem_start(device->mc1n2_pdata);
if(rc < 0) {
ALOGE("Failed to set Yamaha-MC1N2-Audio route");
}
#endif
rc = audio_ril_interface_open((struct audio_hw_device *) device, device_modem, &ril_interface);
if(rc < 0 || ril_interface == NULL) {
ALOGE("Failed to open RIL interface");
device->ril_interface = NULL;
} else {
device->ril_interface = ril_interface;
//Only enable dualmic for earpiece.
if(device_modem == AUDIO_DEVICE_OUT_EARPIECE)
audio_ril_interface_set_twomic(ril_interface,TWO_MIC_SOLUTION_ON);
if(device->voice_volume)
audio_ril_interface_set_voice_volume(ril_interface, device_modem, device->voice_volume);
}
} else if(device->mode == AUDIO_MODE_IN_CALL) {
tinyalsa_mixer_set_modem_state(device->mixer, 0);
/*
* Should be safe to ALWAYS disable it on exit
* But we should instrument secril-client to be sure
* when this is/isn't controlled - FIXME
*/
if(device->ril_interface != NULL) {
audio_ril_interface_set_twomic(device->ril_interface,TWO_MIC_SOLUTION_OFF);
}
#ifdef YAMAHA_MC1N2_AUDIO
rc = yamaha_mc1n2_audio_modem_stop(device->mc1n2_pdata);
if(rc < 0) {
ALOGE("Failed to set Yamaha-MC1N2-Audio route");
}
#endif
if(device->ril_interface != NULL) {
audio_ril_interface_close((struct audio_hw_device *) device, device->ril_interface);
}
}
device->mode = mode;
pthread_mutex_unlock(&device->lock);
}
ALOGD("%s(%p, %d)--", __func__, dev, mode);
return 0;
}
static int audio_hw_set_mic_mute(struct audio_hw_device *dev, bool state)
{
struct tinyalsa_audio_device *device;
audio_devices_t device_modem;
ALOGD("%s(%p, %d)++", __func__, dev, state);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
if(device->mic_mute != state) {
pthread_mutex_lock(&device->lock);
if(device->mode == AUDIO_MODE_IN_CALL) {
if(device->ril_interface != NULL)
device_modem = device->ril_interface->device_current;
else if(device->stream_out != NULL)
device_modem = device->stream_out->device_current;
else
device_modem = AUDIO_DEVICE_OUT_EARPIECE;
tinyalsa_mixer_set_mic_mute(device->mixer,
device_modem, state);
if(device->ril_interface != NULL)
audio_ril_interface_set_mic_mute(device->ril_interface, state);
} else {
if(device->stream_in != NULL) {
tinyalsa_mixer_set_mic_mute(device->mixer,
device->stream_in->device_current, state);
}
}
device->mic_mute = state;
pthread_mutex_unlock(&device->lock);
}
ALOGD("%s(%p, %d)--", __func__, dev, state);
return 0;
}
static int audio_hw_get_mic_mute(const struct audio_hw_device *dev, bool *state)
{
struct tinyalsa_audio_device *device;
ALOGD("%s(%p, %p)", __func__, dev, state);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
*state = device->mic_mute;
return 0;
}
static int audio_hw_set_parameters(struct audio_hw_device *dev,
const char *kvpairs)
{
struct tinyalsa_audio_device *device;
struct str_parms *parms;
char value_string[32] = { 0 };
int value;
int rc;
ALOGD("%s(%p, %s)++", __func__, dev, kvpairs);
if(dev == NULL || kvpairs == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
parms = str_parms_create_str(kvpairs);
if(parms == NULL)
return -1;
rc = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value_string, sizeof(value_string));
if(rc < 0)
goto error_params;
value = atoi(value_string);
pthread_mutex_lock(&device->lock);
if(audio_is_output_device((audio_devices_t) value)) {
if(device->stream_out != NULL && device->stream_out->device_current != (audio_devices_t) value) {
pthread_mutex_lock(&device->stream_out->lock);
audio_out_set_route(device->stream_out, (audio_devices_t) value);
pthread_mutex_unlock(&device->stream_out->lock);
}
if(device->ril_interface != NULL && device->ril_interface->device_current != (audio_devices_t) value) {
audio_ril_interface_set_route(device->ril_interface, (audio_devices_t) value);
}
} else if(audio_is_input_device((audio_devices_t) value)) {
if(device->stream_in != NULL && device->stream_in->device_current != (audio_devices_t) value) {
pthread_mutex_lock(&device->stream_in->lock);
audio_in_set_route(device->stream_in, (audio_devices_t) value);
pthread_mutex_unlock(&device->stream_in->lock);
}
}
pthread_mutex_unlock(&device->lock);
str_parms_destroy(parms);
ALOGD("%s(%p, %s)--", __func__, dev, kvpairs);
return 0;
error_params:
str_parms_destroy(parms);
ALOGD("%s(%p, %s)-- (PARAMETER ERROR)", __func__, dev, kvpairs);
return -1;
}
static char *audio_hw_get_parameters(const struct audio_hw_device *dev,
const char *keys)
{
ALOGD("%s(%p, %s)", __func__, dev, keys);
return strdup("");
}
static size_t audio_hw_get_input_buffer_size(const struct audio_hw_device *dev,
const struct audio_config *config)
{
struct tinyalsa_audio_device *device;
struct tinyalsa_mixer_io_props *mixer_props;
size_t size;
int channel_count = popcount(config->channel_mask);
ALOGD("%s(%p, %d, %d, %d)++", __func__, dev, config->sample_rate, config->format, channel_count);
if(dev == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
mixer_props = tinyalsa_mixer_get_input_props(device->mixer);
if(mixer_props == NULL)
return -1;
// Default value
if(mixer_props->rate == 0)
mixer_props->rate = 44100;
size = (mixer_props->period_size * config->sample_rate) / mixer_props->rate;
size = ((size + 15) / 16) * 16;
size = size * channel_count * audio_bytes_per_sample(config->format);
ALOGD("%s(%p, %d, %d, %d)--", __func__, dev, config->sample_rate, config->format, channel_count);
return size;
}
static int audio_hw_dump(const audio_hw_device_t *device, int fd)
{
ALOGD("%s(%p, %d)", __func__, device, fd);
return 0;
}
/*
* Interface
*/
int audio_hw_close(hw_device_t *device)
{
struct tinyalsa_audio_device *tinyalsa_audio_device;
ALOGD("%s(%p)++", __func__, device);
if(device != NULL) {
tinyalsa_audio_device = (struct tinyalsa_audio_device *) device;
if(tinyalsa_audio_device->mixer != NULL) {
tinyalsa_mixer_close(tinyalsa_audio_device->mixer);
tinyalsa_audio_device->mixer = NULL;
}
#ifdef YAMAHA_MC1N2_AUDIO
if(tinyalsa_audio_device->mc1n2_pdata != NULL) {
yamaha_mc1n2_audio_stop(tinyalsa_audio_device->mc1n2_pdata);
tinyalsa_audio_device->mc1n2_pdata = NULL;
}
#endif
free(device);
}
ALOGD("%s(%p)--", __func__, device);
return 0;
}
int audio_hw_open(const hw_module_t *module, const char *name,
hw_device_t **device)
{
struct tinyalsa_audio_device *tinyalsa_audio_device = NULL;
struct tinyalsa_mixer *tinyalsa_mixer = NULL;
struct audio_hw_device *dev;
int rc;
ALOGD("%s(%p, %s, %p)++", __func__, module, name, device);
if(device == NULL)
return -EINVAL;
if(strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
return -EINVAL;
tinyalsa_audio_device = calloc(1, sizeof(struct tinyalsa_audio_device));
if(tinyalsa_audio_device == NULL)
return -ENOMEM;
dev = &(tinyalsa_audio_device->device);
dev->common.tag = HARDWARE_DEVICE_TAG;
dev->common.version = AUDIO_DEVICE_API_VERSION_2_0;
dev->common.module = (struct hw_module_t *) module;
dev->common.close = audio_hw_close;
dev->init_check = audio_hw_init_check;
dev->set_voice_volume = audio_hw_set_voice_volume;
dev->set_master_volume = audio_hw_set_master_volume;
dev->set_mode = audio_hw_set_mode;
dev->set_mic_mute = audio_hw_set_mic_mute;
dev->get_mic_mute = audio_hw_get_mic_mute;
dev->set_parameters = audio_hw_set_parameters;
dev->get_parameters = audio_hw_get_parameters;
dev->get_input_buffer_size = audio_hw_get_input_buffer_size;
dev->open_output_stream = audio_hw_open_output_stream;
dev->close_output_stream = audio_hw_close_output_stream;
dev->open_input_stream = audio_hw_open_input_stream;
dev->close_input_stream = audio_hw_close_input_stream;
dev->dump = audio_hw_dump;
#ifdef YAMAHA_MC1N2_AUDIO
rc = yamaha_mc1n2_audio_start(&tinyalsa_audio_device->mc1n2_pdata,
YAMAHA_MC1N2_AUDIO_DEVICE);
if(rc < 0) {
ALOGE("Failed to open Yamaha-MC1N2-Audio");
goto error_device;
}
rc = yamaha_mc1n2_audio_init(tinyalsa_audio_device->mc1n2_pdata);
if(rc < 0) {
ALOGE("Failed to init Yamaha-MC1N2-Audio");
}
#endif
rc = tinyalsa_mixer_open(&tinyalsa_mixer, TINYALSA_MIXER_CONFIG_FILE);
if(rc < 0 || tinyalsa_mixer == NULL) {
ALOGE("Failed to open mixer!");
goto error_device;
}
tinyalsa_audio_device->mixer = tinyalsa_mixer;
*device = &(dev->common);
ALOGD("%s(%p, %s, %p)--", __func__, module, name, device);
return 0;
error_device:
*device = NULL;
free(tinyalsa_audio_device);
ALOGD("%s(%p, %s, %p)-- (DEVICE ERROR)", __func__, module, name, device);
return -1;
}
struct hw_module_methods_t audio_hw_module_methods = {
.open = audio_hw_open,
};
struct audio_module HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.module_api_version = AUDIO_MODULE_API_VERSION_0_1,
.hal_api_version = HARDWARE_HAL_API_VERSION,
.id = AUDIO_HARDWARE_MODULE_ID,
.name = "TinyALSA-Audio",
.author = "Paul Kocialkowski",
.methods = &audio_hw_module_methods,
},
};