Commit cb17fe00 authored by Jaroslav Kysela's avatar Jaroslav Kysela Committed by Takashi Iwai
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
    +-- brightness
  mic/
    +-- mode
    +-- brightness

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: default avatarJaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210317172945.842280-6-perex@perex.cz


Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent e65bf997

sound/core/control_led.c

+163 −29
Original line number Diff line number Diff line
@@ -17,7 +17,23 @@ 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;

	unsigned int access;
@@ -26,8 +42,21 @@ struct snd_ctl_led { 
};



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 { \
@@ -47,15 +76,15 @@ static inline unsigned int group_to_access(unsigned int group) 
	return (group + 1) << SNDRV_CTL_ELEM_ACCESS_LED_SHIFT;

}



static struct list_head *snd_ctl_led_controls_by_access(unsigned int access)

static 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;
@@ -91,22 +120,14 @@ static int snd_ctl_led_get(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)

		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 {

	led = snd_ctl_led_get_by_access(access);

	if (!led)

		return;

	}

	route = -1;

	found = false;

	mutex_lock(&snd_ctl_led_mutex);
@@ -115,7 +136,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(lctl));
@@ -127,23 +148,29 @@ static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access, 
			lctl->access = access;

			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(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 struct snd_ctl_led *snd_ctl_led_find(struct snd_kcontrol *kctl, unsigned int ioff)

static struct snd_ctl_led_ctl *snd_ctl_led_find(struct snd_kcontrol *kctl, unsigned int ioff)

{

	struct list_head *controls;

	struct snd_ctl_led *lctl;

	struct snd_ctl_led_ctl *lctl;

	unsigned int group;



	for (group = 0; group < MAX_LED; group++) {

		controls = &snd_ctl_led_controls[group];

		controls = &snd_ctl_leds[group].controls;

		list_for_each_entry(lctl, controls, list)

			if (lctl->kctl == kctl && lctl->index_offset == ioff)

				return lctl;
@@ -154,7 +181,7 @@ static struct snd_ctl_led *snd_ctl_led_find(struct snd_kcontrol *kctl, unsigned 
static unsigned int snd_ctl_led_remove(struct snd_kcontrol *kctl, unsigned int ioff,

				       unsigned int access)

{

	struct snd_ctl_led *lctl;

	struct snd_ctl_led_ctl *lctl;

	unsigned int ret = 0;



	mutex_lock(&snd_ctl_led_mutex);
@@ -206,13 +233,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);
@@ -248,6 +275,82 @@ static void snd_ctl_led_disconnect(struct snd_card *card) 
	snd_ctl_led_refresh();

}



/*

 * 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_brightness(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);



	return sprintf(buf, "%u\n", ledtrig_audio_get(led->trigger_type));

}



static DEVICE_ATTR(mode, 0644, show_mode, store_mode);

static DEVICE_ATTR(brightness, 0444, show_brightness, NULL);



static struct attribute *snd_ctl_led_dev_attrs[] = {

	&dev_attr_mode.attr,

	&dev_attr_brightness.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

 */
@@ -260,16 +363,47 @@ 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);

			for (; group > 0; group--) {

				led = &snd_ctl_leds[group];

				device_del(&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)

{

	struct snd_ctl_led *led;

	unsigned int group;



	for (group = 0; group < MAX_LED; group++) {

		led = &snd_ctl_leds[group];

		device_del(&led->dev);

	}

	device_del(&snd_ctl_led_dev);

	snd_ctl_disconnect_layer(&snd_ctl_led_lops);

	snd_ctl_led_clean(NULL);

}