[linux-block.git] / sound / core / control_led.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  LED state routines for driver control interface
 *  Copyright (c) 2021 by Jaroslav Kysela <perex@perex.cz>
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <linux/leds.h>
#include <sound/core.h>
#include <sound/control.h>

MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
MODULE_DESCRIPTION("ALSA control interface to LED trigger code.");
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)

struct snd_ctl_led {
	struct list_head list;
	struct snd_card *card;
	unsigned int access;
	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];

#define UPDATE_ROUTE(route, cb) \
	do { \
		int route2 = (cb); \
		if (route2 >= 0) \
			route = route < 0 ? route2 : (route | route2); \
	} while (0)

static inline unsigned int access_to_group(unsigned int access)
{
	return ((access & SNDRV_CTL_ELEM_ACCESS_LED_MASK) >>
				SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1;
}

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)
{
	unsigned int group = access_to_group(access);
	if (group >= MAX_LED)
		return NULL;
	return &snd_ctl_led_controls[group];
}

static int snd_ctl_led_get(struct snd_ctl_led *lctl)
{
	struct snd_kcontrol *kctl = lctl->kctl;
	struct snd_ctl_elem_info info;
	struct snd_ctl_elem_value value;
	unsigned int i;
	int result;

	memset(&info, 0, sizeof(info));
	info.id = kctl->id;
	info.id.index += lctl->index_offset;
	info.id.numid += lctl->index_offset;
	result = kctl->info(kctl, &info);
	if (result < 0)
		return -1;
	memset(&value, 0, sizeof(value));
	value.id = info.id;
	result = kctl->get(kctl, &value);
	if (result < 0)
		return -1;
	if (info.type == SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
	    info.type == SNDRV_CTL_ELEM_TYPE_INTEGER) {
		for (i = 0; i < info.count; i++)
			if (value.value.integer.value[i] != info.value.integer.min)
				return 1;
	} else if (info.type == SNDRV_CTL_ELEM_TYPE_INTEGER64) {
		for (i = 0; i < info.count; i++)
			if (value.value.integer64.value[i] != info.value.integer64.min)
				return 1;
	}
	return 0;
}

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;
	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 {
		return;
	}
	route = -1;
	found = false;
	mutex_lock(&snd_ctl_led_mutex);
	/* the card may not be registered (active) at this point */
	if (card && !snd_ctl_led_card_valid[card->number]) {
		mutex_unlock(&snd_ctl_led_mutex);
		return;
	}
	list_for_each_entry(lctl, controls, list) {
		if (lctl->kctl == kctl && lctl->index_offset == ioff)
			found = true;
		UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
	}
	if (!found && kctl && card) {
		lctl = kzalloc(sizeof(*lctl), GFP_KERNEL);
		if (lctl) {
			lctl->card = card;
			lctl->access = access;
			lctl->kctl = kctl;
			lctl->index_offset = ioff;
			list_add(&lctl->list, controls);
			UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
		}
	}
	mutex_unlock(&snd_ctl_led_mutex);
	if (route >= 0)
		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)
{
	struct list_head *controls;
	struct snd_ctl_led *lctl;
	unsigned int group;

	for (group = 0; group < MAX_LED; group++) {
		controls = &snd_ctl_led_controls[group];
		list_for_each_entry(lctl, controls, list)
			if (lctl->kctl == kctl && lctl->index_offset == ioff)
				return lctl;
	}
	return NULL;
}

static unsigned int snd_ctl_led_remove(struct snd_kcontrol *kctl, unsigned int ioff,
				       unsigned int access)
{
	struct snd_ctl_led *lctl;
	unsigned int ret = 0;

	mutex_lock(&snd_ctl_led_mutex);
	lctl = snd_ctl_led_find(kctl, ioff);
	if (lctl && (access == 0 || access != lctl->access)) {
		ret = lctl->access;
		list_del(&lctl->list);
		kfree(lctl);
	}
	mutex_unlock(&snd_ctl_led_mutex);
	return ret;
}

static void snd_ctl_led_notify(struct snd_card *card, unsigned int mask,
			       struct snd_kcontrol *kctl, unsigned int ioff)
{
	struct snd_kcontrol_volatile *vd;
	unsigned int access, access2;

