drivers/leds/led-class.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * LED Class Core
   4  *
   5  * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
   6  * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
   7  */
   8
   9 #include <linux/ctype.h>
  10 #include <linux/device.h>
  11 #include <linux/err.h>
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/leds.h>
  15 #include <linux/list.h>
  16 #include <linux/module.h>
  17 #include <linux/property.h>
  18 #include <linux/slab.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/timer.h>
  21 #include <uapi/linux/uleds.h>
  22 #include <linux/of.h>
  23 #include "leds.h"
  24
  25 static DEFINE_MUTEX(leds_lookup_lock);
  26 static LIST_HEAD(leds_lookup_list);
  27
  28 static struct workqueue_struct *leds_wq;
  29
  30 static ssize_t brightness_show(struct device *dev,
  31                 struct device_attribute *attr, char *buf)
  32 {
  33         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  34         unsigned int brightness;
  35
  36         mutex_lock(&led_cdev->led_access);
  37         led_update_brightness(led_cdev);
  38         brightness = led_cdev->brightness;
  39         mutex_unlock(&led_cdev->led_access);
  40
  41         return sprintf(buf, "%u\n", brightness);
  42 }
  43
  44 static ssize_t brightness_store(struct device *dev,
  45                 struct device_attribute *attr, const char *buf, size_t size)
  46 {
  47         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  48         unsigned long state;
  49         ssize_t ret;
  50
  51         mutex_lock(&led_cdev->led_access);
  52
  53         if (led_sysfs_is_disabled(led_cdev)) {
  54                 ret = -EBUSY;
  55                 goto unlock;
  56         }
  57
  58         ret = kstrtoul(buf, 10, &state);
  59         if (ret)
  60                 goto unlock;
  61
  62         if (state == LED_OFF)
  63                 led_trigger_remove(led_cdev);
  64         led_set_brightness(led_cdev, state);
  65
  66         ret = size;
  67 unlock:
  68         mutex_unlock(&led_cdev->led_access);
  69         return ret;
  70 }
  71 static DEVICE_ATTR_RW(brightness);
  72
  73 static ssize_t max_brightness_show(struct device *dev,
  74                 struct device_attribute *attr, char *buf)
  75 {
  76         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  77         unsigned int max_brightness;
  78
  79         mutex_lock(&led_cdev->led_access);
  80         max_brightness = led_cdev->max_brightness;
  81         mutex_unlock(&led_cdev->led_access);
  82
  83         return sprintf(buf, "%u\n", max_brightness);
  84 }
  85 static DEVICE_ATTR_RO(max_brightness);
  86
  87 #ifdef CONFIG_LEDS_TRIGGERS
  88 static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0);
  89 static struct bin_attribute *led_trigger_bin_attrs[] = {
  90         &bin_attr_trigger,
  91         NULL,
  92 };
  93 static const struct attribute_group led_trigger_group = {
  94         .bin_attrs = led_trigger_bin_attrs,
  95 };
  96 #endif
  97
  98 static struct attribute *led_class_attrs[] = {
  99         &dev_attr_brightness.attr,
 100         &dev_attr_max_brightness.attr,
 101         NULL,
 102 };
 103
 104 static const struct attribute_group led_group = {
 105         .attrs = led_class_attrs,
 106 };
 107
 108 static const struct attribute_group *led_groups[] = {
 109         &led_group,
 110 #ifdef CONFIG_LEDS_TRIGGERS
 111         &led_trigger_group,
 112 #endif
 113         NULL,
 114 };
 115
 116 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
 117 static ssize_t brightness_hw_changed_show(struct device *dev,
 118                 struct device_attribute *attr, char *buf)
 119 {
 120         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 121
 122         if (led_cdev->brightness_hw_changed == -1)
 123                 return -ENODATA;
 124
 125         return sprintf(buf, "%u\n", led_cdev->brightness_hw_changed);
 126 }
 127
 128 static DEVICE_ATTR_RO(brightness_hw_changed);
 129
 130 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
 131 {
 132         struct device *dev = led_cdev->dev;
 133         int ret;
 134
 135         ret = device_create_file(dev, &dev_attr_brightness_hw_changed);
 136         if (ret) {
 137                 dev_err(dev, "Error creating brightness_hw_changed\n");
 138                 return ret;
 139         }
 140
 141         led_cdev->brightness_hw_changed_kn =
 142                 sysfs_get_dirent(dev->kobj.sd, "brightness_hw_changed");
 143         if (!led_cdev->brightness_hw_changed_kn) {
 144                 dev_err(dev, "Error getting brightness_hw_changed kn\n");
 145                 device_remove_file(dev, &dev_attr_brightness_hw_changed);
 146                 return -ENXIO;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
 153 {
 154         sysfs_put(led_cdev->brightness_hw_changed_kn);
 155         device_remove_file(led_cdev->dev, &dev_attr_brightness_hw_changed);
 156 }
 157
 158 void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev, unsigned int brightness)
 159 {
 160         if (WARN_ON(!led_cdev->brightness_hw_changed_kn))
 161                 return;
 162
 163         led_cdev->brightness_hw_changed = brightness;
 164         sysfs_notify_dirent(led_cdev->brightness_hw_changed_kn);
 165 }
 166 EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed);
 167 #else
 168 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
 169 {
 170         return 0;
 171 }
 172 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
 173 {
 174 }
 175 #endif
 176
 177 /**
 178  * led_classdev_suspend - suspend an led_classdev.
 179  * @led_cdev: the led_classdev to suspend.
 180  */
 181 void led_classdev_suspend(struct led_classdev *led_cdev)
 182 {
 183         led_cdev->flags |= LED_SUSPENDED;
 184         led_set_brightness_nopm(led_cdev, 0);
 185         flush_work(&led_cdev->set_brightness_work);
 186 }
 187 EXPORT_SYMBOL_GPL(led_classdev_suspend);
 188
 189 /**
 190  * led_classdev_resume - resume an led_classdev.
 191  * @led_cdev: the led_classdev to resume.
 192  */
 193 void led_classdev_resume(struct led_classdev *led_cdev)
 194 {
 195         led_set_brightness_nopm(led_cdev, led_cdev->brightness);
 196
 197         if (led_cdev->flash_resume)
 198                 led_cdev->flash_resume(led_cdev);
 199
 200         led_cdev->flags &= ~LED_SUSPENDED;
 201 }
 202 EXPORT_SYMBOL_GPL(led_classdev_resume);
 203
 204 #ifdef CONFIG_PM_SLEEP
 205 static int led_suspend(struct device *dev)
 206 {
 207         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 208
 209         if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
 210                 led_classdev_suspend(led_cdev);
 211
 212         return 0;
 213 }
 214
 215 static int led_resume(struct device *dev)
 216 {
 217         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 218
 219         if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
 220                 led_classdev_resume(led_cdev);
 221
 222         return 0;
 223 }
 224 #endif
 225
 226 static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
 227
 228 static struct led_classdev *led_module_get(struct device *led_dev)
 229 {
 230         struct led_classdev *led_cdev;
 231
 232         if (!led_dev)
 233                 return ERR_PTR(-EPROBE_DEFER);
 234
 235         led_cdev = dev_get_drvdata(led_dev);
 236
 237         if (!try_module_get(led_cdev->dev->parent->driver->owner)) {
 238                 put_device(led_cdev->dev);
 239                 return ERR_PTR(-ENODEV);
 240         }
 241
 242         return led_cdev;
 243 }
 244
 245 static const struct class leds_class = {
 246         .name = "leds",
 247         .dev_groups = led_groups,
 248         .pm = &leds_class_dev_pm_ops,
 249 };
 250
 251 /**
 252  * of_led_get() - request a LED device via the LED framework
 253  * @np: device node to get the LED device from
 254  * @index: the index of the LED
 255  *
 256  * Returns the LED device parsed from the phandle specified in the "leds"
 257  * property of a device tree node or a negative error-code on failure.
 258  */
 259 struct led_classdev *of_led_get(struct device_node *np, int index)
 260 {
 261         struct device *led_dev;
 262         struct device_node *led_node;
 263
 264         led_node = of_parse_phandle(np, "leds", index);
 265         if (!led_node)
 266                 return ERR_PTR(-ENOENT);
 267
 268         led_dev = class_find_device_by_of_node(&leds_class, led_node);
 269         of_node_put(led_node);
 270
 271         return led_module_get(led_dev);
 272 }
 273 EXPORT_SYMBOL_GPL(of_led_get);
 274
 275 /**
 276  * led_put() - release a LED device
 277  * @led_cdev: LED device
 278  */
 279 void led_put(struct led_classdev *led_cdev)
 280 {
 281         module_put(led_cdev->dev->parent->driver->owner);
 282         put_device(led_cdev->dev);
 283 }
 284 EXPORT_SYMBOL_GPL(led_put);
 285
 286 static void devm_led_release(struct device *dev, void *res)
 287 {
 288         struct led_classdev **p = res;
 289
 290         led_put(*p);
 291 }
 292
 293 static struct led_classdev *__devm_led_get(struct device *dev, struct led_classdev *led)
 294 {
 295         struct led_classdev **dr;
 296
 297         dr = devres_alloc(devm_led_release, sizeof(struct led_classdev *), GFP_KERNEL);
 298         if (!dr) {
 299                 led_put(led);
 300                 return ERR_PTR(-ENOMEM);
 301         }
 302
 303         *dr = led;
 304         devres_add(dev, dr);
 305
 306         return led;
 307 }
 308
 309 /**
 310  * devm_of_led_get - Resource-managed request of a LED device
 311  * @dev:        LED consumer
 312  * @index:      index of the LED to obtain in the consumer
 313  *
 314  * The device node of the device is parse to find the request LED device.
 315  * The LED device returned from this function is automatically released
 316  * on driver detach.
 317  *
 318  * @return a pointer to a LED device or ERR_PTR(errno) on failure.
 319  */
 320 struct led_classdev *__must_check devm_of_led_get(struct device *dev,
 321                                                   int index)
 322 {
 323         struct led_classdev *led;
 324
 325         if (!dev)
 326                 return ERR_PTR(-EINVAL);
 327
 328         led = of_led_get(dev->of_node, index);
 329         if (IS_ERR(led))
 330                 return led;
 331
 332         return __devm_led_get(dev, led);
 333 }
 334 EXPORT_SYMBOL_GPL(devm_of_led_get);
 335
 336 /**
 337  * led_get() - request a LED device via the LED framework
 338  * @dev: device for which to get the LED device
 339  * @con_id: name of the LED from the device's point of view
 340  *
 341  * @return a pointer to a LED device or ERR_PTR(errno) on failure.
 342  */
 343 struct led_classdev *led_get(struct device *dev, char *con_id)
 344 {
 345         struct led_lookup_data *lookup;
 346         const char *provider = NULL;
 347         struct device *led_dev;
 348
 349         mutex_lock(&leds_lookup_lock);
 350         list_for_each_entry(lookup, &leds_lookup_list, list) {
 351                 if (!strcmp(lookup->dev_id, dev_name(dev)) &&
 352                     !strcmp(lookup->con_id, con_id)) {
 353                         provider = kstrdup_const(lookup->provider, GFP_KERNEL);
 354                         break;
 355                 }
 356         }
 357         mutex_unlock(&leds_lookup_lock);
 358
 359         if (!provider)
 360                 return ERR_PTR(-ENOENT);
 361
 362         led_dev = class_find_device_by_name(&leds_class, provider);
 363         kfree_const(provider);
 364
 365         return led_module_get(led_dev);
 366 }
 367 EXPORT_SYMBOL_GPL(led_get);
 368
 369 /**
 370  * devm_led_get() - request a LED device via the LED framework
 371  * @dev: device for which to get the LED device
 372  * @con_id: name of the LED from the device's point of view
 373  *
 374  * The LED device returned from this function is automatically released
 375  * on driver detach.
 376  *
 377  * @return a pointer to a LED device or ERR_PTR(errno) on failure.
 378  */
 379 struct led_classdev *devm_led_get(struct device *dev, char *con_id)
 380 {
 381         struct led_classdev *led;
 382
 383         led = led_get(dev, con_id);
 384         if (IS_ERR(led))
 385                 return led;
 386
 387         return __devm_led_get(dev, led);
 388 }
 389 EXPORT_SYMBOL_GPL(devm_led_get);
 390
 391 /**
 392  * led_add_lookup() - Add a LED lookup table entry
 393  * @led_lookup: the lookup table entry to add
 394  *
 395  * Add a LED lookup table entry. On systems without devicetree the lookup table
 396  * is used by led_get() to find LEDs.
 397  */
 398 void led_add_lookup(struct led_lookup_data *led_lookup)
 399 {
 400         mutex_lock(&leds_lookup_lock);
 401         list_add_tail(&led_lookup->list, &leds_lookup_list);
 402         mutex_unlock(&leds_lookup_lock);
 403 }
 404 EXPORT_SYMBOL_GPL(led_add_lookup);
 405
 406 /**
 407  * led_remove_lookup() - Remove a LED lookup table entry
 408  * @led_lookup: the lookup table entry to remove
 409  */
 410 void led_remove_lookup(struct led_lookup_data *led_lookup)
 411 {
 412         mutex_lock(&leds_lookup_lock);
 413         list_del(&led_lookup->list);
 414         mutex_unlock(&leds_lookup_lock);
 415 }
 416 EXPORT_SYMBOL_GPL(led_remove_lookup);
 417
 418 /**
 419  * devm_of_led_get_optional - Resource-managed request of an optional LED device
 420  * @dev:        LED consumer
 421  * @index:      index of the LED to obtain in the consumer
 422  *
 423  * The device node of the device is parsed to find the requested LED device.
 424  * The LED device returned from this function is automatically released
 425  * on driver detach.
 426  *
 427  * @return a pointer to a LED device, ERR_PTR(errno) on failure and NULL if the
 428  * led was not found.
 429  */
 430 struct led_classdev *__must_check devm_of_led_get_optional(struct device *dev,
 431                                                         int index)
 432 {
 433         struct led_classdev *led;
 434
 435         led = devm_of_led_get(dev, index);
 436         if (IS_ERR(led) && PTR_ERR(led) == -ENOENT)
 437                 return NULL;
 438
 439         return led;
 440 }
 441 EXPORT_SYMBOL_GPL(devm_of_led_get_optional);
 442
 443 static int led_classdev_next_name(const char *init_name, char *name,
 444                                   size_t len)
 445 {
 446         unsigned int i = 0;
 447         int ret = 0;
 448         struct device *dev;
 449
 450         strscpy(name, init_name, len);
 451
 452         while ((ret < len) &&
 453                (dev = class_find_device_by_name(&leds_class, name))) {
 454                 put_device(dev);
 455                 ret = snprintf(name, len, "%s_%u", init_name, ++i);
 456         }
 457
 458         if (ret >= len)
 459                 return -ENOMEM;
 460
 461         return i;
 462 }
 463
 464 /**
 465  * led_classdev_register_ext - register a new object of led_classdev class
 466  *                             with init data.
 467  *
 468  * @parent: parent of LED device
 469  * @led_cdev: the led_classdev structure for this device.
 470  * @init_data: LED class device initialization data
 471  */
 472 int led_classdev_register_ext(struct device *parent,
 473                               struct led_classdev *led_cdev,
 474                               struct led_init_data *init_data)
 475 {
 476         char composed_name[LED_MAX_NAME_SIZE];
 477         char final_name[LED_MAX_NAME_SIZE];
 478         const char *proposed_name = composed_name;
 479         int ret;
 480
 481         if (init_data) {
 482                 if (init_data->devname_mandatory && !init_data->devicename) {
 483                         dev_err(parent, "Mandatory device name is missing");
 484                         return -EINVAL;
 485                 }
 486                 ret = led_compose_name(parent, init_data, composed_name);
 487                 if (ret < 0)
 488                         return ret;
 489
 490                 if (init_data->fwnode) {
 491                         fwnode_property_read_string(init_data->fwnode,
 492                                 "linux,default-trigger",
 493                                 &led_cdev->default_trigger);
 494
 495                         if (fwnode_property_present(init_data->fwnode,
 496                                                     "retain-state-shutdown"))
 497                                 led_cdev->flags |= LED_RETAIN_AT_SHUTDOWN;
 498
 499                         fwnode_property_read_u32(init_data->fwnode,
 500                                 "max-brightness",
 501                                 &led_cdev->max_brightness);
 502
 503                         if (fwnode_property_present(init_data->fwnode, "color"))
 504                                 fwnode_property_read_u32(init_data->fwnode, "color",
 505                                                          &led_cdev->color);
 506                 }
 507         } else {
 508                 proposed_name = led_cdev->name;
 509         }
 510
 511         ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
 512         if (ret < 0)
 513                 return ret;
 514         else if (ret && led_cdev->flags & LED_REJECT_NAME_CONFLICT)
 515                 return -EEXIST;
 516         else if (ret)
 517                 dev_warn(parent, "Led %s renamed to %s due to name collision\n",
 518                          proposed_name, final_name);
 519
 520         if (led_cdev->color >= LED_COLOR_ID_MAX)
 521                 dev_warn(parent, "LED %s color identifier out of range\n", final_name);
 522
 523         mutex_init(&led_cdev->led_access);
 524         mutex_lock(&led_cdev->led_access);
 525         led_cdev->dev = device_create_with_groups(&leds_class, parent, 0,
 526                                                   led_cdev, led_cdev->groups, "%s", final_name);
 527         if (IS_ERR(led_cdev->dev)) {
 528                 mutex_unlock(&led_cdev->led_access);
 529                 return PTR_ERR(led_cdev->dev);
 530         }
 531         if (init_data && init_data->fwnode)
 532                 device_set_node(led_cdev->dev, init_data->fwnode);
 533
 534         if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) {
 535                 ret = led_add_brightness_hw_changed(led_cdev);
 536                 if (ret) {
 537                         device_unregister(led_cdev->dev);
 538                         led_cdev->dev = NULL;
 539                         mutex_unlock(&led_cdev->led_access);
 540                         return ret;
 541                 }
 542         }
 543
 544         led_cdev->work_flags = 0;
 545 #ifdef CONFIG_LEDS_TRIGGERS
 546         init_rwsem(&led_cdev->trigger_lock);
 547 #endif
 548 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
 549         led_cdev->brightness_hw_changed = -1;
 550 #endif
 551         /* add to the list of leds */
 552         down_write(&leds_list_lock);
 553         list_add_tail(&led_cdev->node, &leds_list);
 554         up_write(&leds_list_lock);
 555
 556         if (!led_cdev->max_brightness)
 557                 led_cdev->max_brightness = LED_FULL;
 558
 559         led_update_brightness(led_cdev);
 560
 561         led_cdev->wq = leds_wq;
 562
 563         led_init_core(led_cdev);
 564
 565 #ifdef CONFIG_LEDS_TRIGGERS
 566         led_trigger_set_default(led_cdev);
 567 #endif
 568
 569         mutex_unlock(&led_cdev->led_access);
 570
 571         dev_dbg(parent, "Registered led device: %s\n",
 572                         led_cdev->name);
 573
 574         return 0;
 575 }
 576 EXPORT_SYMBOL_GPL(led_classdev_register_ext);
 577
 578 /**
 579  * led_classdev_unregister - unregisters a object of led_properties class.
 580  * @led_cdev: the led device to unregister
 581  *
 582  * Unregisters a previously registered via led_classdev_register object.
 583  */
 584 void led_classdev_unregister(struct led_classdev *led_cdev)
 585 {
 586         if (IS_ERR_OR_NULL(led_cdev->dev))
 587                 return;
 588
 589 #ifdef CONFIG_LEDS_TRIGGERS
 590         down_write(&led_cdev->trigger_lock);
 591         if (led_cdev->trigger)
 592                 led_trigger_set(led_cdev, NULL);
 593         up_write(&led_cdev->trigger_lock);
 594 #endif
 595
 596         led_cdev->flags |= LED_UNREGISTERING;
 597
 598         /* Stop blinking */
 599         led_stop_software_blink(led_cdev);
 600
 601         if (!(led_cdev->flags & LED_RETAIN_AT_SHUTDOWN))
 602                 led_set_brightness(led_cdev, LED_OFF);
 603
 604         flush_work(&led_cdev->set_brightness_work);
 605
 606         if (led_cdev->flags & LED_BRIGHT_HW_CHANGED)
 607                 led_remove_brightness_hw_changed(led_cdev);
 608
 609         device_unregister(led_cdev->dev);
 610
 611         down_write(&leds_list_lock);
 612         list_del(&led_cdev->node);
 613         up_write(&leds_list_lock);
 614
 615         mutex_destroy(&led_cdev->led_access);
 616 }
 617 EXPORT_SYMBOL_GPL(led_classdev_unregister);
 618
 619 static void devm_led_classdev_release(struct device *dev, void *res)
 620 {
 621         led_classdev_unregister(*(struct led_classdev **)res);
 622 }
 623
 624 /**
 625  * devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
 626  *
 627  * @parent: parent of LED device
 628  * @led_cdev: the led_classdev structure for this device.
 629  * @init_data: LED class device initialization data
 630  */
 631 int devm_led_classdev_register_ext(struct device *parent,
 632                                    struct led_classdev *led_cdev,
 633                                    struct led_init_data *init_data)
 634 {
 635         struct led_classdev **dr;
 636         int rc;
 637
 638         dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
 639         if (!dr)
 640                 return -ENOMEM;
 641
 642         rc = led_classdev_register_ext(parent, led_cdev, init_data);
 643         if (rc) {
 644                 devres_free(dr);
 645                 return rc;
 646         }
 647
 648         *dr = led_cdev;
 649         devres_add(parent, dr);
 650
 651         return 0;
 652 }
 653 EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
 654
 655 static int devm_led_classdev_match(struct device *dev, void *res, void *data)
 656 {
 657         struct led_classdev **p = res;
 658
 659         if (WARN_ON(!p || !*p))
 660                 return 0;
 661
 662         return *p == data;
 663 }
 664
 665 /**
 666  * devm_led_classdev_unregister() - resource managed led_classdev_unregister()
 667  * @dev: The device to unregister.
 668  * @led_cdev: the led_classdev structure for this device.
 669  */
 670 void devm_led_classdev_unregister(struct device *dev,
 671                                   struct led_classdev *led_cdev)
 672 {
 673         WARN_ON(devres_release(dev,
 674                                devm_led_classdev_release,
 675                                devm_led_classdev_match, led_cdev));
 676 }
 677 EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
 678
 679 static int __init leds_init(void)
 680 {
 681         leds_wq = alloc_ordered_workqueue("leds", 0);
 682         if (!leds_wq) {
 683                 pr_err("Failed to create LEDs ordered workqueue\n");
 684                 return -ENOMEM;
 685         }
 686
 687         return class_register(&leds_class);
 688 }
 689
 690 static void __exit leds_exit(void)
 691 {
 692         class_unregister(&leds_class);
 693         destroy_workqueue(leds_wq);
 694 }
 695
 696 subsys_initcall(leds_init);
 697 module_exit(leds_exit);
 698
 699 MODULE_AUTHOR("John Lenz, Richard Purdie");
 700 MODULE_LICENSE("GPL");
 701 MODULE_DESCRIPTION("LED Class Interface");