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