	if (mask == SNDRV_CTL_EVENT_MASK_REMOVE) {
		access = snd_ctl_led_remove(kctl, ioff, 0);
		if (access)
			snd_ctl_led_set_state(card, access, NULL, 0);
	} else if (mask & SNDRV_CTL_EVENT_MASK_INFO) {
		vd = &kctl->vd[ioff];
		access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
		access2 = snd_ctl_led_remove(kctl, ioff, access);
		if (access2)
			snd_ctl_led_set_state(card, access2, NULL, 0);
		if (access)
			snd_ctl_led_set_state(card, access, kctl, ioff);
	} else if ((mask & (SNDRV_CTL_EVENT_MASK_ADD |
			    SNDRV_CTL_EVENT_MASK_VALUE)) != 0) {
		vd = &kctl->vd[ioff];
		access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
		if (access)
			snd_ctl_led_set_state(card, access, kctl, ioff);
	}
}

static void snd_ctl_led_refresh(void)
{
	unsigned int group;

	for (group = 0; group < MAX_LED; group++)
		snd_ctl_led_set_state(NULL, group_to_access(group), NULL, 0);
}

static void snd_ctl_led_clean(struct snd_card *card)
{
	unsigned int group;
	struct list_head *controls;
	struct snd_ctl_led *lctl;

	for (group = 0; group < MAX_LED; group++) {
		controls = &snd_ctl_led_controls[group];
repeat:
		list_for_each_entry(lctl, controls, list)
			if (!card || lctl->card == card) {
				list_del(&lctl->list);
				kfree(lctl);
				goto repeat;
			}
	}
}

static void snd_ctl_led_register(struct snd_card *card)
{
	struct snd_kcontrol *kctl;
	unsigned int ioff;

	if (snd_BUG_ON(card->number < 0 ||
		       card->number >= ARRAY_SIZE(snd_ctl_led_card_valid)))
		return;
	mutex_lock(&snd_ctl_led_mutex);
	snd_ctl_led_card_valid[card->number] = true;
	mutex_unlock(&snd_ctl_led_mutex);
	/* the register callback is already called with held card->controls_rwsem */
	list_for_each_entry(kctl, &card->controls, list)
		for (ioff = 0; ioff < kctl->count; ioff++)
			snd_ctl_led_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, ioff);
	snd_ctl_led_refresh();
}

static void snd_ctl_led_disconnect(struct snd_card *card)
{
	mutex_lock(&snd_ctl_led_mutex);
	snd_ctl_led_card_valid[card->number] = false;
	snd_ctl_led_clean(card);
	mutex_unlock(&snd_ctl_led_mutex);
	snd_ctl_led_refresh();
}

/*
 * Control layer registration
 */
static struct snd_ctl_layer_ops snd_ctl_led_lops = {
	.module_name = SND_CTL_LAYER_MODULE_LED,
	.lregister = snd_ctl_led_register,
	.ldisconnect = snd_ctl_led_disconnect,
	.lnotify = snd_ctl_led_notify,
};

static int __init snd_ctl_led_init(void)
{
	unsigned int group;

	for (group = 0; group < MAX_LED; group++)
		INIT_LIST_HEAD(&snd_ctl_led_controls[group]);
	snd_ctl_register_layer(&snd_ctl_led_lops);
	return 0;
}

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

