Skip to content
Permalink
Browse files
ALSA: control - add sysfs support to the LED trigger module 
Create SYSFS/devices/virtual/sound/ctl-led tree
(with SYSFS/class/sound/ctl-led symlink).

  speaker/
    +-- mode
    +-- state
  mic/
    +-- mode
    +-- state

Copy the idea from the HDA driver and allow to set the audio
LEDs based on the various modes:

- follow mute
- follow moute (inverted to follow mute)
- off
- on

Also, the actual LED state is exposed.

Signed-off-by: Jaroslav Kysela <perex@perex.cz>
  • Loading branch information
@perexg @intel-lab-lkp
perexg authored and intel-lab-lkp committed Feb 11, 2021
1 parent a7fc56d commit 050a577337d6c36f0ff05c450d004d7767045f20
Showing 1 changed file with 162 additions and 31 deletions.
193 sound/core/control_led.c
View file
@@ -17,16 +17,45 @@ MODULE_LICENSE("GPL");
#define MAX_LED (((SNDRV_CTL_ELEM_ACCESS_MIC_LED - SNDRV_CTL_ELEM_ACCESS_SPK_LED) \
>> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) + 1)

enum snd_ctl_led_mode {
MODE_FOLLOW_MUTE = 0,
MODE_FOLLOW_ROUTE,
MODE_OFF,
MODE_ON,
};

struct snd_ctl_led {
struct device dev;
struct list_head controls;
const char *name;
unsigned int group;
enum led_audio trigger_type;
enum snd_ctl_led_mode mode;
};

struct snd_ctl_led_ctl {
struct list_head list;
struct snd_card *card;
struct snd_kcontrol *kctl;
unsigned int index_offset;
};

