554 lines
13 KiB
C++
554 lines
13 KiB
C++
/*
|
|
* \brief Audio driver BSD API emulation
|
|
* \author Josef Soentgen
|
|
* \date 2014-11-09
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2014-2016 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <audio_out_session/audio_out_session.h>
|
|
#include <audio_in_session/audio_in_session.h>
|
|
#include <base/env.h>
|
|
#include <base/log.h>
|
|
#include <os/reporter.h>
|
|
#include <util/xml_node.h>
|
|
|
|
/* local includes */
|
|
#include <audio/audio.h>
|
|
#include <bsd.h>
|
|
#include <bsd_emul.h>
|
|
|
|
#include <extern_c_begin.h>
|
|
# include <sys/device.h>
|
|
# include <sys/audioio.h>
|
|
#include <extern_c_end.h>
|
|
|
|
|
|
extern struct cfdriver audio_cd;
|
|
|
|
static dev_t const adev = 0x80; /* audio0 (minor nr 128) */
|
|
static dev_t const mdev = 0x10; /* mixer0 (minor nr 16) */
|
|
|
|
static bool adev_usuable = false;
|
|
|
|
|
|
static bool drv_loaded()
|
|
{
|
|
/*
|
|
* The condition is true when at least one PCI device where a
|
|
* driver is available for was found by the autoconf mechanisum
|
|
* (see bsd_emul.c).
|
|
*/
|
|
return audio_cd.cd_ndevs > 0 ? true : false;
|
|
}
|
|
|
|
|
|
/******************************
|
|
** Dump audio configuration **
|
|
******************************/
|
|
|
|
#define DUMP_INFO(field) \
|
|
Genode::log("--- " #field " information ---"); \
|
|
Genode::log("sample_rate: ", (unsigned)ai.field.sample_rate); \
|
|
Genode::log("channels: ", (unsigned)ai.field.channels); \
|
|
Genode::log("precision: ", (unsigned)ai.field.precision); \
|
|
Genode::log("bps: ", (unsigned)ai.field.bps); \
|
|
Genode::log("encoding: ", (unsigned)ai.field.encoding); \
|
|
Genode::log("buffer_size: ", (unsigned)ai.field.buffer_size); \
|
|
Genode::log("block_size: ", (unsigned)ai.field.block_size); \
|
|
Genode::log("samples: ", (unsigned)ai.field.samples); \
|
|
Genode::log("pause: ", (unsigned)ai.field.pause); \
|
|
Genode::log("active: ", (unsigned)ai.field.active)
|
|
|
|
|
|
static void dump_pinfo()
|
|
{
|
|
struct audio_info ai;
|
|
if (audioioctl(adev, AUDIO_GETINFO, (char*)&ai, 0, 0)) {
|
|
Genode::error("could not gather play information");
|
|
return;
|
|
}
|
|
|
|
DUMP_INFO(play);
|
|
}
|
|
|
|
|
|
static void dump_rinfo()
|
|
{
|
|
struct audio_info ai;
|
|
if (audioioctl(adev, AUDIO_GETINFO, (char*)&ai, 0, 0)) {
|
|
Genode::error("could not gather play information");
|
|
return;
|
|
}
|
|
|
|
DUMP_INFO(record);
|
|
}
|
|
|
|
|
|
/*************************
|
|
** Mixer configuration **
|
|
*************************/
|
|
|
|
struct Mixer
|
|
{
|
|
mixer_devinfo_t *info;
|
|
unsigned num;
|
|
};
|
|
|
|
|
|
static Mixer mixer;
|
|
|
|
|
|
static unsigned count_mixer()
|
|
{
|
|
mixer_devinfo_t info;
|
|
for (int i = 0; ; i++) {
|
|
info.index = i;
|
|
if (audioioctl(mdev, AUDIO_MIXER_DEVINFO, (char*)&info, 0, 0))
|
|
return i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static mixer_devinfo_t *alloc_mixer(unsigned num)
|
|
{
|
|
return (mixer_devinfo_t*)
|
|
mallocarray(num, sizeof(mixer_devinfo_t), 0, M_ZERO);
|
|
}
|
|
|
|
|
|
static bool query_mixer(Mixer &mixer)
|
|
{
|
|
for (unsigned i = 0; i < mixer.num; i++) {
|
|
mixer.info[i].index = i;
|
|
if (audioioctl(mdev, AUDIO_MIXER_DEVINFO, (char*)&mixer.info[i], 0, 0))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static inline int level(char const *value)
|
|
{
|
|
unsigned long res = 0;
|
|
Genode::ascii_to(value, res);
|
|
return res > AUDIO_MAX_GAIN ? AUDIO_MAX_GAIN : res;
|
|
}
|
|
|
|
|
|
static bool set_mixer_value(Mixer &mixer, char const * const field,
|
|
char const * const value)
|
|
{
|
|
char buffer[64];
|
|
|
|
for (unsigned i = 0; i < mixer.num; i++) {
|
|
mixer_devinfo_t &info = mixer.info[i];
|
|
|
|
if (info.type == AUDIO_MIXER_CLASS)
|
|
continue;
|
|
|
|
unsigned mixer_class = info.mixer_class;
|
|
char const * const class_name = mixer.info[mixer_class].label.name;
|
|
char const * const name = info.label.name;
|
|
|
|
Genode::snprintf(buffer, sizeof(buffer), "%s.%s", class_name, name);
|
|
if (Genode::strcmp(field, buffer) != 0)
|
|
continue;
|
|
|
|
mixer_ctrl_t ctrl;
|
|
ctrl.dev = info.index;
|
|
ctrl.type = info.type;
|
|
ctrl.un.value.num_channels = 2;
|
|
|
|
if (audioioctl(mdev, AUDIO_MIXER_READ, (char*)&ctrl, 0, 0)) {
|
|
ctrl.un.value.num_channels = 1;
|
|
if (audioioctl(mdev, AUDIO_MIXER_READ, (char*)&ctrl, 0, 0)) {
|
|
Genode::error("could not read mixer ", ctrl.dev);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int oldv = -1;
|
|
int newv = 0;
|
|
switch (ctrl.type) {
|
|
case AUDIO_MIXER_ENUM:
|
|
{
|
|
for (int i = 0; i < info.un.e.num_mem; i++)
|
|
if (Genode::strcmp(value, info.un.e.member[i].label.name) == 0) {
|
|
oldv = ctrl.un.ord;
|
|
newv = info.un.e.member[i].ord;
|
|
|
|
ctrl.un.ord = newv;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case AUDIO_MIXER_SET:
|
|
{
|
|
for (int i = 0; i < info.un.s.num_mem; i++) {
|
|
if (Genode::strcmp(value, info.un.e.member[i].label.name) == 0) {
|
|
oldv= ctrl.un.mask;
|
|
newv |= info.un.s.member[i].mask;
|
|
|
|
ctrl.un.mask = newv;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case AUDIO_MIXER_VALUE:
|
|
{
|
|
oldv = ctrl.un.value.level[0];
|
|
newv = level(value);
|
|
ctrl.un.value.level[0] = newv;
|
|
|
|
if (ctrl.un.value.num_channels == 2)
|
|
ctrl.un.value.level[1] = newv;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (oldv == -1)
|
|
break;
|
|
|
|
if (audioioctl(mdev, AUDIO_MIXER_WRITE, (char*)&ctrl, FWRITE, 0)) {
|
|
Genode::error("could not set ", field, " from ", oldv, " to ", newv);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
static char const *get_mixer_value(mixer_devinfo_t *info)
|
|
{
|
|
static char buffer[128];
|
|
|
|
mixer_ctrl_t ctrl;
|
|
ctrl.dev = info->index;
|
|
ctrl.type = info->type;
|
|
ctrl.un.value.num_channels = 2;
|
|
|
|
if (audioioctl(mdev, AUDIO_MIXER_READ, (char*)&ctrl, 0, 0)) {
|
|
ctrl.un.value.num_channels = 1;
|
|
if (audioioctl(mdev, AUDIO_MIXER_READ, (char*)&ctrl, 0, 0)) {
|
|
Genode::error("could not read mixer ", ctrl.dev);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
switch (ctrl.type) {
|
|
case AUDIO_MIXER_ENUM:
|
|
{
|
|
for (int i = 0; i < info->un.e.num_mem; i++)
|
|
if (ctrl.un.ord == info->un.e.member[i].ord) {
|
|
Genode::snprintf(buffer, sizeof(buffer),
|
|
"%s", info->un.e.member[i].label.name);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case AUDIO_MIXER_SET:
|
|
{
|
|
char *p = buffer;
|
|
Genode::size_t n = 0;
|
|
for (int i = 0; i < info->un.s.num_mem; i++)
|
|
if (ctrl.un.mask & info->un.s.member[i].mask)
|
|
n += Genode::snprintf(p + n, sizeof(buffer) - n,
|
|
"%s%s", n ? "," : "",
|
|
info->un.s.member[i].label.name);
|
|
break;
|
|
}
|
|
case AUDIO_MIXER_VALUE:
|
|
{
|
|
if (ctrl.un.value.num_channels == 2)
|
|
Genode::snprintf(buffer, sizeof(buffer), "%d,%d",
|
|
ctrl.un.value.level[0],
|
|
ctrl.un.value.level[1]);
|
|
else
|
|
Genode::snprintf(buffer, sizeof(buffer), "%d",
|
|
ctrl.un.value.level[0]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
|
|
static void dump_mixer(Mixer const &mixer)
|
|
{
|
|
Genode::log("--- mixer information ---");
|
|
for (unsigned i = 0; i < mixer.num; i++) {
|
|
if (mixer.info[i].type == AUDIO_MIXER_CLASS)
|
|
continue;
|
|
|
|
unsigned mixer_class = mixer.info[i].mixer_class;
|
|
char const * const class_name = mixer.info[mixer_class].label.name;
|
|
char const * const name = mixer.info[i].label.name;
|
|
char const * const value = get_mixer_value(&mixer.info[i]);
|
|
|
|
if (value)
|
|
Genode::log(class_name, ".", name, "=", value);
|
|
}
|
|
}
|
|
|
|
|
|
static Genode::Reporter mixer_reporter = { "mixer_state" };
|
|
|
|
|
|
static void report_mixer(Mixer const &mixer)
|
|
{
|
|
if (!mixer_reporter.is_enabled()) { return; }
|
|
|
|
try {
|
|
|
|
Genode::Reporter::Xml_generator xml(mixer_reporter, [&]() {
|
|
|
|
for (unsigned i = 0; i < mixer.num; i++) {
|
|
if (mixer.info[i].type == AUDIO_MIXER_CLASS)
|
|
continue;
|
|
|
|
unsigned mixer_class = mixer.info[i].mixer_class;
|
|
char const * const class_name = mixer.info[mixer_class].label.name;
|
|
char const * const name = mixer.info[i].label.name;
|
|
char const * const value = get_mixer_value(&mixer.info[i]);
|
|
|
|
if (value) {
|
|
xml.node("mixer", [&]() {
|
|
char tmp[64];
|
|
Genode::snprintf(tmp, sizeof(tmp), "%s.%s",
|
|
class_name, name);
|
|
|
|
xml.attribute("field", tmp);
|
|
xml.attribute("value", value);
|
|
});
|
|
}
|
|
}
|
|
});
|
|
} catch (...) { Genode::warning("Could not report mixer state"); }
|
|
}
|
|
|
|
|
|
/******************
|
|
** Audio device **
|
|
******************/
|
|
|
|
static bool open_audio_device(dev_t dev)
|
|
{
|
|
if (!drv_loaded())
|
|
return false;
|
|
|
|
int err = audioopen(dev, FWRITE|FREAD, 0 /* ifmt */, 0 /* proc */);
|
|
if (err)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static void parse_config(Mixer &mixer, Genode::Xml_node config)
|
|
{
|
|
using namespace Genode;
|
|
|
|
bool const v = config.attribute_value<bool>("report_mixer", false);
|
|
mixer_reporter.enabled(v);
|
|
|
|
config.for_each_sub_node("mixer", [&] (Xml_node node) {
|
|
char field[32];
|
|
char value[16];
|
|
try {
|
|
node.attribute("field").value(field, sizeof(field));
|
|
node.attribute("value").value(value, sizeof(value));
|
|
|
|
set_mixer_value(mixer, field, value);
|
|
} catch (Xml_attribute::Nonexistent_attribute) { }
|
|
});
|
|
}
|
|
|
|
|
|
static bool configure_audio_device(dev_t dev, Genode::Xml_node config)
|
|
{
|
|
struct audio_info ai;
|
|
|
|
int err = audioioctl(adev, AUDIO_GETINFO, (char*)&ai, 0, 0);
|
|
if (err)
|
|
return false;
|
|
|
|
using namespace Audio;
|
|
|
|
/* configure the device according to our Audio_out session settings */
|
|
ai.play.sample_rate = Audio_out::SAMPLE_RATE;
|
|
ai.play.channels = Audio_out::MAX_CHANNELS;
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.play.block_size = Audio_out::MAX_CHANNELS * sizeof(short) * Audio_out::PERIOD;
|
|
|
|
/* Configure the device according to our Audio_in session settings
|
|
*
|
|
* We use Audio_out::MAX_CHANNELS here because the backend provides us
|
|
* with two channels that we will mix to one in the front end for now.
|
|
*/
|
|
ai.record.sample_rate = Audio_in::SAMPLE_RATE;
|
|
ai.record.channels = Audio_out::MAX_CHANNELS;
|
|
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.record.block_size = Audio_out::MAX_CHANNELS * sizeof(short) * Audio_in::PERIOD;
|
|
|
|
err = audioioctl(adev, AUDIO_SETINFO, (char*)&ai, 0, 0);
|
|
if (err)
|
|
return false;
|
|
|
|
int fullduplex = 1;
|
|
err = audioioctl(adev, AUDIO_SETFD, (char*)&fullduplex, 0, 0);
|
|
if (err)
|
|
return false;
|
|
|
|
/* query mixer information */
|
|
mixer.num = count_mixer();
|
|
mixer.info = alloc_mixer(mixer.num);
|
|
if (!mixer.info || !query_mixer(mixer))
|
|
return false;
|
|
|
|
bool const verbose = config.attribute_value<bool>("verbose", false);
|
|
|
|
if (verbose) dump_pinfo();
|
|
if (verbose) dump_rinfo();
|
|
if (verbose) dump_mixer(mixer);
|
|
|
|
parse_config(mixer, config);
|
|
report_mixer(mixer);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
namespace {
|
|
|
|
struct Task_args
|
|
{
|
|
Genode::Env &env;
|
|
Genode::Allocator &alloc;
|
|
Genode::Xml_node config;
|
|
|
|
Task_args(Genode::Env &env, Genode::Allocator &alloc,
|
|
Genode::Xml_node config)
|
|
: env(env), alloc(alloc), config(config) { }
|
|
};
|
|
}
|
|
|
|
|
|
static void run_bsd(void *p)
|
|
{
|
|
Task_args *args = static_cast<Task_args*>(p);
|
|
|
|
if (!Bsd::probe_drivers(args->env, args->alloc)) {
|
|
Genode::error("no supported sound card found");
|
|
Genode::sleep_forever();
|
|
}
|
|
|
|
if (!open_audio_device(adev)) {
|
|
Genode::error("could not initialize sound card");
|
|
Genode::sleep_forever();
|
|
}
|
|
|
|
adev_usuable = configure_audio_device(adev, args->config);
|
|
|
|
while (true) {
|
|
Bsd::scheduler().current()->block_and_schedule();
|
|
}
|
|
}
|
|
|
|
|
|
/***************************
|
|
** Notification handling **
|
|
***************************/
|
|
|
|
static Genode::Signal_context_capability _play_sigh;
|
|
static Genode::Signal_context_capability _record_sigh;
|
|
|
|
|
|
/*
|
|
* These functions are directly called by the audio
|
|
* backend in case an play/record interrupt occures
|
|
* and are used to notify our driver frontend.
|
|
*/
|
|
|
|
extern "C" void notify_play()
|
|
{
|
|
if (_play_sigh.valid())
|
|
Genode::Signal_transmitter(_play_sigh).submit();
|
|
}
|
|
|
|
|
|
extern "C" void notify_record()
|
|
{
|
|
if (_record_sigh.valid())
|
|
Genode::Signal_transmitter(_record_sigh).submit();
|
|
}
|
|
|
|
|
|
/*****************************
|
|
** private Audio namespace **
|
|
*****************************/
|
|
|
|
void Audio::update_config(Genode::Xml_node config)
|
|
{
|
|
if (mixer.info == nullptr) { return; }
|
|
|
|
parse_config(mixer, config);
|
|
report_mixer(mixer);
|
|
}
|
|
|
|
|
|
void Audio::init_driver(Genode::Env &env, Genode::Allocator &alloc,
|
|
Genode::Xml_node config)
|
|
{
|
|
Bsd::mem_init(env, alloc);
|
|
Bsd::irq_init(env.ep(), alloc);
|
|
Bsd::timer_init(env.ep());
|
|
|
|
static Task_args args(env, alloc, config);
|
|
|
|
static Bsd::Task task_bsd(run_bsd, &args, "bsd",
|
|
Bsd::Task::PRIORITY_0, Bsd::scheduler(),
|
|
2048 * sizeof(Genode::addr_t));
|
|
Bsd::scheduler().schedule();
|
|
}
|
|
|
|
|
|
bool Audio::driver_active() { return drv_loaded() && adev_usuable; }
|
|
|
|
|
|
void Audio::play_sigh(Genode::Signal_context_capability sigh) {
|
|
_play_sigh = sigh; }
|
|
|
|
|
|
void Audio::record_sigh(Genode::Signal_context_capability sigh) {
|
|
_record_sigh = sigh; }
|
|
|
|
|
|
int Audio::play(short *data, Genode::size_t size)
|
|
{
|
|
struct uio uio = { 0, size, UIO_READ, data, size };
|
|
return audiowrite(adev, &uio, IO_NDELAY);
|
|
}
|
|
|
|
|
|
int Audio::record(short *data, Genode::size_t size)
|
|
{
|
|
struct uio uio = { 0, size, UIO_WRITE, data, size };
|
|
return audioread(adev, &uio, IO_NDELAY);
|
|
}
|