module_init(snd_ctl_led_init)
module_exit(snd_ctl_led_exit)
Commit	Line	Data
22d8de62 JK	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* LED state routines for driver control interface
	4	* Copyright (c) 2021 by Jaroslav Kysela <perex@perex.cz>
	5	*/
	6
	7	#include <linux/slab.h>
	8	#include <linux/module.h>
	9	#include <linux/leds.h>
	10	#include <sound/core.h>
	11	#include <sound/control.h>
	12
	13	MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
	14	MODULE_DESCRIPTION("ALSA control interface to LED trigger code.");
	15	MODULE_LICENSE("GPL");
	16
	17	#define MAX_LED (((SNDRV_CTL_ELEM_ACCESS_MIC_LED - SNDRV_CTL_ELEM_ACCESS_SPK_LED) \
	18	>> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) + 1)
	19
	20	struct snd_ctl_led {
	21	struct list_head list;
	22	struct snd_card *card;
	23	unsigned int access;
	24	struct snd_kcontrol *kctl;
	25	unsigned int index_offset;
	26	};
	27
	28	static DEFINE_MUTEX(snd_ctl_led_mutex);
	29	static struct list_head snd_ctl_led_controls[MAX_LED];
	30	static bool snd_ctl_led_card_valid[SNDRV_CARDS];
	31
	32	#define UPDATE_ROUTE(route, cb) \
	33	do { \
	34	int route2 = (cb); \
	35	if (route2 >= 0) \
	36	route = route < 0 ? route2 : (route \| route2); \
	37	} while (0)
	38
	39	static inline unsigned int access_to_group(unsigned int access)
	40	{
	41	return ((access & SNDRV_CTL_ELEM_ACCESS_LED_MASK) >>
	42	SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1;
	43	}
	44
	45	static inline unsigned int group_to_access(unsigned int group)
	46	{
	47	return (group + 1) << SNDRV_CTL_ELEM_ACCESS_LED_SHIFT;
	48	}
	49
	50	static struct list_head *snd_ctl_led_controls_by_access(unsigned int access)
	51	{
	52	unsigned int group = access_to_group(access);
	53	if (group >= MAX_LED)
	54	return NULL;
	55	return &snd_ctl_led_controls[group];
	56	}
	57
	58	static int snd_ctl_led_get(struct snd_ctl_led *lctl)
	59	{
	60	struct snd_kcontrol *kctl = lctl->kctl;
	61	struct snd_ctl_elem_info info;
	62	struct snd_ctl_elem_value value;
	63	unsigned int i;
	64	int result;
65
66	memset(&info, 0, sizeof(info));
67	info.id = kctl->id;
68	info.id.index += lctl->index_offset;
69	info.id.numid += lctl->index_offset;
70	result = kctl->info(kctl, &info);
71	if (result < 0)
72	return -1;
73	memset(&value, 0, sizeof(value));
74	value.id = info.id;
75	result = kctl->get(kctl, &value);
76	if (result < 0)
77	return -1;
78	if (info.type == SNDRV_CTL_ELEM_TYPE_BOOLEAN \|\|
79	info.type == SNDRV_CTL_ELEM_TYPE_INTEGER) {
80	for (i = 0; i < info.count; i++)
81	if (value.value.integer.value[i] != info.value.integer.min)
82	return 1;
83	} else if (info.type == SNDRV_CTL_ELEM_TYPE_INTEGER64) {
84	for (i = 0; i < info.count; i++)
85	if (value.value.integer64.value[i] != info.value.integer64.min)
86	return 1;
87	}
88	return 0;
89	}
90
91	static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access,
92	struct snd_kcontrol *kctl, unsigned int ioff)
93	{
94	struct list_head *controls;
95	struct snd_ctl_led *lctl;
96	enum led_audio led_trigger_type;
97	int route;
98	bool found;
99
100	controls = snd_ctl_led_controls_by_access(access);
101	if (!controls)
102	return;
103	if (access == SNDRV_CTL_ELEM_ACCESS_SPK_LED) {
104	led_trigger_type = LED_AUDIO_MUTE;
105	} else if (access == SNDRV_CTL_ELEM_ACCESS_MIC_LED) {
106	led_trigger_type = LED_AUDIO_MICMUTE;
107	} else {
108	return;
109	}
110	route = -1;
111	found = false;
112	mutex_lock(&snd_ctl_led_mutex);
113	/* the card may not be registered (active) at this point */
114	if (card && !snd_ctl_led_card_valid[card->number]) {
115	mutex_unlock(&snd_ctl_led_mutex);
116	return;
117	}
118	list_for_each_entry(lctl, controls, list) {
119	if (lctl->kctl == kctl && lctl->index_offset == ioff)
120	found = true;
121	UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
122	}
123	if (!found && kctl && card) {
124	lctl = kzalloc(sizeof(*lctl), GFP_KERNEL);
125	if (lctl) {
126	lctl->card = card;
127	lctl->access = access;
128	lctl->kctl = kctl;
129	lctl->index_offset = ioff;
130	list_add(&lctl->list, controls);
131	UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
132	}
133	}
134	mutex_unlock(&snd_ctl_led_mutex);
135	if (route >= 0)
136	ledtrig_audio_set(led_trigger_type, route ? LED_OFF : LED_ON);
137	}
138
139	static struct snd_ctl_led snd_ctl_led_find(struct snd_kcontrol kctl, unsigned int ioff)
140	{
141	struct list_head *controls;
142	struct snd_ctl_led *lctl;
143	unsigned int group;
144
145	for (group = 0; group < MAX_LED; group++) {
146	controls = &snd_ctl_led_controls[group];
147	list_for_each_entry(lctl, controls, list)
148	if (lctl->kctl == kctl && lctl->index_offset == ioff)
149	return lctl;
150	}
151	return NULL;
152	}
153
154	static unsigned int snd_ctl_led_remove(struct snd_kcontrol *kctl, unsigned int ioff,
155	unsigned int access)
156	{
157	struct snd_ctl_led *lctl;
158	unsigned int ret = 0;
159
160	mutex_lock(&snd_ctl_led_mutex);
161	lctl = snd_ctl_led_find(kctl, ioff);
162	if (lctl && (access == 0 \|\| access != lctl->access)) {
163	ret = lctl->access;
164	list_del(&lctl->list);
165	kfree(lctl);
166	}
167	mutex_unlock(&snd_ctl_led_mutex);
168	return ret;
169	}
170
171	static void snd_ctl_led_notify(struct snd_card *card, unsigned int mask,
172	struct snd_kcontrol *kctl, unsigned int ioff)
173	{
174	struct snd_kcontrol_volatile *vd;
175	unsigned int access, access2;
176
177	if (mask == SNDRV_CTL_EVENT_MASK_REMOVE) {
178	access = snd_ctl_led_remove(kctl, ioff, 0);
179	if (access)
180	snd_ctl_led_set_state(card, access, NULL, 0);
181	} else if (mask & SNDRV_CTL_EVENT_MASK_INFO) {
182	vd = &kctl->vd[ioff];
183	access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
184	access2 = snd_ctl_led_remove(kctl, ioff, access);
185	if (access2)
186	snd_ctl_led_set_state(card, access2, NULL, 0);
187	if (access)
188	snd_ctl_led_set_state(card, access, kctl, ioff);
189	} else if ((mask & (SNDRV_CTL_EVENT_MASK_ADD \|
190	SNDRV_CTL_EVENT_MASK_VALUE)) != 0) {
191	vd = &kctl->vd[ioff];
192	access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
193	if (access)
194	snd_ctl_led_set_state(card, access, kctl, ioff);
195	}
196	}
197
198	static void snd_ctl_led_refresh(void)
199	{
200	unsigned int group;
201
202	for (group = 0; group < MAX_LED; group++)
203	snd_ctl_led_set_state(NULL, group_to_access(group), NULL, 0);
204	}
205
206	static void snd_ctl_led_clean(struct snd_card *card)
207	{
208	unsigned int group;
209	struct list_head *controls;
210	struct snd_ctl_led *lctl;
211
212	for (group = 0; group < MAX_LED; group++) {
213	controls = &snd_ctl_led_controls[group];
214	repeat:
215	list_for_each_entry(lctl, controls, list)
216	if (!card \|\| lctl->card == card) {
217	list_del(&lctl->list);
218	kfree(lctl);
219	goto repeat;
220	}
221	}
222	}
223
224	static void snd_ctl_led_register(struct snd_card *card)
225	{
226	struct snd_kcontrol *kctl;
227	unsigned int ioff;
228
229	if (snd_BUG_ON(card->number < 0 \|\|
230	card->number >= ARRAY_SIZE(snd_ctl_led_card_valid)))
231	return;
232	mutex_lock(&snd_ctl_led_mutex);
233	snd_ctl_led_card_valid[card->number] = true;
234	mutex_unlock(&snd_ctl_led_mutex);
235	/* the register callback is already called with held card->controls_rwsem */
236	list_for_each_entry(kctl, &card->controls, list)
237	for (ioff = 0; ioff < kctl->count; ioff++)
238	snd_ctl_led_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, ioff);
239	snd_ctl_led_refresh();
240	}
241
242	static void snd_ctl_led_disconnect(struct snd_card *card)
243	{
244	mutex_lock(&snd_ctl_led_mutex);
245	snd_ctl_led_card_valid[card->number] = false;
246	snd_ctl_led_clean(card);
247	mutex_unlock(&snd_ctl_led_mutex);
248	snd_ctl_led_refresh();
249	}
250
251	/*
252	* Control layer registration
253	*/
254	static struct snd_ctl_layer_ops snd_ctl_led_lops = {
255	.module_name = SND_CTL_LAYER_MODULE_LED,
256	.lregister = snd_ctl_led_register,
257	.ldisconnect = snd_ctl_led_disconnect,
258	.lnotify = snd_ctl_led_notify,
259	};
260
261	static int __init snd_ctl_led_init(void)
262	{
263	unsigned int group;
264
265	for (group = 0; group < MAX_LED; group++)
266	INIT_LIST_HEAD(&snd_ctl_led_controls[group]);
267	snd_ctl_register_layer(&snd_ctl_led_lops);
268	return 0;
269	}
270
271	static void __exit snd_ctl_led_exit(void)
272	{
273	snd_ctl_disconnect_layer(&snd_ctl_led_lops);
274	snd_ctl_led_clean(NULL);
275	}
276
277	module_init(snd_ctl_led_init)
278	module_exit(snd_ctl_led_exit)