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 #define to_led_card_dev(_dev) \
21 	container_of(_dev, struct snd_ctl_led_card, dev)
22 
23 enum snd_ctl_led_mode {
24 	 MODE_FOLLOW_MUTE = 0,
25 	 MODE_FOLLOW_ROUTE,
26 	 MODE_OFF,
27 	 MODE_ON,
28 };
29 
30 struct snd_ctl_led_card {
31 	struct device dev;
32 	int number;
33 	struct snd_ctl_led *led;
34 };
35 
36 struct snd_ctl_led {
37 	struct device dev;
38 	struct list_head controls;
39 	const char *name;
40 	unsigned int group;
41 	enum led_audio trigger_type;
42 	enum snd_ctl_led_mode mode;
43 	struct snd_ctl_led_card *cards[SNDRV_CARDS];
44 };
45 
46 struct snd_ctl_led_ctl {
47 	struct list_head list;
48 	struct snd_card *card;
49 	unsigned int access;
50 	struct snd_kcontrol *kctl;
51 	unsigned int index_offset;
52 };
53 
54 static DEFINE_MUTEX(snd_ctl_led_mutex);
55 static bool snd_ctl_led_card_valid[SNDRV_CARDS];
56 static struct led_trigger *snd_ctl_ledtrig_audio[NUM_AUDIO_LEDS];
57 static struct snd_ctl_led snd_ctl_leds[MAX_LED] = {
58 	{
59 		.name = "speaker",
60 		.group = (SNDRV_CTL_ELEM_ACCESS_SPK_LED >> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1,
61 		.trigger_type = LED_AUDIO_MUTE,
62 		.mode = MODE_FOLLOW_MUTE,
63 	},
64 	{
65 		.name = "mic",
66 		.group = (SNDRV_CTL_ELEM_ACCESS_MIC_LED >> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1,
67 		.trigger_type = LED_AUDIO_MICMUTE,
68 		.mode = MODE_FOLLOW_MUTE,
69 	},
70 };
71 
72 static void snd_ctl_led_sysfs_add(struct snd_card *card);
73 static void snd_ctl_led_sysfs_remove(struct snd_card *card);
74 
75 #define UPDATE_ROUTE(route, cb) \
76 	do { \
77 		int route2 = (cb); \
78 		if (route2 >= 0) \
79 			route = route < 0 ? route2 : (route | route2); \
80 	} while (0)
81 
access_to_group(unsigned int access)82 static inline unsigned int access_to_group(unsigned int access)
83 {
84 	return ((access & SNDRV_CTL_ELEM_ACCESS_LED_MASK) >>
85 				SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) - 1;
86 }
87 
group_to_access(unsigned int group)88 static inline unsigned int group_to_access(unsigned int group)
89 {
90 	return (group + 1) << SNDRV_CTL_ELEM_ACCESS_LED_SHIFT;
91 }
92 
snd_ctl_led_get_by_access(unsigned int access)93 static struct snd_ctl_led *snd_ctl_led_get_by_access(unsigned int access)
94 {
95 	unsigned int group = access_to_group(access);
96 	if (group >= MAX_LED)
97 		return NULL;
98 	return &snd_ctl_leds[group];
99 }
100 
101 /*
102  * A note for callers:
103  *   The two static variables info and value are protected using snd_ctl_led_mutex.
104  */
snd_ctl_led_get(struct snd_ctl_led_ctl * lctl)105 static int snd_ctl_led_get(struct snd_ctl_led_ctl *lctl)
106 {
107 	static struct snd_ctl_elem_info info;
108 	static struct snd_ctl_elem_value value;
109 	struct snd_kcontrol *kctl = lctl->kctl;
110 	unsigned int i;
111 	int result;
112 
113 	memset(&info, 0, sizeof(info));
114 	info.id = kctl->id;
115 	info.id.index += lctl->index_offset;
116 	info.id.numid += lctl->index_offset;
117 	result = kctl->info(kctl, &info);
118 	if (result < 0)
119 		return -1;
120 	memset(&value, 0, sizeof(value));
121 	value.id = info.id;
122 	result = kctl->get(kctl, &value);
123 	if (result < 0)
124 		return -1;
125 	if (info.type == SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
126 	    info.type == SNDRV_CTL_ELEM_TYPE_INTEGER) {
127 		for (i = 0; i < info.count; i++)
128 			if (value.value.integer.value[i] != info.value.integer.min)
129 				return 1;
130 	} else if (info.type == SNDRV_CTL_ELEM_TYPE_INTEGER64) {
131 		for (i = 0; i < info.count; i++)
132 			if (value.value.integer64.value[i] != info.value.integer64.min)
133 				return 1;
134 	}
135 	return 0;
136 }
137 
snd_ctl_led_set_state(struct snd_card * card,unsigned int access,struct snd_kcontrol * kctl,unsigned int ioff)138 static void snd_ctl_led_set_state(struct snd_card *card, unsigned int access,
139 				  struct snd_kcontrol *kctl, unsigned int ioff)
140 {
141 	struct snd_ctl_led *led;
142 	struct snd_ctl_led_ctl *lctl;
143 	int route;
144 	bool found;
145 
146 	led = snd_ctl_led_get_by_access(access);
147 	if (!led)
148 		return;
149 	route = -1;
150 	found = false;
151 	scoped_guard(mutex, &snd_ctl_led_mutex) {
152 		/* the card may not be registered (active) at this point */
153 		if (card && !snd_ctl_led_card_valid[card->number])
154 			return;
155 		list_for_each_entry(lctl, &led->controls, list) {
156 			if (lctl->kctl == kctl && lctl->index_offset == ioff)
157 				found = true;
158 			UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
159 		}
160 		if (!found && kctl && card) {
161 			lctl = kzalloc(sizeof(*lctl), GFP_KERNEL);
162 			if (lctl) {
163 				lctl->card = card;
164 				lctl->access = access;
165 				lctl->kctl = kctl;
166 				lctl->index_offset = ioff;
167 				list_add(&lctl->list, &led->controls);
168 				UPDATE_ROUTE(route, snd_ctl_led_get(lctl));
169 			}
170 		}
171 	}
172 	switch (led->mode) {
173 	case MODE_OFF:		route = 1; break;
174 	case MODE_ON:		route = 0; break;
175 	case MODE_FOLLOW_ROUTE:	if (route >= 0) route ^= 1; break;
176 	case MODE_FOLLOW_MUTE:	/* noop */ break;
177 	}
178 	if (route >= 0) {
179 		struct led_trigger *trig = snd_ctl_ledtrig_audio[led->trigger_type];
180 
181 		led_trigger_event(trig, route ? LED_OFF : LED_ON);
182 	}
183 }
184 
snd_ctl_led_find(struct snd_kcontrol * kctl,unsigned int ioff)185 static struct snd_ctl_led_ctl *snd_ctl_led_find(struct snd_kcontrol *kctl, unsigned int ioff)
186 {
187 	struct list_head *controls;
188 	struct snd_ctl_led_ctl *lctl;
189 	unsigned int group;
190 
191 	for (group = 0; group < MAX_LED; group++) {
192 		controls = &snd_ctl_leds[group].controls;
193 		list_for_each_entry(lctl, controls, list)
194 			if (lctl->kctl == kctl && lctl->index_offset == ioff)
195 				return lctl;
196 	}
197 	return NULL;
198 }
199 
snd_ctl_led_remove(struct snd_kcontrol * kctl,unsigned int ioff,unsigned int access)200 static unsigned int snd_ctl_led_remove(struct snd_kcontrol *kctl, unsigned int ioff,
201 				       unsigned int access)
202 {
203 	struct snd_ctl_led_ctl *lctl;
204 	unsigned int ret = 0;
205 
206 	guard(mutex)(&snd_ctl_led_mutex);
207 	lctl = snd_ctl_led_find(kctl, ioff);
208 	if (lctl && (access == 0 || access != lctl->access)) {
209 		ret = lctl->access;
210 		list_del(&lctl->list);
211 		kfree(lctl);
212 	}
213 	return ret;
214 }
215 
snd_ctl_led_notify(struct snd_card * card,unsigned int mask,struct snd_kcontrol * kctl,unsigned int ioff)216 static void snd_ctl_led_notify(struct snd_card *card, unsigned int mask,
217 			       struct snd_kcontrol *kctl, unsigned int ioff)
218 {
219 	struct snd_kcontrol_volatile *vd;
220 	unsigned int access, access2;
221 
222 	if (mask == SNDRV_CTL_EVENT_MASK_REMOVE) {
223 		access = snd_ctl_led_remove(kctl, ioff, 0);
224 		if (access)
225 			snd_ctl_led_set_state(card, access, NULL, 0);
226 	} else if (mask & SNDRV_CTL_EVENT_MASK_INFO) {
227 		vd = &kctl->vd[ioff];
228 		access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
229 		access2 = snd_ctl_led_remove(kctl, ioff, access);
230 		if (access2)
231 			snd_ctl_led_set_state(card, access2, NULL, 0);
232 		if (access)
233 			snd_ctl_led_set_state(card, access, kctl, ioff);
234 	} else if ((mask & (SNDRV_CTL_EVENT_MASK_ADD |
235 			    SNDRV_CTL_EVENT_MASK_VALUE)) != 0) {
236 		vd = &kctl->vd[ioff];
237 		access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
238 		if (access)
239 			snd_ctl_led_set_state(card, access, kctl, ioff);
240 	}
241 }
242 
DEFINE_FREE(snd_card_unref,struct snd_card *,if (_T)snd_card_unref (_T))243 DEFINE_FREE(snd_card_unref, struct snd_card *, if (_T) snd_card_unref(_T))
244 
245 static int snd_ctl_led_set_id(int card_number, struct snd_ctl_elem_id *id,
246 			      unsigned int group, bool set)
247 {
248 	struct snd_card *card __free(snd_card_unref) = NULL;
249 	struct snd_kcontrol *kctl;
250 	struct snd_kcontrol_volatile *vd;
251 	unsigned int ioff, access, new_access;
252 
253 	card = snd_card_ref(card_number);
254 	if (!card)
255 		return -ENXIO;
256 	guard(rwsem_write)(&card->controls_rwsem);
257 	kctl = snd_ctl_find_id(card, id);
258 	if (!kctl)
259 		return -ENOENT;
260 	ioff = snd_ctl_get_ioff(kctl, id);
261 	vd = &kctl->vd[ioff];
262 	access = vd->access & SNDRV_CTL_ELEM_ACCESS_LED_MASK;
263 	if (access != 0 && access != group_to_access(group))
264 		return -EXDEV;
265 	new_access = vd->access & ~SNDRV_CTL_ELEM_ACCESS_LED_MASK;
266 	if (set)
267 		new_access |= group_to_access(group);
268 	if (new_access != vd->access) {
269 		vd->access = new_access;
270 		snd_ctl_led_notify(card, SNDRV_CTL_EVENT_MASK_INFO, kctl, ioff);
271 	}
272 	return 0;
273 }
274 
snd_ctl_led_refresh(void)275 static void snd_ctl_led_refresh(void)
276 {
277 	unsigned int group;
278 
279 	for (group = 0; group < MAX_LED; group++)
280 		snd_ctl_led_set_state(NULL, group_to_access(group), NULL, 0);
281 }
282 
snd_ctl_led_ctl_destroy(struct snd_ctl_led_ctl * lctl)283 static void snd_ctl_led_ctl_destroy(struct snd_ctl_led_ctl *lctl)
284 {
285 	list_del(&lctl->list);
286 	kfree(lctl);
287 }
288 
snd_ctl_led_clean(struct snd_card * card)289 static void snd_ctl_led_clean(struct snd_card *card)
290 {
291 	unsigned int group;
292 	struct snd_ctl_led_ctl *lctl, *_lctl;
293 	struct snd_ctl_led *led;
294 
295 	for (group = 0; group < MAX_LED; group++) {
296 		led = &snd_ctl_leds[group];
297 		list_for_each_entry_safe(lctl, _lctl, &led->controls, list)
298 			if (!card || lctl->card == card)
299 				snd_ctl_led_ctl_destroy(lctl);
300 	}
301 }
302 
snd_ctl_led_reset(int card_number,unsigned int group)303 static int snd_ctl_led_reset(int card_number, unsigned int group)
304 {
305 	struct snd_card *card __free(snd_card_unref) = NULL;
306 	struct snd_ctl_led_ctl *lctl, *_lctl;
307 	struct snd_ctl_led *led;
308 	struct snd_kcontrol_volatile *vd;
309 	bool change = false;
310 
311 	card = snd_card_ref(card_number);
312 	if (!card)
313 		return -ENXIO;
314 
315 	scoped_guard(mutex, &snd_ctl_led_mutex) {
316 		if (!snd_ctl_led_card_valid[card_number])
317 			return -ENXIO;
318 		led = &snd_ctl_leds[group];
319 		list_for_each_entry_safe(lctl, _lctl, &led->controls, list)
320 			if (lctl->card == card) {
321 				vd = &lctl->kctl->vd[lctl->index_offset];
322 				vd->access &= ~group_to_access(group);
323 				snd_ctl_led_ctl_destroy(lctl);
324 				change = true;
325 			}
326 	}
327 	if (change)
328 		snd_ctl_led_set_state(NULL, group_to_access(group), NULL, 0);
329 	return 0;
330 }
331 
snd_ctl_led_register(struct snd_card * card)332 static void snd_ctl_led_register(struct snd_card *card)
333 {
334 	struct snd_kcontrol *kctl;
335 	unsigned int ioff;
336 
337 	if (snd_BUG_ON(card->number < 0 ||
338 		       card->number >= ARRAY_SIZE(snd_ctl_led_card_valid)))
339 		return;
340 	scoped_guard(mutex, &snd_ctl_led_mutex)
341 		snd_ctl_led_card_valid[card->number] = true;
342 	/* the register callback is already called with held card->controls_rwsem */
343 	list_for_each_entry(kctl, &card->controls, list)
344 		for (ioff = 0; ioff < kctl->count; ioff++)
345 			snd_ctl_led_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, ioff);
346 	snd_ctl_led_refresh();
347 	snd_ctl_led_sysfs_add(card);
348 }
349 
snd_ctl_led_disconnect(struct snd_card * card)350 static void snd_ctl_led_disconnect(struct snd_card *card)
351 {
352 	snd_ctl_led_sysfs_remove(card);
353 	scoped_guard(mutex, &snd_ctl_led_mutex) {
354 		snd_ctl_led_card_valid[card->number] = false;
355 		snd_ctl_led_clean(card);
356 	}
357 	snd_ctl_led_refresh();
358 }
359 
snd_ctl_led_card_release(struct device * dev)360 static void snd_ctl_led_card_release(struct device *dev)
361 {
362 	struct snd_ctl_led_card *led_card = to_led_card_dev(dev);
363 
364 	kfree(led_card);
365 }
366 
snd_ctl_led_release(struct device * dev)367 static void snd_ctl_led_release(struct device *dev)
368 {
369 }
370 
snd_ctl_led_dev_release(struct device * dev)371 static void snd_ctl_led_dev_release(struct device *dev)
372 {
373 }
374 
375 /*
376  * sysfs
377  */
378 
mode_show(struct device * dev,struct device_attribute * attr,char * buf)379 static ssize_t mode_show(struct device *dev,
380 			 struct device_attribute *attr, char *buf)
381 {
382 	struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
383 	const char *str = NULL;
384 
385 	switch (led->mode) {
386 	case MODE_FOLLOW_MUTE:	str = "follow-mute"; break;
387 	case MODE_FOLLOW_ROUTE:	str = "follow-route"; break;
388 	case MODE_ON:		str = "on"; break;
389 	case MODE_OFF:		str = "off"; break;
390 	}
391 	return sysfs_emit(buf, "%s\n", str);
392 }
393 
mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)394 static ssize_t mode_store(struct device *dev,
395 			  struct device_attribute *attr,
396 			  const char *buf, size_t count)
397 {
398 	struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
399 	char _buf[16];
400 	size_t l = min(count, sizeof(_buf) - 1);
401 	enum snd_ctl_led_mode mode;
402 
403 	memcpy(_buf, buf, l);
404 	_buf[l] = '\0';
405 	if (strstr(_buf, "mute"))
406 		mode = MODE_FOLLOW_MUTE;
407 	else if (strstr(_buf, "route"))
408 		mode = MODE_FOLLOW_ROUTE;
409 	else if (strncmp(_buf, "off", 3) == 0 || strncmp(_buf, "0", 1) == 0)
410 		mode = MODE_OFF;
411 	else if (strncmp(_buf, "on", 2) == 0 || strncmp(_buf, "1", 1) == 0)
412 		mode = MODE_ON;
413 	else
414 		return count;
415 
416 	scoped_guard(mutex, &snd_ctl_led_mutex)
417 		led->mode = mode;
418 
419 	snd_ctl_led_set_state(NULL, group_to_access(led->group), NULL, 0);
420 	return count;
421 }
422 
brightness_show(struct device * dev,struct device_attribute * attr,char * buf)423 static ssize_t brightness_show(struct device *dev,
424 			       struct device_attribute *attr, char *buf)
425 {
426 	struct snd_ctl_led *led = container_of(dev, struct snd_ctl_led, dev);
427 	struct led_trigger *trig = snd_ctl_ledtrig_audio[led->trigger_type];
428 
429 	return sysfs_emit(buf, "%u\n", led_trigger_get_brightness(trig));
430 }
431 
432 static DEVICE_ATTR_RW(mode);
433 static DEVICE_ATTR_RO(brightness);
434 
435 static struct attribute *snd_ctl_led_dev_attrs[] = {
436 	&dev_attr_mode.attr,
437 	&dev_attr_brightness.attr,
438 	NULL,
439 };
440 
441 static const struct attribute_group snd_ctl_led_dev_attr_group = {
442 	.attrs = snd_ctl_led_dev_attrs,
443 };
444 
445 static const struct attribute_group *snd_ctl_led_dev_attr_groups[] = {
446 	&snd_ctl_led_dev_attr_group,
447 	NULL,
448 };
449 
find_eos(char * s)450 static char *find_eos(char *s)
451 {
452 	while (*s && *s != ',')
453 		s++;
454 	if (*s)
455 		s++;
456 	return s;
457 }
458 
parse_uint(char * s,unsigned int * val)459 static char *parse_uint(char *s, unsigned int *val)
460 {
461 	unsigned long long res;
462 	if (kstrtoull(s, 10, &res))
463 		res = 0;
464 	*val = res;
465 	return find_eos(s);
466 }
467 
parse_string(char * s,char * val,size_t val_size)468 static char *parse_string(char *s, char *val, size_t val_size)
469 {
470 	if (*s == '"' || *s == '\'') {
471 		char c = *s;
472 		s++;
473 		while (*s && *s != c) {
474 			if (val_size > 1) {
475 				*val++ = *s;
476 				val_size--;
477 			}
478 			s++;
479 		}
480 	} else {
481 		while (*s && *s != ',') {
482 			if (val_size > 1) {
483 				*val++ = *s;
484 				val_size--;
485 			}
486 			s++;
487 		}
488 	}
489 	*val = '\0';
490 	if (*s)
491 		s++;
492 	return s;
493 }
494 
parse_iface(char * s,snd_ctl_elem_iface_t * val)495 static char *parse_iface(char *s, snd_ctl_elem_iface_t *val)
496 {
497 	if (!strncasecmp(s, "card", 4))
498 		*val = SNDRV_CTL_ELEM_IFACE_CARD;
499 	else if (!strncasecmp(s, "mixer", 5))
500 		*val = SNDRV_CTL_ELEM_IFACE_MIXER;
501 	return find_eos(s);
502 }
503 
504 /*
505  * These types of input strings are accepted:
506  *
507  *   unsigned integer - numid (equivaled to numid=UINT)
508  *   string - basic mixer name (equivalent to iface=MIXER,name=STR)
509  *   numid=UINT
510  *   [iface=MIXER,][device=UINT,][subdevice=UINT,]name=STR[,index=UINT]
511  */
set_led_id(struct snd_ctl_led_card * led_card,const char * buf,size_t count,bool attach)512 static ssize_t set_led_id(struct snd_ctl_led_card *led_card, const char *buf, size_t count,
513 			  bool attach)
514 {
515 	char buf2[256], *s, *os;
516 	struct snd_ctl_elem_id id;
517 	int err;
518 
519 	if (strscpy(buf2, buf, sizeof(buf2)) < 0)
520 		return -E2BIG;
521 	memset(&id, 0, sizeof(id));
522 	id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
523 	s = buf2;
524 	while (*s) {
525 		os = s;
526 		if (!strncasecmp(s, "numid=", 6)) {
527 			s = parse_uint(s + 6, &id.numid);
528 		} else if (!strncasecmp(s, "iface=", 6)) {
529 			s = parse_iface(s + 6, &id.iface);
530 		} else if (!strncasecmp(s, "device=", 7)) {
531 			s = parse_uint(s + 7, &id.device);
532 		} else if (!strncasecmp(s, "subdevice=", 10)) {
533 			s = parse_uint(s + 10, &id.subdevice);
534 		} else if (!strncasecmp(s, "name=", 5)) {
535 			s = parse_string(s + 5, id.name, sizeof(id.name));
536 		} else if (!strncasecmp(s, "index=", 6)) {
537 			s = parse_uint(s + 6, &id.index);
538 		} else if (s == buf2) {
539 			while (*s) {
540 				if (*s < '0' || *s > '9')
541 					break;
542 				s++;
543 			}
544 			if (*s == '\0')
545 				parse_uint(buf2, &id.numid);
546 			else {
547 				for (; *s >= ' '; s++);
548 				*s = '\0';
549 				strscpy(id.name, buf2, sizeof(id.name));
550 			}
551 			break;
552 		}
553 		if (*s == ',')
554 			s++;
555 		if (s == os)
556 			break;
557 	}
558 
559 	err = snd_ctl_led_set_id(led_card->number, &id, led_card->led->group, attach);
560 	if (err < 0)
561 		return err;
562 
563 	return count;
564 }
565 
attach_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)566 static ssize_t attach_store(struct device *dev,
567 			    struct device_attribute *attr,
568 			    const char *buf, size_t count)
569 {
570 	struct snd_ctl_led_card *led_card = container_of(dev, struct snd_ctl_led_card, dev);
571 	return set_led_id(led_card, buf, count, true);
572 }
573 
detach_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)574 static ssize_t detach_store(struct device *dev,
575 			    struct device_attribute *attr,
576 			    const char *buf, size_t count)
577 {
578 	struct snd_ctl_led_card *led_card = container_of(dev, struct snd_ctl_led_card, dev);
579 	return set_led_id(led_card, buf, count, false);
580 }
581 
reset_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)582 static ssize_t reset_store(struct device *dev,
583 			   struct device_attribute *attr,
584 			   const char *buf, size_t count)
585 {
586 	struct snd_ctl_led_card *led_card = container_of(dev, struct snd_ctl_led_card, dev);
587 	int err;
588 
589 	if (count > 0 && buf[0] == '1') {
590 		err = snd_ctl_led_reset(led_card->number, led_card->led->group);
591 		if (err < 0)
592 			return err;
593 	}
594 	return count;
595 }
596 
list_show(struct device * dev,struct device_attribute * attr,char * buf)597 static ssize_t list_show(struct device *dev,
598 			 struct device_attribute *attr, char *buf)
599 {
600 	struct snd_ctl_led_card *led_card = container_of(dev, struct snd_ctl_led_card, dev);
601 	struct snd_card *card __free(snd_card_unref) = NULL;
602 	struct snd_ctl_led_ctl *lctl;
603 	size_t l = 0;
604 
605 	card = snd_card_ref(led_card->number);
606 	if (!card)
607 		return -ENXIO;
608 	guard(rwsem_read)(&card->controls_rwsem);
609 	guard(mutex)(&snd_ctl_led_mutex);
610 	if (snd_ctl_led_card_valid[led_card->number]) {
611 		list_for_each_entry(lctl, &led_card->led->controls, list) {
612 			if (lctl->card != card)
613 				continue;
614 			if (l)
615 				l += sysfs_emit_at(buf, l, " ");
616 			l += sysfs_emit_at(buf, l, "%u",
617 					   lctl->kctl->id.numid + lctl->index_offset);
618 		}
619 	}
620 	return l;
621 }
622 
623 static DEVICE_ATTR_WO(attach);
624 static DEVICE_ATTR_WO(detach);
625 static DEVICE_ATTR_WO(reset);
626 static DEVICE_ATTR_RO(list);
627 
628 static struct attribute *snd_ctl_led_card_attrs[] = {
629 	&dev_attr_attach.attr,
630 	&dev_attr_detach.attr,
631 	&dev_attr_reset.attr,
632 	&dev_attr_list.attr,
633 	NULL,
634 };
635 
636 static const struct attribute_group snd_ctl_led_card_attr_group = {
637 	.attrs = snd_ctl_led_card_attrs,
638 };
639 
640 static const struct attribute_group *snd_ctl_led_card_attr_groups[] = {
641 	&snd_ctl_led_card_attr_group,
642 	NULL,
643 };
644 
645 static struct device snd_ctl_led_dev;
646 
snd_ctl_led_sysfs_add(struct snd_card * card)647 static void snd_ctl_led_sysfs_add(struct snd_card *card)
648 {
649 	unsigned int group;
650 	struct snd_ctl_led_card *led_card;
651 	struct snd_ctl_led *led;
652 	char link_name[32];
653 
654 	for (group = 0; group < MAX_LED; group++) {
655 		led = &snd_ctl_leds[group];
656 		led_card = kzalloc(sizeof(*led_card), GFP_KERNEL);
657 		if (!led_card)
658 			goto cerr2;
659 		led_card->number = card->number;
660 		led_card->led = led;
661 		device_initialize(&led_card->dev);
662 		led_card->dev.release = snd_ctl_led_card_release;
663 		if (dev_set_name(&led_card->dev, "card%d", card->number) < 0)
664 			goto cerr;
665 		led_card->dev.parent = &led->dev;
666 		led_card->dev.groups = snd_ctl_led_card_attr_groups;
667 		if (device_add(&led_card->dev))
668 			goto cerr;
669 		led->cards[card->number] = led_card;
670 		snprintf(link_name, sizeof(link_name), "led-%s", led->name);
671 		WARN(sysfs_create_link(&card->ctl_dev->kobj, &led_card->dev.kobj, link_name),
672 			"can't create symlink to controlC%i device\n", card->number);
673 		WARN(sysfs_create_link(&led_card->dev.kobj, &card->card_dev.kobj, "card"),
674 			"can't create symlink to card%i\n", card->number);
675 
676 		continue;
677 cerr:
678 		put_device(&led_card->dev);
679 cerr2:
680 		dev_err(card->dev, "snd_ctl_led: unable to add card%d", card->number);
681 	}
682 }
683 
snd_ctl_led_sysfs_remove(struct snd_card * card)684 static void snd_ctl_led_sysfs_remove(struct snd_card *card)
685 {
686 	unsigned int group;
687 	struct snd_ctl_led_card *led_card;
688 	struct snd_ctl_led *led;
689 	char link_name[32];
690 
691 	for (group = 0; group < MAX_LED; group++) {
692 		led = &snd_ctl_leds[group];
693 		led_card = led->cards[card->number];
694 		if (!led_card)
695 			continue;
696 		snprintf(link_name, sizeof(link_name), "led-%s", led->name);
697 		sysfs_remove_link(&card->ctl_dev->kobj, link_name);
698 		sysfs_remove_link(&led_card->dev.kobj, "card");
699 		device_unregister(&led_card->dev);
700 		led->cards[card->number] = NULL;
701 	}
702 }
703 
704 /*
705  * Control layer registration
706  */
707 static struct snd_ctl_layer_ops snd_ctl_led_lops = {
708 	.module_name = SND_CTL_LAYER_MODULE_LED,
709 	.lregister = snd_ctl_led_register,
710 	.ldisconnect = snd_ctl_led_disconnect,
711 	.lnotify = snd_ctl_led_notify,
712 };
713 
snd_ctl_led_init(void)714 static int __init snd_ctl_led_init(void)
715 {
716 	struct snd_ctl_led *led;
717 	unsigned int group;
718 
719 	led_trigger_register_simple("audio-mute", &snd_ctl_ledtrig_audio[LED_AUDIO_MUTE]);
720 	led_trigger_register_simple("audio-micmute", &snd_ctl_ledtrig_audio[LED_AUDIO_MICMUTE]);
721 
722 	device_initialize(&snd_ctl_led_dev);
723 	snd_ctl_led_dev.class = &sound_class;
724 	snd_ctl_led_dev.release = snd_ctl_led_dev_release;
725 	dev_set_name(&snd_ctl_led_dev, "ctl-led");
726 	if (device_add(&snd_ctl_led_dev)) {
727 		put_device(&snd_ctl_led_dev);
728 		return -ENOMEM;
729 	}
730 	for (group = 0; group < MAX_LED; group++) {
731 		led = &snd_ctl_leds[group];
732 		INIT_LIST_HEAD(&led->controls);
733 		device_initialize(&led->dev);
734 		led->dev.parent = &snd_ctl_led_dev;
735 		led->dev.release = snd_ctl_led_release;
736 		led->dev.groups = snd_ctl_led_dev_attr_groups;
737 		dev_set_name(&led->dev, led->name);
738 		if (device_add(&led->dev)) {
739 			put_device(&led->dev);
740 			for (; group > 0; group--) {
741 				led = &snd_ctl_leds[group - 1];
742 				device_unregister(&led->dev);
743 			}
744 			device_unregister(&snd_ctl_led_dev);
745 			return -ENOMEM;
746 		}
747 	}
748 	snd_ctl_register_layer(&snd_ctl_led_lops);
749 	return 0;
750 }
751 
snd_ctl_led_exit(void)752 static void __exit snd_ctl_led_exit(void)
753 {
754 	struct snd_ctl_led *led;
755 	struct snd_card *card;
756 	unsigned int group, card_number;
757 
758 	snd_ctl_disconnect_layer(&snd_ctl_led_lops);
759 	for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
760 		if (!snd_ctl_led_card_valid[card_number])
761 			continue;
762 		card = snd_card_ref(card_number);
763 		if (card) {
764 			snd_ctl_led_sysfs_remove(card);
765 			snd_card_unref(card);
766 		}
767 	}
768 	for (group = 0; group < MAX_LED; group++) {
769 		led = &snd_ctl_leds[group];
770 		device_unregister(&led->dev);
771 	}
772 	device_unregister(&snd_ctl_led_dev);
773 	snd_ctl_led_clean(NULL);
774 
775 	led_trigger_unregister_simple(snd_ctl_ledtrig_audio[LED_AUDIO_MUTE]);
776 	led_trigger_unregister_simple(snd_ctl_ledtrig_audio[LED_AUDIO_MICMUTE]);
777 }
778 
779 module_init(snd_ctl_led_init)
780 module_exit(snd_ctl_led_exit)
781 
782 MODULE_ALIAS("ledtrig:audio-mute");
783 MODULE_ALIAS("ledtrig:audio-micmute");
784