satip-axe/kernel/sound/stm/conv.c

1124 lines
26 KiB
C
Raw Normal View History

/*
* STMicroelectronics System-on-Chips' generic converters infrastructure
*
* Copyright (c) 2005-2007 STMicroelectronics Limited
*
* Author: Pawel Moll <pawel.moll@st.com>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <linux/init.h>
#include <linux/list.h>
#include <linux/device.h>
#include <sound/control.h>
#include "common.h"
extern int snd_stm_debug_level;
/*
* Converters infrastructure description
*/
struct snd_stm_conv_group;
struct snd_stm_conv_source;
struct snd_stm_conv_converter {
struct list_head list;
struct snd_stm_conv_group *group;
struct snd_stm_conv_ops *ops;
void *priv;
int source_channel_from;
int source_channel_to;
int enabled;
int muted_by_source;
int muted_by_user;
spinlock_t status_lock; /* Protects enabled and muted_by_* */
struct snd_kcontrol *ctl_mute;
snd_stm_magic_field;
};
struct snd_stm_conv_group {
struct list_head list;
struct snd_stm_conv_source *source;
struct list_head converters;
int enabled;
int muted_by_source;
snd_stm_magic_field;
char name[1]; /* "Expandable" */
};
#define SND_STM_BUS_ID_SIZE 30
struct snd_stm_conv_source {
struct list_head list;
struct bus_type *bus;
char bus_id[SND_STM_BUS_ID_SIZE];
int channels_num;
struct snd_card *card;
int card_device;
struct snd_stm_conv_group *group_selected;
struct snd_stm_conv_group *group_active;
struct list_head groups;
struct snd_kcontrol *ctl_route;
snd_stm_magic_field;
};
static LIST_HEAD(snd_stm_conv_sources); /* Sources list */
static DEFINE_MUTEX(snd_stm_conv_mutex); /* Big Converters Structure Lock ;-) */
/*
* Converter control interface implementation
*/
const char *snd_stm_conv_get_name(struct snd_stm_conv_group *group)
{
snd_stm_printd(1, "snd_stm_conv_get_name(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
return group->name;
}
unsigned int snd_stm_conv_get_format(struct snd_stm_conv_group *group)
{
unsigned int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_get_format(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
/* All configured converters must share the same input format -
* get first of them and check the rest; if any of converters
* has different opinion than others - raise an error! */
list_for_each_entry(converter, &group->converters, list) {
unsigned int format = converter->ops->get_format(
converter->priv);
if (result == 0) {
result = format;
} else if (format != result) {
snd_stm_printe("Wrong format (0x%x) for converter %p"
" (the rest says 0x%x)!\n", format,
converter, result);
snd_BUG();
}
}
return result;
}
int snd_stm_conv_get_oversampling(struct snd_stm_conv_group *group)
{
int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_get_oversampling(group=%p)\n",
group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
/* All configured converters must share the same oversampling value -
* get first of them and check the rest; if any of converters
* has different opinion than others - raise an error! */
list_for_each_entry(converter, &group->converters, list) {
int oversampling;
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
oversampling = converter->ops->get_oversampling(
converter->priv);
if (result == 0) {
result = oversampling;
} else if (oversampling != result) {
snd_stm_printe("Wrong oversampling value (%d) for "
"converter %p (the rest says %d)!\n",
oversampling, converter, result);
snd_BUG();
}
}
return result;
}
int snd_stm_conv_enable(struct snd_stm_conv_group *group,
int channel_from, int channel_to)
{
int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_enable(group=%p, channel_from=%d, "
"channel_to=%d)\n", group, channel_from, channel_to);
BUG_ON(channel_to < channel_from);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
BUG_ON(group->enabled);
group->enabled = 1;
list_for_each_entry(converter, &group->converters, list) {
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
BUG_ON(converter->enabled);
spin_lock(&converter->status_lock);
if ((channel_from <= converter->source_channel_from &&
converter->source_channel_from <= channel_to) ||
(channel_from <= converter->source_channel_to &&
converter->source_channel_to <= channel_to)) {
converter->enabled = 1;
if (converter->ops->set_enabled) {
int done = converter->ops->set_enabled(1,
converter->priv);
if (done != 0) {
snd_stm_printe("Failed to enable "
"converter %p!\n",
converter);
result = done;
}
}
}
spin_unlock(&converter->status_lock);
}
return result;
}
int snd_stm_conv_disable(struct snd_stm_conv_group *group)
{
int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_disable(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
BUG_ON(!group->enabled);
group->enabled = 0;
list_for_each_entry(converter, &group->converters, list) {
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
spin_lock(&converter->status_lock);
if (converter->enabled) {
converter->enabled = 0;
if (converter->ops->set_enabled) {
int done = converter->ops->set_enabled(0,
converter->priv);
if (done != 0) {
snd_stm_printe("Failed to disable "
"converter %p!\n",
converter);
result = done;
}
}
}
spin_unlock(&converter->status_lock);
}
return result;
}
int snd_stm_conv_mute(struct snd_stm_conv_group *group)
{
int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_mute(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
BUG_ON(!group->enabled);
BUG_ON(group->muted_by_source);
group->muted_by_source = 1;
list_for_each_entry(converter, &group->converters, list) {
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
spin_lock(&converter->status_lock);
if (converter->enabled) {
converter->muted_by_source = 1;
if (converter->ops->set_muted &&
!converter->muted_by_user) {
int done = converter->ops->set_muted(1,
converter->priv);
if (done != 0) {
snd_stm_printe("Failed to mute "
"converter %p!\n",
converter);
result = done;
}
}
}
spin_unlock(&converter->status_lock);
}
return result;
}
int snd_stm_conv_unmute(struct snd_stm_conv_group *group)
{
int result = 0;
struct snd_stm_conv_converter *converter;
snd_stm_printd(1, "snd_stm_conv_unmute(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
BUG_ON(!group->enabled);
BUG_ON(!group->muted_by_source);
group->muted_by_source = 0;
list_for_each_entry(converter, &group->converters, list) {
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
spin_lock(&converter->status_lock);
if (converter->enabled) {
converter->muted_by_source = 0;
if (converter->ops->set_muted &&
!converter->muted_by_user) {
int done = converter->ops->set_muted(0,
converter->priv);
if (done != 0) {
snd_stm_printe("Failed to unmute "
"converter %p!\n",
converter);
result = done;
}
}
}
spin_unlock(&converter->status_lock);
}
return result;
}
/*
* ALSA controls
*/
static int snd_stm_conv_ctl_mute_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_stm_conv_converter *converter = snd_kcontrol_chip(kcontrol);
snd_stm_printd(1, "snd_stm_conv_ctl_mute_get(kcontrol=0x%p,"
" ucontrol=0x%p)\n", kcontrol, ucontrol);
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
spin_lock(&converter->status_lock);
ucontrol->value.integer.value[0] = !converter->muted_by_user;
spin_unlock(&converter->status_lock);
return 0;
}
static int snd_stm_conv_ctl_mute_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_stm_conv_converter *converter = snd_kcontrol_chip(kcontrol);
int changed = 0;
snd_stm_printd(1, "snd_stm_conv_ctl_mute_put(kcontrol=0x%p,"
" ucontrol=0x%p)\n", kcontrol, ucontrol);
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
BUG_ON(!converter->ops->set_muted);
spin_lock(&converter->status_lock);
if (ucontrol->value.integer.value[0] !=
!converter->muted_by_user) {
changed = 1;
converter->muted_by_user =
!ucontrol->value.integer.value[0];
if (converter->enabled &&
converter->muted_by_user &&
!converter->muted_by_source)
converter->ops->set_muted(1, converter->priv);
else if (converter->enabled &&
!converter->muted_by_user &&
!converter->muted_by_source)
converter->ops->set_muted(0, converter->priv);
}
spin_unlock(&converter->status_lock);
return changed;
}
static struct snd_kcontrol_new snd_stm_conv_ctl_mute = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Master Playback Switch",
.info = snd_stm_ctl_boolean_info,
.get = snd_stm_conv_ctl_mute_get,
.put = snd_stm_conv_ctl_mute_put,
};
static int snd_stm_conv_ctl_mute_add(struct snd_stm_conv_converter *converter)
{
int result;
struct snd_stm_conv_source *source;
struct snd_kcontrol *ctl_mute;
snd_stm_printd(1, "snd_stm_conv_ctl_mute_add(converter=%p)\n",
converter);
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
source = converter->group->source;
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
snd_stm_conv_ctl_mute.device = source->card_device;
ctl_mute = snd_ctl_new1(&snd_stm_conv_ctl_mute, converter);
result = snd_ctl_add(source->card, ctl_mute);
if (result >= 0) {
/* We will have to manually dispose "hot-plugged" controls...
* ("normal" ones will be disposed during snd_card_free) */
if (snd_stm_card_is_registered())
converter->ctl_mute = ctl_mute;
snd_stm_conv_ctl_mute.index++;
} else {
snd_stm_printe("Error %d while adding mute ALSA control!\n",
result);
}
return result;
}
static int snd_stm_conv_ctl_route_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
struct snd_stm_conv_source *source = snd_kcontrol_chip(kcontrol);
struct snd_stm_conv_group *group;
int item = 0;
snd_stm_printd(1, "snd_stm_conv_ctl_route_info(kcontrol=0x%p,"
" uinfo=0x%p)\n", kcontrol, uinfo);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
mutex_lock(&snd_stm_conv_mutex);
list_for_each_entry(group, &source->groups, list) {
if (list_is_last(&group->list, &source->groups) &&
uinfo->value.enumerated.item > item)
uinfo->value.enumerated.item = item;
if (item == uinfo->value.enumerated.item)
snprintf(uinfo->value.enumerated.name, 64, "%s",
group->name);
item++;
};
uinfo->value.enumerated.items = item;
mutex_unlock(&snd_stm_conv_mutex);
return 0;
}
static int snd_stm_conv_ctl_route_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_stm_conv_source *source = snd_kcontrol_chip(kcontrol);
struct snd_stm_conv_group *group;
int item = 0;
snd_stm_printd(1, "snd_stm_conv_ctl_route_get(kcontrol=0x%p,"
" ucontrol=0x%p)\n", kcontrol, ucontrol);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
mutex_lock(&snd_stm_conv_mutex);
ucontrol->value.enumerated.item[0] = 0; /* First is default ;-) */
list_for_each_entry(group, &source->groups, list) {
if (group == source->group_selected) {
ucontrol->value.enumerated.item[0] = item;
break;
}
item++;
};
mutex_unlock(&snd_stm_conv_mutex);
return 0;
}
static int snd_stm_conv_ctl_route_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int changed = 0;
struct snd_stm_conv_source *source = snd_kcontrol_chip(kcontrol);
struct snd_stm_conv_group *group;
int item = 0;
snd_stm_printd(1, "snd_stm_conv_ctl_route_put(kcontrol=0x%p,"
" ucontrol=0x%p)\n", kcontrol, ucontrol);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
mutex_lock(&snd_stm_conv_mutex);
list_for_each_entry(group, &source->groups, list) {
if (item == ucontrol->value.enumerated.item[0]) {
if (group != source->group_selected) {
changed = 1;
source->group_selected = group;
}
break;
}
item++;
}
mutex_unlock(&snd_stm_conv_mutex);
return changed;
}
static struct snd_kcontrol_new snd_stm_conv_ctl_route = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Playback Route",
.info = snd_stm_conv_ctl_route_info,
.get = snd_stm_conv_ctl_route_get,
.put = snd_stm_conv_ctl_route_put,
};
static int snd_stm_conv_ctl_route_add(struct snd_stm_conv_source *source)
{
struct snd_kcontrol *ctl_route;
int result;
snd_stm_printd(1, "snd_stm_conv_ctl_route_add(source=%p)\n", source);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
snd_stm_conv_ctl_route.device = source->card_device;
ctl_route = snd_ctl_new1(&snd_stm_conv_ctl_route, source);
result = snd_ctl_add(source->card, ctl_route);
if (result >= 0) {
/* We will have to manually dispose "hot-plugged"
* controls... ("normal" ones will be disposed
* during snd_card_free) */
if (snd_stm_card_is_registered())
source->ctl_route = ctl_route;
snd_stm_conv_ctl_route.index++;
} else {
snd_stm_printe("Error %d while adding route ALSA "
"control!\n", result);
}
return result;
}
/*
* Converters router implementation
*/
static inline int snd_stm_conv_more_than_one_entry(const struct list_head *head)
{
return !list_empty(head) && !list_is_last(head->next, head);
}
static struct snd_stm_conv_source *snd_stm_conv_get_source(
struct bus_type *bus, const char *bus_id)
{
struct snd_stm_conv_source *source;
snd_stm_printd(1, "snd_stm_conv_get_source(bus=%p, bus_id='%s')\n",
bus, bus_id);
BUG_ON(!bus);
BUG_ON(!bus_id);
mutex_lock(&snd_stm_conv_mutex);
list_for_each_entry(source, &snd_stm_conv_sources, list)
if (bus == source->bus && strcmp(bus_id, source->bus_id) == 0)
goto done; /* Already known source */
/* First time see... */
source = kzalloc(sizeof(*source), GFP_KERNEL);
if (!source) {
snd_stm_printe("Can't allocate memory for source!\n");
goto done;
}
snd_stm_magic_set(source);
source->bus = bus;
strlcpy(source->bus_id, bus_id, SND_STM_BUS_ID_SIZE);
INIT_LIST_HEAD(&source->groups);
list_add_tail(&source->list, &snd_stm_conv_sources);
done:
mutex_unlock(&snd_stm_conv_mutex);
return source;
}
struct snd_stm_conv_source *snd_stm_conv_register_source(struct bus_type *bus,
const char *bus_id, int channels_num,
struct snd_card *card, int card_device)
{
struct snd_stm_conv_source *source;
struct snd_stm_conv_group *group;
snd_stm_printd(1, "snd_stm_conv_register_source(bus=%p, bus_id='%s', "
"channels_num=%d, card=%p, card_device=%d)\n",
bus, bus_id, channels_num, card, card_device);
BUG_ON(!bus);
BUG_ON(!bus_id);
BUG_ON(channels_num <= 0);
BUG_ON(!card);
BUG_ON(card_device < 0);
source = snd_stm_conv_get_source(bus, bus_id);
if (!source) {
snd_stm_printe("Can't get source structure!\n");
return NULL;
}
BUG_ON(source->channels_num != 0);
BUG_ON(source->card);
source->channels_num = channels_num;
source->card = card;
source->card_device = card_device;
mutex_lock(&snd_stm_conv_mutex);
/* Add route ALSA control if needed */
if (snd_stm_conv_more_than_one_entry(&source->groups) &&
snd_stm_conv_ctl_route_add(source) != 0)
snd_stm_printe("Failed to add route ALSA control!\n");
/* Add mute ALSA controls for already registered converters */
list_for_each_entry(group, &source->groups, list) {
struct snd_stm_conv_converter *converter;
BUG_ON(!snd_stm_magic_valid(group));
list_for_each_entry(converter, &group->converters, list) {
BUG_ON(!snd_stm_magic_valid(converter));
if (converter->ops->set_muted &&
snd_stm_conv_ctl_mute_add(converter)
< 0)
snd_stm_printe("Failed to add mute "
"ALSA control!\n");
}
}
mutex_unlock(&snd_stm_conv_mutex);
return source;
}
int snd_stm_conv_unregister_source(struct snd_stm_conv_source *source)
{
snd_stm_printd(1, "snd_stm_conv_unregister_source(source=%p)\n",
source);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
mutex_lock(&snd_stm_conv_mutex);
list_del(&source->list);
source->channels_num = 0;
/* If there is no more registered converters... */
if (list_empty(&source->groups)) {
snd_stm_magic_clear(source);
kfree(source);
}
mutex_unlock(&snd_stm_conv_mutex);
return 0;
}
static struct snd_stm_conv_group *snd_stm_conv_get_group(
struct snd_stm_conv_source *source, const char *name)
{
struct snd_stm_conv_group *group;
snd_stm_printd(1, "snd_stm_conv_get_group(source=%p, name='%s')\n",
source, name);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
BUG_ON(!name);
/* Random memory fuse */
BUG_ON(strlen(name) > 1024);
mutex_lock(&snd_stm_conv_mutex);
list_for_each_entry(group, &source->groups, list)
if (strcmp(name, group->name) == 0)
goto done; /* Already known group */
/* First time see... */
group = kzalloc(sizeof(*group) + strlen(name), GFP_KERNEL);
if (!group) {
snd_stm_printe("Can't allocate memory for group!\n");
goto done;
}
snd_stm_magic_set(group);
INIT_LIST_HEAD(&group->converters);
strcpy(group->name, name);
group->source = source;
group->muted_by_source = 1;
if (!source->group_selected)
source->group_selected = group;
list_add_tail(&group->list, &source->groups);
/* If this is a second group attached to this source,
* and the source has been already registered, we need
* to add a route ALSA control... */
if (source->card && snd_stm_conv_more_than_one_entry(&source->groups))
snd_stm_conv_ctl_route_add(source);
done:
mutex_unlock(&snd_stm_conv_mutex);
return group;
}
static int snd_stm_conv_remove_group(struct snd_stm_conv_group *group)
{
struct snd_stm_conv_source *source;
snd_stm_printd(1, "snd_stm_conv_remove_group(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
source = group->source;
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
list_del(&group->list);
if (group == source->group_active)
snd_stm_printe("WARNING! Removing active converters group! "
"I hope you know what are you doing...\n");
/* Removing actually selected group? */
if (group == source->group_selected) {
if (list_empty(&source->groups)) {
/* This was the last group... */
source->group_selected = NULL;
} else {
/* If there is only one group left, the route control
* is not needed anymore */
if (!snd_stm_conv_more_than_one_entry(&source->groups)
&& source->ctl_route)
snd_ctl_remove(source->card, source->ctl_route);
/* The first group on list is considered default... */
source->group_selected = list_first_entry(
&source->groups,
struct snd_stm_conv_group, list);
}
}
snd_stm_magic_clear(group);
kfree(group);
/* Release the source resources, if not used anymore */
if (list_empty(&source->groups) && source->channels_num == 0) {
snd_stm_magic_clear(source);
kfree(source);
}
return 0;
}
struct snd_stm_conv_converter *snd_stm_conv_register_converter(
const char *group_name, struct snd_stm_conv_ops *ops,
void *priv,
struct bus_type *source_bus, const char *source_bus_id,
int source_channel_from, int source_channel_to, int *index)
{
static int number;
struct snd_stm_conv_converter *converter;
struct snd_stm_conv_group *group;
struct snd_stm_conv_source *source;
snd_stm_printd(1, "snd_stm_conv_register_converter(group='%s', ops=%p,"
" priv=%p, source_bus=%p, source_bus_id='%s', "
"source_channel_from=%d, source_channel_to=%d)\n",
group_name, ops, priv, source_bus, source_bus_id,
source_channel_from, source_channel_to);
BUG_ON(!group_name);
BUG_ON(!ops);
BUG_ON(!source_bus);
BUG_ON(!source_bus_id);
BUG_ON(source_channel_from < 0);
BUG_ON(source_channel_to < source_channel_from);
/* Create converter description */
converter = kzalloc(sizeof(*converter), GFP_KERNEL);
if (!converter) {
snd_stm_printe("Can't allocate memory for converter!\n");
goto error_kzalloc;
}
snd_stm_magic_set(converter);
converter->ops = ops;
converter->priv = priv;
converter->source_channel_from = source_channel_from;
converter->source_channel_to = source_channel_to;
converter->muted_by_source = 1;
spin_lock_init(&converter->status_lock);
/* And link it with the source */
source = snd_stm_conv_get_source(source_bus, source_bus_id);
if (!source) {
snd_stm_printe("Can't get source structure!\n");
goto error_get_source;
}
group = snd_stm_conv_get_group(source, group_name);
if (!group) {
snd_stm_printe("Can't get group structure!\n");
goto error_get_group;
}
if (source->group_active == group)
snd_stm_printe("WARNING! Adding a converter to an active "
"group!\n");
mutex_lock(&snd_stm_conv_mutex);
converter->group = group;
list_add_tail(&converter->list, &group->converters);
mutex_unlock(&snd_stm_conv_mutex);
/* Add mute ALSA control if muting is supported and source is known */
if (source->card && ops->set_muted &&
snd_stm_conv_ctl_mute_add(converter) < 0) {
snd_stm_printe("Failed to add mute ALSA control!\n");
goto error_add_ctl_mute;
}
number++;
if (index)
*index = number;
return converter;
error_add_ctl_mute:
error_get_group:
error_get_source:
list_del(&converter->list);
snd_stm_magic_clear(converter);
kfree(converter);
error_kzalloc:
return NULL;
}
EXPORT_SYMBOL(snd_stm_conv_register_converter);
int snd_stm_conv_unregister_converter(struct snd_stm_conv_converter *converter)
{
struct snd_stm_conv_group *group;
snd_stm_printd(1, "snd_stm_conv_unregister_converter(converter=%p)\n",
converter);
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
group = converter->group;
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
mutex_lock(&snd_stm_conv_mutex);
list_del(&converter->list);
if (converter->ctl_mute)
snd_ctl_remove(group->source->card, converter->ctl_mute);
snd_stm_magic_clear(converter);
kfree(converter);
if (list_empty(&group->converters))
snd_stm_conv_remove_group(group);
mutex_unlock(&snd_stm_conv_mutex);
return 0;
}
EXPORT_SYMBOL(snd_stm_conv_unregister_converter);
int snd_stm_conv_get_card_device(struct snd_stm_conv_converter *converter)
{
snd_stm_printd(1, "snd_stm_conv_get_card_device(converter=%p)\n",
converter);
BUG_ON(!converter);
BUG_ON(!snd_stm_magic_valid(converter));
return converter->group->source->card_device;
}
EXPORT_SYMBOL(snd_stm_conv_get_card_device);
struct snd_stm_conv_group *snd_stm_conv_request_group(
struct snd_stm_conv_source *source)
{
snd_stm_printd(1, "snd_stm_conv_request_group(source=%p)\n", source);
BUG_ON(!source);
BUG_ON(!snd_stm_magic_valid(source));
BUG_ON(source->group_active);
mutex_lock(&snd_stm_conv_mutex);
source->group_active = source->group_selected;
mutex_unlock(&snd_stm_conv_mutex);
return source->group_active;
}
int snd_stm_conv_release_group(struct snd_stm_conv_group *group)
{
snd_stm_printd(1, "snd_stm_conv_release_group(group=%p)\n", group);
BUG_ON(!group);
BUG_ON(!snd_stm_magic_valid(group));
BUG_ON(!group->source);
BUG_ON(!snd_stm_magic_valid(group->source));
BUG_ON(group != group->source->group_active);
mutex_lock(&snd_stm_conv_mutex);
group->source->group_active = NULL;
mutex_unlock(&snd_stm_conv_mutex);
return 0;
}
/*
* Converters information view
*/
static struct snd_info_entry *snd_stm_conv_proc_entry;
static void snd_stm_conv_info(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
struct snd_stm_conv_source *source;
snd_iprintf(buffer, "--- converters ---\n");
list_for_each_entry(source, &snd_stm_conv_sources, list) {
struct snd_stm_conv_group *group;
snd_iprintf(buffer, "- source %p:\n", source);
snd_iprintf(buffer, " bus=%p, bus_id='%s'\n",
source->bus, source->bus_id);
snd_iprintf(buffer, " channels_num=%d\n",
source->channels_num);
snd_iprintf(buffer, " card=%p, card_device=%d\n",
source->card, source->card_device);
list_for_each_entry(group, &source->groups, list) {
struct snd_stm_conv_converter *converter;
snd_iprintf(buffer, " - group %p:\n", group);
snd_iprintf(buffer, " name='%s'\n", group->name);
list_for_each_entry(converter, &group->converters,
list) {
snd_iprintf(buffer, " - converter %p:\n",
converter);
snd_iprintf(buffer, " source_channel_from"
"=%d, source_channel_to=%d\n",
converter->source_channel_from,
converter->source_channel_to);
snd_iprintf(buffer, " enabled=%d\n",
converter->enabled);
snd_iprintf(buffer, " muted_by_source=%d,"
" muted_by_user=%d\n",
converter->muted_by_source,
converter->muted_by_user);
}
}
}
snd_iprintf(buffer, "\n");
}
/*
* Initialization
*/
int __init snd_stm_conv_init(void)
{
/* Register converters information file in ALSA's procfs */
snd_stm_info_register(&snd_stm_conv_proc_entry, "converters",
snd_stm_conv_info, NULL);
return 0;
}
void snd_stm_conv_exit(void)
{
snd_stm_info_unregister(snd_stm_conv_proc_entry);
if (!list_empty(&snd_stm_conv_sources)) {
struct snd_stm_conv_source *source, *source_next;
snd_stm_printe("WARNING! There are some converters "
"infrastructure components left - "
"check your configuration!\n");
list_for_each_entry_safe(source, source_next,
&snd_stm_conv_sources, list) {
struct snd_stm_conv_group *group, *group_next;
list_for_each_entry_safe(group, group_next,
&source->groups, list) {
struct snd_stm_conv_converter *converter,
*converter_next;
list_for_each_entry_safe(converter,
converter_next,
&group->converters, list) {
list_del(&converter->list);
snd_stm_magic_clear(converter);
kfree(converter);
}
list_del(&group->list);
snd_stm_magic_clear(group);
kfree(group);
}
list_del(&source->list);
snd_stm_magic_clear(source);
kfree(source);
}
}
}