Thomas Gleixner | d2912cb | 2019-06-04 10:11:33 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 2 | /* |
| 3 | * LED Class Core |
| 4 | * |
| 5 | * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu> |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 6 | * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com> |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 7 | */ |
| 8 | |
Richard Purdie | 3dc7b82 | 2006-05-15 09:44:17 -0700 | [diff] [blame] | 9 | #include <linux/ctype.h> |
Jacek Anaszewski | 0471330 | 2014-08-07 05:10:22 -0700 | [diff] [blame] | 10 | #include <linux/device.h> |
| 11 | #include <linux/err.h> |
| 12 | #include <linux/init.h> |
| 13 | #include <linux/kernel.h> |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 14 | #include <linux/leds.h> |
Jacek Anaszewski | 0471330 | 2014-08-07 05:10:22 -0700 | [diff] [blame] | 15 | #include <linux/list.h> |
| 16 | #include <linux/module.h> |
Andy Shevchenko | fd81d7e | 2019-08-22 18:19:28 +0300 | [diff] [blame] | 17 | #include <linux/property.h> |
Jacek Anaszewski | 0471330 | 2014-08-07 05:10:22 -0700 | [diff] [blame] | 18 | #include <linux/slab.h> |
| 19 | #include <linux/spinlock.h> |
| 20 | #include <linux/timer.h> |
David Lechner | eb1ce74 | 2016-09-16 14:16:49 -0500 | [diff] [blame] | 21 | #include <uapi/linux/uleds.h> |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 22 | #include <linux/of.h> |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 23 | #include "leds.h" |
| 24 | |
| 25 | static struct class *leds_class; |
Hans de Goede | abc3100 | 2023-01-20 12:45:17 +0100 | [diff] [blame] | 26 | static DEFINE_MUTEX(leds_lookup_lock); |
| 27 | static LIST_HEAD(leds_lookup_list); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 28 | |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 29 | static ssize_t brightness_show(struct device *dev, |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 30 | struct device_attribute *attr, char *buf) |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 31 | { |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 32 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 33 | |
| 34 | /* no lock needed for this */ |
Henrique de Moraes Holschuh | 29d76df | 2008-03-18 09:47:48 +0000 | [diff] [blame] | 35 | led_update_brightness(led_cdev); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 36 | |
Sven Wegener | dd8e5a2 | 2008-10-13 10:41:39 +0100 | [diff] [blame] | 37 | return sprintf(buf, "%u\n", led_cdev->brightness); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 38 | } |
| 39 | |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 40 | static ssize_t brightness_store(struct device *dev, |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 41 | struct device_attribute *attr, const char *buf, size_t size) |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 42 | { |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 43 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
Shuah Khan | 872b86b | 2012-05-29 15:07:26 -0700 | [diff] [blame] | 44 | unsigned long state; |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 45 | ssize_t ret; |
| 46 | |
| 47 | mutex_lock(&led_cdev->led_access); |
| 48 | |
| 49 | if (led_sysfs_is_disabled(led_cdev)) { |
| 50 | ret = -EBUSY; |
| 51 | goto unlock; |
| 52 | } |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 53 | |
Shuah Khan | 872b86b | 2012-05-29 15:07:26 -0700 | [diff] [blame] | 54 | ret = kstrtoul(buf, 10, &state); |
| 55 | if (ret) |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 56 | goto unlock; |
Richard Purdie | 3dc7b82 | 2006-05-15 09:44:17 -0700 | [diff] [blame] | 57 | |
Shuah Khan | 872b86b | 2012-05-29 15:07:26 -0700 | [diff] [blame] | 58 | if (state == LED_OFF) |
| 59 | led_trigger_remove(led_cdev); |
Jacek Anaszewski | 4d71a4a | 2014-11-14 02:50:18 -0800 | [diff] [blame] | 60 | led_set_brightness(led_cdev, state); |
Pavel Machek | 0db3791 | 2019-04-29 17:22:59 +0200 | [diff] [blame] | 61 | flush_work(&led_cdev->set_brightness_work); |
Németh Márton | 0013b23 | 2008-03-09 20:54:37 +0000 | [diff] [blame] | 62 | |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 63 | ret = size; |
| 64 | unlock: |
| 65 | mutex_unlock(&led_cdev->led_access); |
| 66 | return ret; |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 67 | } |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 68 | static DEVICE_ATTR_RW(brightness); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 69 | |
Jacek Anaszewski | 38419612 | 2014-08-07 05:10:24 -0700 | [diff] [blame] | 70 | static ssize_t max_brightness_show(struct device *dev, |
Guennadi Liakhovetski | 1bd465e | 2009-01-10 18:54:39 +0000 | [diff] [blame] | 71 | struct device_attribute *attr, char *buf) |
| 72 | { |
| 73 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
| 74 | |
| 75 | return sprintf(buf, "%u\n", led_cdev->max_brightness); |
| 76 | } |
Jacek Anaszewski | 38419612 | 2014-08-07 05:10:24 -0700 | [diff] [blame] | 77 | static DEVICE_ATTR_RO(max_brightness); |
Guennadi Liakhovetski | 1bd465e | 2009-01-10 18:54:39 +0000 | [diff] [blame] | 78 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 79 | #ifdef CONFIG_LEDS_TRIGGERS |
Akinobu Mita | 11f7000 | 2019-09-29 23:18:49 +0900 | [diff] [blame] | 80 | static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0); |
| 81 | static struct bin_attribute *led_trigger_bin_attrs[] = { |
| 82 | &bin_attr_trigger, |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 83 | NULL, |
| 84 | }; |
| 85 | static const struct attribute_group led_trigger_group = { |
Akinobu Mita | 11f7000 | 2019-09-29 23:18:49 +0900 | [diff] [blame] | 86 | .bin_attrs = led_trigger_bin_attrs, |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 87 | }; |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 88 | #endif |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 89 | |
| 90 | static struct attribute *led_class_attrs[] = { |
| 91 | &dev_attr_brightness.attr, |
| 92 | &dev_attr_max_brightness.attr, |
| 93 | NULL, |
| 94 | }; |
| 95 | |
| 96 | static const struct attribute_group led_group = { |
| 97 | .attrs = led_class_attrs, |
| 98 | }; |
| 99 | |
| 100 | static const struct attribute_group *led_groups[] = { |
| 101 | &led_group, |
| 102 | #ifdef CONFIG_LEDS_TRIGGERS |
| 103 | &led_trigger_group, |
| 104 | #endif |
| 105 | NULL, |
Florian Fainelli | 14b5d6d | 2010-03-10 18:32:18 +0100 | [diff] [blame] | 106 | }; |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 107 | |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 108 | #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED |
| 109 | static ssize_t brightness_hw_changed_show(struct device *dev, |
| 110 | struct device_attribute *attr, char *buf) |
| 111 | { |
| 112 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
| 113 | |
| 114 | if (led_cdev->brightness_hw_changed == -1) |
| 115 | return -ENODATA; |
| 116 | |
| 117 | return sprintf(buf, "%u\n", led_cdev->brightness_hw_changed); |
| 118 | } |
| 119 | |
| 120 | static DEVICE_ATTR_RO(brightness_hw_changed); |
| 121 | |
| 122 | static int led_add_brightness_hw_changed(struct led_classdev *led_cdev) |
| 123 | { |
| 124 | struct device *dev = led_cdev->dev; |
| 125 | int ret; |
| 126 | |
| 127 | ret = device_create_file(dev, &dev_attr_brightness_hw_changed); |
| 128 | if (ret) { |
| 129 | dev_err(dev, "Error creating brightness_hw_changed\n"); |
| 130 | return ret; |
| 131 | } |
| 132 | |
| 133 | led_cdev->brightness_hw_changed_kn = |
| 134 | sysfs_get_dirent(dev->kobj.sd, "brightness_hw_changed"); |
| 135 | if (!led_cdev->brightness_hw_changed_kn) { |
| 136 | dev_err(dev, "Error getting brightness_hw_changed kn\n"); |
| 137 | device_remove_file(dev, &dev_attr_brightness_hw_changed); |
| 138 | return -ENXIO; |
| 139 | } |
| 140 | |
| 141 | return 0; |
| 142 | } |
| 143 | |
| 144 | static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev) |
| 145 | { |
| 146 | sysfs_put(led_cdev->brightness_hw_changed_kn); |
| 147 | device_remove_file(led_cdev->dev, &dev_attr_brightness_hw_changed); |
| 148 | } |
| 149 | |
Abanoub Sameh | af0bfab | 2020-12-11 22:42:08 +0200 | [diff] [blame] | 150 | void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev, unsigned int brightness) |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 151 | { |
| 152 | if (WARN_ON(!led_cdev->brightness_hw_changed_kn)) |
| 153 | return; |
| 154 | |
| 155 | led_cdev->brightness_hw_changed = brightness; |
| 156 | sysfs_notify_dirent(led_cdev->brightness_hw_changed_kn); |
| 157 | } |
| 158 | EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed); |
| 159 | #else |
| 160 | static int led_add_brightness_hw_changed(struct led_classdev *led_cdev) |
| 161 | { |
| 162 | return 0; |
| 163 | } |
| 164 | static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev) |
| 165 | { |
| 166 | } |
| 167 | #endif |
| 168 | |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 169 | /** |
| 170 | * led_classdev_suspend - suspend an led_classdev. |
| 171 | * @led_cdev: the led_classdev to suspend. |
| 172 | */ |
| 173 | void led_classdev_suspend(struct led_classdev *led_cdev) |
| 174 | { |
| 175 | led_cdev->flags |= LED_SUSPENDED; |
Jacek Anaszewski | 81fe8e5 | 2015-10-07 11:10:41 +0200 | [diff] [blame] | 176 | led_set_brightness_nopm(led_cdev, 0); |
Kai-Heng Feng | 302a085 | 2020-07-02 13:45:00 +0800 | [diff] [blame] | 177 | flush_work(&led_cdev->set_brightness_work); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 178 | } |
| 179 | EXPORT_SYMBOL_GPL(led_classdev_suspend); |
| 180 | |
| 181 | /** |
| 182 | * led_classdev_resume - resume an led_classdev. |
| 183 | * @led_cdev: the led_classdev to resume. |
| 184 | */ |
| 185 | void led_classdev_resume(struct led_classdev *led_cdev) |
| 186 | { |
Jacek Anaszewski | 81fe8e5 | 2015-10-07 11:10:41 +0200 | [diff] [blame] | 187 | led_set_brightness_nopm(led_cdev, led_cdev->brightness); |
Jacek Anaszewski | 7aea838 | 2015-01-09 07:22:51 -0800 | [diff] [blame] | 188 | |
| 189 | if (led_cdev->flash_resume) |
| 190 | led_cdev->flash_resume(led_cdev); |
| 191 | |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 192 | led_cdev->flags &= ~LED_SUSPENDED; |
| 193 | } |
| 194 | EXPORT_SYMBOL_GPL(led_classdev_resume); |
| 195 | |
Grygorii Strashko | 084609b | 2015-04-24 14:57:10 +0300 | [diff] [blame] | 196 | #ifdef CONFIG_PM_SLEEP |
Shuah Khan | 73e1ab4 | 2013-06-20 12:08:44 -0700 | [diff] [blame] | 197 | static int led_suspend(struct device *dev) |
Richard Purdie | 859cb7f | 2009-01-08 17:55:03 +0000 | [diff] [blame] | 198 | { |
| 199 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
| 200 | |
| 201 | if (led_cdev->flags & LED_CORE_SUSPENDRESUME) |
| 202 | led_classdev_suspend(led_cdev); |
| 203 | |
| 204 | return 0; |
| 205 | } |
| 206 | |
| 207 | static int led_resume(struct device *dev) |
| 208 | { |
| 209 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
| 210 | |
| 211 | if (led_cdev->flags & LED_CORE_SUSPENDRESUME) |
| 212 | led_classdev_resume(led_cdev); |
| 213 | |
| 214 | return 0; |
| 215 | } |
Grygorii Strashko | 084609b | 2015-04-24 14:57:10 +0300 | [diff] [blame] | 216 | #endif |
Richard Purdie | 859cb7f | 2009-01-08 17:55:03 +0000 | [diff] [blame] | 217 | |
Grygorii Strashko | 084609b | 2015-04-24 14:57:10 +0300 | [diff] [blame] | 218 | static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume); |
Shuah Khan | 73e1ab4 | 2013-06-20 12:08:44 -0700 | [diff] [blame] | 219 | |
Hans de Goede | fafef58 | 2023-01-20 12:45:15 +0100 | [diff] [blame] | 220 | static struct led_classdev *led_module_get(struct device *led_dev) |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 221 | { |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 222 | struct led_classdev *led_cdev; |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 223 | |
| 224 | if (!led_dev) |
| 225 | return ERR_PTR(-EPROBE_DEFER); |
| 226 | |
| 227 | led_cdev = dev_get_drvdata(led_dev); |
| 228 | |
Hans de Goede | 4451109 | 2023-01-20 12:45:14 +0100 | [diff] [blame] | 229 | if (!try_module_get(led_cdev->dev->parent->driver->owner)) { |
| 230 | put_device(led_cdev->dev); |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 231 | return ERR_PTR(-ENODEV); |
Hans de Goede | 4451109 | 2023-01-20 12:45:14 +0100 | [diff] [blame] | 232 | } |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 233 | |
| 234 | return led_cdev; |
| 235 | } |
Hans de Goede | fafef58 | 2023-01-20 12:45:15 +0100 | [diff] [blame] | 236 | |
| 237 | /** |
| 238 | * of_led_get() - request a LED device via the LED framework |
| 239 | * @np: device node to get the LED device from |
| 240 | * @index: the index of the LED |
| 241 | * |
| 242 | * Returns the LED device parsed from the phandle specified in the "leds" |
| 243 | * property of a device tree node or a negative error-code on failure. |
| 244 | */ |
| 245 | struct led_classdev *of_led_get(struct device_node *np, int index) |
| 246 | { |
| 247 | struct device *led_dev; |
| 248 | struct device_node *led_node; |
| 249 | |
| 250 | led_node = of_parse_phandle(np, "leds", index); |
| 251 | if (!led_node) |
| 252 | return ERR_PTR(-ENOENT); |
| 253 | |
| 254 | led_dev = class_find_device_by_of_node(leds_class, led_node); |
| 255 | of_node_put(led_node); |
Miaoqian Lin | da1afe8 | 2022-12-20 16:18:07 +0400 | [diff] [blame] | 256 | put_device(led_dev); |
Hans de Goede | fafef58 | 2023-01-20 12:45:15 +0100 | [diff] [blame] | 257 | |
| 258 | return led_module_get(led_dev); |
| 259 | } |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 260 | EXPORT_SYMBOL_GPL(of_led_get); |
| 261 | |
| 262 | /** |
| 263 | * led_put() - release a LED device |
| 264 | * @led_cdev: LED device |
| 265 | */ |
| 266 | void led_put(struct led_classdev *led_cdev) |
| 267 | { |
| 268 | module_put(led_cdev->dev->parent->driver->owner); |
Hans de Goede | 4451109 | 2023-01-20 12:45:14 +0100 | [diff] [blame] | 269 | put_device(led_cdev->dev); |
Tomi Valkeinen | 699a8c7 | 2019-10-03 10:28:09 +0200 | [diff] [blame] | 270 | } |
| 271 | EXPORT_SYMBOL_GPL(led_put); |
| 272 | |
Jean-Jacques Hiblot | e389240 | 2019-10-03 10:28:10 +0200 | [diff] [blame] | 273 | static void devm_led_release(struct device *dev, void *res) |
| 274 | { |
| 275 | struct led_classdev **p = res; |
| 276 | |
| 277 | led_put(*p); |
| 278 | } |
| 279 | |
Hans de Goede | 537bdca | 2023-01-20 12:45:16 +0100 | [diff] [blame] | 280 | static struct led_classdev *__devm_led_get(struct device *dev, struct led_classdev *led) |
| 281 | { |
| 282 | struct led_classdev **dr; |
| 283 | |
| 284 | dr = devres_alloc(devm_led_release, sizeof(struct led_classdev *), GFP_KERNEL); |
| 285 | if (!dr) { |
| 286 | led_put(led); |
| 287 | return ERR_PTR(-ENOMEM); |
| 288 | } |
| 289 | |
| 290 | *dr = led; |
| 291 | devres_add(dev, dr); |
| 292 | |
| 293 | return led; |
| 294 | } |
| 295 | |
Jean-Jacques Hiblot | e389240 | 2019-10-03 10:28:10 +0200 | [diff] [blame] | 296 | /** |
| 297 | * devm_of_led_get - Resource-managed request of a LED device |
| 298 | * @dev: LED consumer |
| 299 | * @index: index of the LED to obtain in the consumer |
| 300 | * |
| 301 | * The device node of the device is parse to find the request LED device. |
| 302 | * The LED device returned from this function is automatically released |
| 303 | * on driver detach. |
| 304 | * |
| 305 | * @return a pointer to a LED device or ERR_PTR(errno) on failure. |
| 306 | */ |
| 307 | struct led_classdev *__must_check devm_of_led_get(struct device *dev, |
| 308 | int index) |
| 309 | { |
| 310 | struct led_classdev *led; |
Jean-Jacques Hiblot | e389240 | 2019-10-03 10:28:10 +0200 | [diff] [blame] | 311 | |
| 312 | if (!dev) |
| 313 | return ERR_PTR(-EINVAL); |
| 314 | |
Jean-Jacques Hiblot | e389240 | 2019-10-03 10:28:10 +0200 | [diff] [blame] | 315 | led = of_led_get(dev->of_node, index); |
| 316 | if (IS_ERR(led)) |
| 317 | return led; |
| 318 | |
Hans de Goede | 537bdca | 2023-01-20 12:45:16 +0100 | [diff] [blame] | 319 | return __devm_led_get(dev, led); |
Jean-Jacques Hiblot | e389240 | 2019-10-03 10:28:10 +0200 | [diff] [blame] | 320 | } |
| 321 | EXPORT_SYMBOL_GPL(devm_of_led_get); |
| 322 | |
Hans de Goede | abc3100 | 2023-01-20 12:45:17 +0100 | [diff] [blame] | 323 | /** |
| 324 | * led_get() - request a LED device via the LED framework |
| 325 | * @dev: device for which to get the LED device |
| 326 | * @con_id: name of the LED from the device's point of view |
| 327 | * |
| 328 | * @return a pointer to a LED device or ERR_PTR(errno) on failure. |
| 329 | */ |
| 330 | struct led_classdev *led_get(struct device *dev, char *con_id) |
| 331 | { |
| 332 | struct led_lookup_data *lookup; |
| 333 | const char *provider = NULL; |
| 334 | struct device *led_dev; |
| 335 | |
| 336 | mutex_lock(&leds_lookup_lock); |
| 337 | list_for_each_entry(lookup, &leds_lookup_list, list) { |
| 338 | if (!strcmp(lookup->dev_id, dev_name(dev)) && |
| 339 | !strcmp(lookup->con_id, con_id)) { |
| 340 | provider = kstrdup_const(lookup->provider, GFP_KERNEL); |
| 341 | break; |
| 342 | } |
| 343 | } |
| 344 | mutex_unlock(&leds_lookup_lock); |
| 345 | |
| 346 | if (!provider) |
| 347 | return ERR_PTR(-ENOENT); |
| 348 | |
| 349 | led_dev = class_find_device_by_name(leds_class, provider); |
| 350 | kfree_const(provider); |
| 351 | |
| 352 | return led_module_get(led_dev); |
| 353 | } |
| 354 | EXPORT_SYMBOL_GPL(led_get); |
| 355 | |
| 356 | /** |
| 357 | * devm_led_get() - request a LED device via the LED framework |
| 358 | * @dev: device for which to get the LED device |
| 359 | * @con_id: name of the LED from the device's point of view |
| 360 | * |
| 361 | * The LED device returned from this function is automatically released |
| 362 | * on driver detach. |
| 363 | * |
| 364 | * @return a pointer to a LED device or ERR_PTR(errno) on failure. |
| 365 | */ |
| 366 | struct led_classdev *devm_led_get(struct device *dev, char *con_id) |
| 367 | { |
| 368 | struct led_classdev *led; |
| 369 | |
| 370 | led = led_get(dev, con_id); |
| 371 | if (IS_ERR(led)) |
| 372 | return led; |
| 373 | |
| 374 | return __devm_led_get(dev, led); |
| 375 | } |
| 376 | EXPORT_SYMBOL_GPL(devm_led_get); |
| 377 | |
| 378 | /** |
| 379 | * led_add_lookup() - Add a LED lookup table entry |
| 380 | * @led_lookup: the lookup table entry to add |
| 381 | * |
| 382 | * Add a LED lookup table entry. On systems without devicetree the lookup table |
| 383 | * is used by led_get() to find LEDs. |
| 384 | */ |
| 385 | void led_add_lookup(struct led_lookup_data *led_lookup) |
| 386 | { |
| 387 | mutex_lock(&leds_lookup_lock); |
| 388 | list_add_tail(&led_lookup->list, &leds_lookup_list); |
| 389 | mutex_unlock(&leds_lookup_lock); |
| 390 | } |
| 391 | EXPORT_SYMBOL_GPL(led_add_lookup); |
| 392 | |
| 393 | /** |
| 394 | * led_remove_lookup() - Remove a LED lookup table entry |
| 395 | * @led_lookup: the lookup table entry to remove |
| 396 | */ |
| 397 | void led_remove_lookup(struct led_lookup_data *led_lookup) |
| 398 | { |
| 399 | mutex_lock(&leds_lookup_lock); |
| 400 | list_del(&led_lookup->list); |
| 401 | mutex_unlock(&leds_lookup_lock); |
| 402 | } |
| 403 | EXPORT_SYMBOL_GPL(led_remove_lookup); |
| 404 | |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 405 | static int led_classdev_next_name(const char *init_name, char *name, |
| 406 | size_t len) |
| 407 | { |
| 408 | unsigned int i = 0; |
| 409 | int ret = 0; |
Ricardo Ribalda Delgado | e5b5a61 | 2015-07-31 13:36:21 +0200 | [diff] [blame] | 410 | struct device *dev; |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 411 | |
| 412 | strlcpy(name, init_name, len); |
| 413 | |
Ricardo Ribalda Delgado | e5b5a61 | 2015-07-31 13:36:21 +0200 | [diff] [blame] | 414 | while ((ret < len) && |
Suzuki K Poulose | 6cda08a | 2019-07-23 23:18:32 +0100 | [diff] [blame] | 415 | (dev = class_find_device_by_name(leds_class, name))) { |
Ricardo Ribalda Delgado | e5b5a61 | 2015-07-31 13:36:21 +0200 | [diff] [blame] | 416 | put_device(dev); |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 417 | ret = snprintf(name, len, "%s_%u", init_name, ++i); |
Ricardo Ribalda Delgado | e5b5a61 | 2015-07-31 13:36:21 +0200 | [diff] [blame] | 418 | } |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 419 | |
| 420 | if (ret >= len) |
| 421 | return -ENOMEM; |
| 422 | |
| 423 | return i; |
| 424 | } |
| 425 | |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 426 | /** |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 427 | * led_classdev_register_ext - register a new object of led_classdev class |
| 428 | * with init data. |
Rafał Miłecki | 442c609 | 2017-03-06 06:19:44 +0100 | [diff] [blame] | 429 | * |
| 430 | * @parent: parent of LED device |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 431 | * @led_cdev: the led_classdev structure for this device. |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 432 | * @init_data: LED class device initialization data |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 433 | */ |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 434 | int led_classdev_register_ext(struct device *parent, |
| 435 | struct led_classdev *led_cdev, |
| 436 | struct led_init_data *init_data) |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 437 | { |
Jacek Anaszewski | bb4e9af | 2019-06-09 20:19:04 +0200 | [diff] [blame] | 438 | char composed_name[LED_MAX_NAME_SIZE]; |
| 439 | char final_name[LED_MAX_NAME_SIZE]; |
| 440 | const char *proposed_name = composed_name; |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 441 | int ret; |
| 442 | |
Jacek Anaszewski | bb4e9af | 2019-06-09 20:19:04 +0200 | [diff] [blame] | 443 | if (init_data) { |
| 444 | if (init_data->devname_mandatory && !init_data->devicename) { |
| 445 | dev_err(parent, "Mandatory device name is missing"); |
| 446 | return -EINVAL; |
| 447 | } |
| 448 | ret = led_compose_name(parent, init_data, composed_name); |
| 449 | if (ret < 0) |
| 450 | return ret; |
Marek Behún | c49d6ca | 2020-09-19 20:03:04 +0200 | [diff] [blame] | 451 | |
Eddie James | 4190663 | 2021-07-16 17:03:26 -0500 | [diff] [blame] | 452 | if (init_data->fwnode) { |
Marek Behún | c49d6ca | 2020-09-19 20:03:04 +0200 | [diff] [blame] | 453 | fwnode_property_read_string(init_data->fwnode, |
| 454 | "linux,default-trigger", |
| 455 | &led_cdev->default_trigger); |
Eddie James | 4190663 | 2021-07-16 17:03:26 -0500 | [diff] [blame] | 456 | |
| 457 | if (fwnode_property_present(init_data->fwnode, |
| 458 | "retain-state-shutdown")) |
| 459 | led_cdev->flags |= LED_RETAIN_AT_SHUTDOWN; |
| 460 | } |
Jacek Anaszewski | bb4e9af | 2019-06-09 20:19:04 +0200 | [diff] [blame] | 461 | } else { |
| 462 | proposed_name = led_cdev->name; |
| 463 | } |
| 464 | |
| 465 | ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name)); |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 466 | if (ret < 0) |
| 467 | return ret; |
| 468 | |
Luis Henriques | 6d71021 | 2018-05-23 23:22:21 +0100 | [diff] [blame] | 469 | mutex_init(&led_cdev->led_access); |
| 470 | mutex_lock(&led_cdev->led_access); |
Johan Hovold | d0d480c | 2014-06-25 10:08:44 -0700 | [diff] [blame] | 471 | led_cdev->dev = device_create_with_groups(leds_class, parent, 0, |
Jacek Anaszewski | bb4e9af | 2019-06-09 20:19:04 +0200 | [diff] [blame] | 472 | led_cdev, led_cdev->groups, "%s", final_name); |
Luis Henriques | 6d71021 | 2018-05-23 23:22:21 +0100 | [diff] [blame] | 473 | if (IS_ERR(led_cdev->dev)) { |
| 474 | mutex_unlock(&led_cdev->led_access); |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 475 | return PTR_ERR(led_cdev->dev); |
Luis Henriques | 6d71021 | 2018-05-23 23:22:21 +0100 | [diff] [blame] | 476 | } |
Sander Vanheule | 495b896 | 2021-11-13 22:11:13 +0100 | [diff] [blame] | 477 | if (init_data && init_data->fwnode) |
| 478 | device_set_node(led_cdev->dev, init_data->fwnode); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 479 | |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 480 | if (ret) |
Sakari Ailus | 6f06c7f | 2015-03-26 16:42:05 -0700 | [diff] [blame] | 481 | dev_warn(parent, "Led %s renamed to %s due to name collision", |
Ricardo Ribalda Delgado | 64ed658 | 2020-04-01 11:51:47 +0200 | [diff] [blame] | 482 | proposed_name, dev_name(led_cdev->dev)); |
Ricardo Ribalda Delgado | a96aa64 | 2015-03-30 10:45:59 -0700 | [diff] [blame] | 483 | |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 484 | if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) { |
| 485 | ret = led_add_brightness_hw_changed(led_cdev); |
| 486 | if (ret) { |
| 487 | device_unregister(led_cdev->dev); |
Andy Shevchenko | 1dbb9fb4 | 2019-08-16 13:52:29 +0300 | [diff] [blame] | 488 | led_cdev->dev = NULL; |
Luis Henriques | 6d71021 | 2018-05-23 23:22:21 +0100 | [diff] [blame] | 489 | mutex_unlock(&led_cdev->led_access); |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 490 | return ret; |
| 491 | } |
| 492 | } |
| 493 | |
Hans de Goede | a9c6ce5 | 2016-11-08 14:38:46 +0100 | [diff] [blame] | 494 | led_cdev->work_flags = 0; |
Richard Purdie | 270c395 | 2008-10-20 23:16:17 +0100 | [diff] [blame] | 495 | #ifdef CONFIG_LEDS_TRIGGERS |
| 496 | init_rwsem(&led_cdev->trigger_lock); |
| 497 | #endif |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 498 | #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED |
| 499 | led_cdev->brightness_hw_changed = -1; |
| 500 | #endif |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 501 | /* add to the list of leds */ |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 502 | down_write(&leds_list_lock); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 503 | list_add_tail(&led_cdev->node, &leds_list); |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 504 | up_write(&leds_list_lock); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 505 | |
Guennadi Liakhovetski | 1bd465e | 2009-01-10 18:54:39 +0000 | [diff] [blame] | 506 | if (!led_cdev->max_brightness) |
| 507 | led_cdev->max_brightness = LED_FULL; |
| 508 | |
Henrique de Moraes Holschuh | 29d76df | 2008-03-18 09:47:48 +0000 | [diff] [blame] | 509 | led_update_brightness(led_cdev); |
| 510 | |
Jacek Anaszewski | 757b06a | 2015-09-28 14:38:04 +0200 | [diff] [blame] | 511 | led_init_core(led_cdev); |
Johannes Berg | 5ada28b | 2010-11-11 14:05:21 -0800 | [diff] [blame] | 512 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 513 | #ifdef CONFIG_LEDS_TRIGGERS |
Jeff Garzik | 12fda16 | 2006-10-17 00:10:20 -0700 | [diff] [blame] | 514 | led_trigger_set_default(led_cdev); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 515 | #endif |
| 516 | |
Luis Henriques | 6d71021 | 2018-05-23 23:22:21 +0100 | [diff] [blame] | 517 | mutex_unlock(&led_cdev->led_access); |
| 518 | |
Sachin Kamat | d23e7b8 | 2012-11-25 10:57:35 +0530 | [diff] [blame] | 519 | dev_dbg(parent, "Registered led device: %s\n", |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 520 | led_cdev->name); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 521 | |
| 522 | return 0; |
| 523 | } |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 524 | EXPORT_SYMBOL_GPL(led_classdev_register_ext); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 525 | |
| 526 | /** |
Qinghuang Feng | 0266a45 | 2008-10-20 23:04:36 +0100 | [diff] [blame] | 527 | * led_classdev_unregister - unregisters a object of led_properties class. |
Henrik Kretzschmar | 70d63cc | 2006-10-03 23:31:30 +0200 | [diff] [blame] | 528 | * @led_cdev: the led device to unregister |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 529 | * |
| 530 | * Unregisters a previously registered via led_classdev_register object. |
| 531 | */ |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 532 | void led_classdev_unregister(struct led_classdev *led_cdev) |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 533 | { |
Andy Shevchenko | 1dbb9fb4 | 2019-08-16 13:52:29 +0300 | [diff] [blame] | 534 | if (IS_ERR_OR_NULL(led_cdev->dev)) |
| 535 | return; |
| 536 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 537 | #ifdef CONFIG_LEDS_TRIGGERS |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 538 | down_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 539 | if (led_cdev->trigger) |
| 540 | led_trigger_set(led_cdev, NULL); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 541 | up_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 542 | #endif |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 543 | |
Heiner Kallweit | d84d80f3 | 2016-01-22 21:43:48 +0100 | [diff] [blame] | 544 | led_cdev->flags |= LED_UNREGISTERING; |
| 545 | |
Johannes Berg | 5ada28b | 2010-11-11 14:05:21 -0800 | [diff] [blame] | 546 | /* Stop blinking */ |
Fabio Baltieri | d23a22a | 2012-08-15 21:44:34 +0800 | [diff] [blame] | 547 | led_stop_software_blink(led_cdev); |
Milo Kim | d1aa577 | 2015-11-20 17:03:00 +0900 | [diff] [blame] | 548 | |
Eddie James | 4190663 | 2021-07-16 17:03:26 -0500 | [diff] [blame] | 549 | if (!(led_cdev->flags & LED_RETAIN_AT_SHUTDOWN)) |
| 550 | led_set_brightness(led_cdev, LED_OFF); |
Johannes Berg | 5ada28b | 2010-11-11 14:05:21 -0800 | [diff] [blame] | 551 | |
Milo Kim | d1aa577 | 2015-11-20 17:03:00 +0900 | [diff] [blame] | 552 | flush_work(&led_cdev->set_brightness_work); |
| 553 | |
Hans de Goede | 0cb8eb3 | 2017-01-29 14:42:52 +0100 | [diff] [blame] | 554 | if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) |
| 555 | led_remove_brightness_hw_changed(led_cdev); |
| 556 | |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 557 | device_unregister(led_cdev->dev); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 558 | |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 559 | down_write(&leds_list_lock); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 560 | list_del(&led_cdev->node); |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 561 | up_write(&leds_list_lock); |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 562 | |
| 563 | mutex_destroy(&led_cdev->led_access); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 564 | } |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 565 | EXPORT_SYMBOL_GPL(led_classdev_unregister); |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 566 | |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 567 | static void devm_led_classdev_release(struct device *dev, void *res) |
| 568 | { |
| 569 | led_classdev_unregister(*(struct led_classdev **)res); |
| 570 | } |
| 571 | |
| 572 | /** |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 573 | * devm_led_classdev_register_ext - resource managed led_classdev_register_ext() |
Rafał Miłecki | 442c609 | 2017-03-06 06:19:44 +0100 | [diff] [blame] | 574 | * |
| 575 | * @parent: parent of LED device |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 576 | * @led_cdev: the led_classdev structure for this device. |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 577 | * @init_data: LED class device initialization data |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 578 | */ |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 579 | int devm_led_classdev_register_ext(struct device *parent, |
| 580 | struct led_classdev *led_cdev, |
| 581 | struct led_init_data *init_data) |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 582 | { |
| 583 | struct led_classdev **dr; |
| 584 | int rc; |
| 585 | |
| 586 | dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL); |
| 587 | if (!dr) |
| 588 | return -ENOMEM; |
| 589 | |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 590 | rc = led_classdev_register_ext(parent, led_cdev, init_data); |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 591 | if (rc) { |
| 592 | devres_free(dr); |
| 593 | return rc; |
| 594 | } |
| 595 | |
| 596 | *dr = led_cdev; |
| 597 | devres_add(parent, dr); |
| 598 | |
| 599 | return 0; |
| 600 | } |
Jacek Anaszewski | b2b998c | 2019-06-09 20:19:03 +0200 | [diff] [blame] | 601 | EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext); |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 602 | |
| 603 | static int devm_led_classdev_match(struct device *dev, void *res, void *data) |
| 604 | { |
Dan Murphy | 4b83cf0 | 2019-10-02 07:40:41 -0500 | [diff] [blame] | 605 | struct led_classdev **p = res; |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 606 | |
| 607 | if (WARN_ON(!p || !*p)) |
| 608 | return 0; |
| 609 | |
| 610 | return *p == data; |
| 611 | } |
| 612 | |
| 613 | /** |
| 614 | * devm_led_classdev_unregister() - resource managed led_classdev_unregister() |
Lee Jones | 6a3a871 | 2021-05-28 10:06:17 +0100 | [diff] [blame] | 615 | * @dev: The device to unregister. |
Bjorn Andersson | ca1bb4e | 2015-02-23 16:11:41 -0800 | [diff] [blame] | 616 | * @led_cdev: the led_classdev structure for this device. |
| 617 | */ |
| 618 | void devm_led_classdev_unregister(struct device *dev, |
| 619 | struct led_classdev *led_cdev) |
| 620 | { |
| 621 | WARN_ON(devres_release(dev, |
| 622 | devm_led_classdev_release, |
| 623 | devm_led_classdev_match, led_cdev)); |
| 624 | } |
| 625 | EXPORT_SYMBOL_GPL(devm_led_classdev_unregister); |
| 626 | |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 627 | static int __init leds_init(void) |
| 628 | { |
| 629 | leds_class = class_create(THIS_MODULE, "leds"); |
| 630 | if (IS_ERR(leds_class)) |
| 631 | return PTR_ERR(leds_class); |
Shuah Khan | 73e1ab4 | 2013-06-20 12:08:44 -0700 | [diff] [blame] | 632 | leds_class->pm = &leds_class_dev_pm_ops; |
Greg Kroah-Hartman | 5baa750 | 2013-07-24 15:05:13 -0700 | [diff] [blame] | 633 | leds_class->dev_groups = led_groups; |
Richard Purdie | c72a1d6 | 2006-03-31 02:31:04 -0800 | [diff] [blame] | 634 | return 0; |
| 635 | } |
| 636 | |
| 637 | static void __exit leds_exit(void) |
| 638 | { |
| 639 | class_destroy(leds_class); |
| 640 | } |
| 641 | |
| 642 | subsys_initcall(leds_init); |
| 643 | module_exit(leds_exit); |
| 644 | |
| 645 | MODULE_AUTHOR("John Lenz, Richard Purdie"); |
| 646 | MODULE_LICENSE("GPL"); |
| 647 | MODULE_DESCRIPTION("LED Class Interface"); |