sound/core/control_led.c

   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 <[email protected]>
   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 <[email protected]>");
  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
  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
  88 static inline unsigned int group_to_access(unsigned int group)
  89 {
  90         return (group + 1) << SNDRV_CTL_ELEM_ACCESS_LED_SHIFT;
  91 }
  92
  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  */
 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
 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
 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
 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
 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
 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_locked(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
 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
 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
 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
 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
 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
 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
 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
 367 static void snd_ctl_led_release(struct device *dev)
 368 {
 369 }
 370
 371 static void snd_ctl_led_dev_release(struct device *dev)
 372 {
 373 }
 374
 375 /*
 376  * sysfs
 377  */
 378
 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
 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
 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
 450 static char *find_eos(char *s)
 451 {
 452         while (*s && *s != ',')
 453                 s++;
 454         if (*s)
 455                 s++;
 456         return s;
 457 }
 458
 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
 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
 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  */
 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
 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
 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
 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
 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
 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                 printk(KERN_ERR "snd_ctl_led: unable to add card%d", card->number);
 681         }
 682 }
 683
 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
 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
 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");