static DEFINE_MUTEX(snd_ctl_led_mutex);
static struct list_head snd_ctl_led_controls[MAX_LED];
static bool snd_ctl_led_card_valid[SNDRV_CARDS];
static struct snd_ctl_led snd_ctl_leds[MAX_LED] = {
{
.name = "speaker",
.group = (SNDRV_CTL_ELEM_ACCESS_SPK_LED >> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1,
.trigger_type = LED_AUDIO_MUTE,
.mode = MODE_FOLLOW_MUTE,
},
{
.name = "mic",
.group = (SNDRV_CTL_ELEM_ACCESS_MIC_LED >> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1,
.trigger_type = LED_AUDIO_MICMUTE,
.mode = MODE_FOLLOW_MUTE,
},
};

#define UPDATE_ROUTE(route, cb) \
do { \
@@ -46,15 +75,15 @@ static inline unsigned int group_to_access(unsigned int group)
return (group + 1) << SNDRV_CTL_ELEM_ACCESS_LED_SHIFT;
}

struct list_head *snd_ctl_led_controls_by_access(unsigned int access)
struct snd_ctl_led *snd_ctl_led_get_by_access(unsigned int access)
{
unsigned int group = access_to_group(access);
if (group >= MAX_LED)
return NULL;
return &snd_ctl_led_controls[group];
return &snd_ctl_leds[group];
}

static int snd_ctl_led_get(struct snd_ctl_led *lctl)
static int snd_ctl_led_get(struct snd_ctl_led_ctl *lctl)
{
struct snd_kcontrol *kctl = lctl->kctl;
struct snd_ctl_elem_info info;
@@ -87,7 +116,7 @@ static int snd_ctl_led_get(struct snd_ctl_led *lctl)
return 0;
}

static int snd_ctl_led_get_lock(struct snd_ctl_led *lctl)
static int snd_ctl_led_get_lock(struct snd_ctl_led_ctl *lctl)
{
struct snd_card *card = lctl->card;
int route;
@@ -101,22 +130,14 @@ static int snd_ctl_led_get_lock(struct snd_ctl_led *lctl)
static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access,
struct snd_kcontrol *kctl, unsigned int ioff)
{
struct list_head *controls;
struct snd_ctl_led *lctl;
enum led_audio led_trigger_type;
struct snd_ctl_led *led;
struct snd_ctl_led_ctl *lctl;
int route;
bool found;

controls = snd_ctl_led_controls_by_access(access);
if (!controls)
led = snd_ctl_led_get_by_access(access);
if (!led)
return;
if (access == SNDRV_CTL_ELEM_ACCESS_SPK_LED) {
led_trigger_type = LED_AUDIO_MUTE;
} else if (access == SNDRV_CTL_ELEM_ACCESS_MIC_LED) {
led_trigger_type = LED_AUDIO_MICMUTE;
} else {
return;
}
route = -1;
found = false;
mutex_lock(&snd_ctl_led_mutex);
@@ -125,7 +146,7 @@ static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access,
mutex_unlock(&snd_ctl_led_mutex);
return;
}
list_for_each_entry(lctl, controls, list) {
list_for_each_entry(lctl, &led->controls, list) {
if (lctl->kctl == kctl && lctl->index_offset == ioff)
found = true;
UPDATE_ROUTE(route, snd_ctl_led_get_lock(lctl));
@@ -136,27 +157,33 @@ static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access,
lctl->card = card;
lctl->kctl = kctl;
lctl->index_offset = ioff;
list_add(&lctl->list, controls);
list_add(&lctl->list, &led->controls);
UPDATE_ROUTE(route, snd_ctl_led_get_lock(lctl));
}
}
mutex_unlock(&snd_ctl_led_mutex);
switch (led->mode) {
case MODE_OFF: route = 1; break;
case MODE_ON: route = 0; break;
case MODE_FOLLOW_ROUTE: if (route >= 0) route ^= 1; break;
case MODE_FOLLOW_MUTE: /* noop */ break;
}
if (route >= 0)
ledtrig_audio_set(led_trigger_type, route ? LED_OFF : LED_ON);
ledtrig_audio_set(led->trigger_type, route ? LED_OFF : LED_ON);
}

static void snd_ctl_led_remove(struct snd_kcontrol *kctl, unsigned int ioff)
{
struct snd_kcontrol_volatile *vd;
struct list_head *controls;
struct snd_ctl_led *lctl;
struct snd_ctl_led *led;
struct snd_ctl_led_ctl *lctl;

vd = &kctl->vd[ioff];
controls = snd_ctl_led_controls_by_access(vd->access);
if (!controls)
led = snd_ctl_led_get_by_access(vd->access);
if (!led)
return;
mutex_lock(&snd_ctl_led_mutex);
list_for_each_entry(lctl, controls, list)
list_for_each_entry(lctl, &led->controls, list)
if (lctl->kctl == kctl && lctl->index_offset == ioff) {
list_del(&lctl->list);
kfree(lctl);
@@ -193,13 +220,13 @@ static void snd_ctl_led_refresh(void)
static void snd_ctl_led_clean(struct snd_card *card)
{
unsigned int group;
struct list_head *controls;
struct snd_ctl_led *lctl;
struct snd_ctl_led *led;
struct snd_ctl_led_ctl *lctl;

for (group = 0; group < MAX_LED; group++) {
controls = &snd_ctl_led_controls[group];
led = &snd_ctl_leds[group];
repeat:
list_for_each_entry(lctl, controls, list)
list_for_each_entry(lctl, &led->controls, list)
if (!card || lctl->card == card) {
list_del(&lctl->list);
kfree(lctl);
@@ -246,6 +273,90 @@ void snd_ctl_led_hello(void)
}
EXPORT_SYMBOL(snd_ctl_led_hello);

/*
* sysfs
*/

static ssize_t show_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
const char *str;

switch (led->mode) {
case MODE_FOLLOW_MUTE: str = "follow-mute"; break;
case MODE_FOLLOW_ROUTE: str = "follow-route"; break;
case MODE_ON: str = "on"; break;
case MODE_OFF: str = "off"; break;
}
return sprintf(buf, "%s\n", str);
}

static ssize_t store_mode(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
char _buf[16];
size_t l = min(count, sizeof(_buf) - 1) + 1;
enum snd_ctl_led_mode mode;

memcpy(_buf, buf, l);
_buf[l] = '\0';
if (strstr(_buf, "mute"))
mode = MODE_FOLLOW_MUTE;
else if (strstr(_buf, "route"))
mode = MODE_FOLLOW_ROUTE;
else if (strncmp(_buf, "off", 3) == 0 || strncmp(_buf, "0", 1) == 0)
mode = MODE_OFF;
else if (strncmp(_buf, "on", 2) == 0 || strncmp(_buf, "1", 1) == 0)
mode = MODE_ON;
else
return count;

mutex_lock(&snd_ctl_led_mutex);
led->mode = mode;
mutex_unlock(&snd_ctl_led_mutex);

snd_ctl_led_set_state(NULL, group_to_access(led->group), NULL, 0);
return count;
}

static ssize_t show_state(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
enum led_brightness b;
const char *str;

b = ledtrig_audio_get(led->trigger_type);
switch (b) {
case LED_ON: str = "on"; break;
case LED_OFF: str = "off"; break;
default: str = "?"; break;
}
return sprintf(buf, "%s\n", str);
}

static DEVICE_ATTR(mode, 0644, show_mode, store_mode);
static DEVICE_ATTR(state, 0444, show_state, NULL);

static struct attribute *snd_ctl_led_dev_attrs[] = {
&dev_attr_mode.attr,
&dev_attr_state.attr,
NULL,
};

static const struct attribute_group snd_ctl_led_dev_attr_group = {
.attrs = snd_ctl_led_dev_attrs,
};

static const struct attribute_group *snd_ctl_led_dev_attr_groups[] = {
&snd_ctl_led_dev_attr_group,
NULL,
};

static struct device snd_ctl_led_dev;

/*
* Control layer registration
*/
@@ -258,16 +369,36 @@ static struct snd_ctl_layer_ops snd_ctl_led_lops = {

static int __init snd_ctl_led_init(void)
{
struct snd_ctl_led *led;
unsigned int group;

for (group = 0; group < MAX_LED; group++)
INIT_LIST_HEAD(&snd_ctl_led_controls[group]);
device_initialize(&snd_ctl_led_dev);
snd_ctl_led_dev.class = sound_class;
dev_set_name(&snd_ctl_led_dev, "ctl-led");
if (device_add(&snd_ctl_led_dev)) {
put_device(&snd_ctl_led_dev);
return -ENOMEM;
}
for (group = 0; group < MAX_LED; group++) {
led = &snd_ctl_leds[group];
INIT_LIST_HEAD(&led->controls);
device_initialize(&led->dev);
led->dev.parent = &snd_ctl_led_dev;
led->dev.groups = snd_ctl_led_dev_attr_groups;
dev_set_name(&led->dev, led->name);
if (device_add(&led->dev)) {
put_device(&led->dev);
device_del(&snd_ctl_led_dev);
return -ENOMEM;
}
}
snd_ctl_register_layer(&snd_ctl_led_lops);
return 0;
}

static void __exit snd_ctl_led_exit(void)
{
device_del(&snd_ctl_led_dev);
snd_ctl_disconnect_layer(&snd_ctl_led_lops);
snd_ctl_led_clean(NULL);
}

0 comments on commit 050a577

Please sign in to comment.