blob: a6b3adcd044a01e4e25d95de72680f213eb083be [file] [log] [blame]
Thomas Gleixnerd2912cb2019-06-04 10:11:33 +02001// SPDX-License-Identifier: GPL-2.0-only
Richard Purdiec72a1d62006-03-31 02:31:04 -08002/*
3 * LED Class Core
4 *
5 * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
Richard Purdief8a7c6f2007-07-08 23:19:31 +01006 * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
Richard Purdiec72a1d62006-03-31 02:31:04 -08007 */
8
Richard Purdie3dc7b822006-05-15 09:44:17 -07009#include <linux/ctype.h>
Jacek Anaszewski04713302014-08-07 05:10:22 -070010#include <linux/device.h>
11#include <linux/err.h>
12#include <linux/init.h>
13#include <linux/kernel.h>
Richard Purdiec72a1d62006-03-31 02:31:04 -080014#include <linux/leds.h>
Jacek Anaszewski04713302014-08-07 05:10:22 -070015#include <linux/list.h>
16#include <linux/module.h>
Andy Shevchenkofd81d7e2019-08-22 18:19:28 +030017#include <linux/property.h>
Jacek Anaszewski04713302014-08-07 05:10:22 -070018#include <linux/slab.h>
19#include <linux/spinlock.h>
20#include <linux/timer.h>
David Lechnereb1ce742016-09-16 14:16:49 -050021#include <uapi/linux/uleds.h>
Tomi Valkeinen699a8c72019-10-03 10:28:09 +020022#include <linux/of.h>
Richard Purdiec72a1d62006-03-31 02:31:04 -080023#include "leds.h"
24
25static struct class *leds_class;
Hans de Goedeabc31002023-01-20 12:45:17 +010026static DEFINE_MUTEX(leds_lookup_lock);
27static LIST_HEAD(leds_lookup_list);
Richard Purdiec72a1d62006-03-31 02:31:04 -080028
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070029static ssize_t brightness_show(struct device *dev,
Richard Purdief8a7c6f2007-07-08 23:19:31 +010030 struct device_attribute *attr, char *buf)
Richard Purdiec72a1d62006-03-31 02:31:04 -080031{
Richard Purdief8a7c6f2007-07-08 23:19:31 +010032 struct led_classdev *led_cdev = dev_get_drvdata(dev);
Richard Purdiec72a1d62006-03-31 02:31:04 -080033
34 /* no lock needed for this */
Henrique de Moraes Holschuh29d76df2008-03-18 09:47:48 +000035 led_update_brightness(led_cdev);
Richard Purdiec72a1d62006-03-31 02:31:04 -080036
Sven Wegenerdd8e5a22008-10-13 10:41:39 +010037 return sprintf(buf, "%u\n", led_cdev->brightness);
Richard Purdiec72a1d62006-03-31 02:31:04 -080038}
39
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070040static ssize_t brightness_store(struct device *dev,
Richard Purdief8a7c6f2007-07-08 23:19:31 +010041 struct device_attribute *attr, const char *buf, size_t size)
Richard Purdiec72a1d62006-03-31 02:31:04 -080042{
Richard Purdief8a7c6f2007-07-08 23:19:31 +010043 struct led_classdev *led_cdev = dev_get_drvdata(dev);
Shuah Khan872b86b2012-05-29 15:07:26 -070044 unsigned long state;
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -070045 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 Purdiec72a1d62006-03-31 02:31:04 -080053
Shuah Khan872b86b2012-05-29 15:07:26 -070054 ret = kstrtoul(buf, 10, &state);
55 if (ret)
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -070056 goto unlock;
Richard Purdie3dc7b822006-05-15 09:44:17 -070057
Shuah Khan872b86b2012-05-29 15:07:26 -070058 if (state == LED_OFF)
59 led_trigger_remove(led_cdev);
Jacek Anaszewski4d71a4a2014-11-14 02:50:18 -080060 led_set_brightness(led_cdev, state);
Pavel Machek0db37912019-04-29 17:22:59 +020061 flush_work(&led_cdev->set_brightness_work);
Németh Márton0013b232008-03-09 20:54:37 +000062
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -070063 ret = size;
64unlock:
65 mutex_unlock(&led_cdev->led_access);
66 return ret;
Richard Purdiec72a1d62006-03-31 02:31:04 -080067}
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070068static DEVICE_ATTR_RW(brightness);
Richard Purdiec72a1d62006-03-31 02:31:04 -080069
Jacek Anaszewski384196122014-08-07 05:10:24 -070070static ssize_t max_brightness_show(struct device *dev,
Guennadi Liakhovetski1bd465e2009-01-10 18:54:39 +000071 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 Anaszewski384196122014-08-07 05:10:24 -070077static DEVICE_ATTR_RO(max_brightness);
Guennadi Liakhovetski1bd465e2009-01-10 18:54:39 +000078
Richard Purdiec3bc9952006-03-31 02:31:05 -080079#ifdef CONFIG_LEDS_TRIGGERS
Akinobu Mita11f70002019-09-29 23:18:49 +090080static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0);
81static struct bin_attribute *led_trigger_bin_attrs[] = {
82 &bin_attr_trigger,
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070083 NULL,
84};
85static const struct attribute_group led_trigger_group = {
Akinobu Mita11f70002019-09-29 23:18:49 +090086 .bin_attrs = led_trigger_bin_attrs,
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070087};
Richard Purdiec3bc9952006-03-31 02:31:05 -080088#endif
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -070089
90static struct attribute *led_class_attrs[] = {
91 &dev_attr_brightness.attr,
92 &dev_attr_max_brightness.attr,
93 NULL,
94};
95
96static const struct attribute_group led_group = {
97 .attrs = led_class_attrs,
98};
99
100static const struct attribute_group *led_groups[] = {
101 &led_group,
102#ifdef CONFIG_LEDS_TRIGGERS
103 &led_trigger_group,
104#endif
105 NULL,
Florian Fainelli14b5d6d2010-03-10 18:32:18 +0100106};
Richard Purdiec72a1d62006-03-31 02:31:04 -0800107
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100108#ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
109static 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
120static DEVICE_ATTR_RO(brightness_hw_changed);
121
122static 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
144static 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 Samehaf0bfab2020-12-11 22:42:08 +0200150void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev, unsigned int brightness)
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100151{
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}
158EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed);
159#else
160static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
161{
162 return 0;
163}
164static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
165{
166}
167#endif
168
Richard Purdiec72a1d62006-03-31 02:31:04 -0800169/**
170 * led_classdev_suspend - suspend an led_classdev.
171 * @led_cdev: the led_classdev to suspend.
172 */
173void led_classdev_suspend(struct led_classdev *led_cdev)
174{
175 led_cdev->flags |= LED_SUSPENDED;
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200176 led_set_brightness_nopm(led_cdev, 0);
Kai-Heng Feng302a0852020-07-02 13:45:00 +0800177 flush_work(&led_cdev->set_brightness_work);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800178}
179EXPORT_SYMBOL_GPL(led_classdev_suspend);
180
181/**
182 * led_classdev_resume - resume an led_classdev.
183 * @led_cdev: the led_classdev to resume.
184 */
185void led_classdev_resume(struct led_classdev *led_cdev)
186{
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200187 led_set_brightness_nopm(led_cdev, led_cdev->brightness);
Jacek Anaszewski7aea8382015-01-09 07:22:51 -0800188
189 if (led_cdev->flash_resume)
190 led_cdev->flash_resume(led_cdev);
191
Richard Purdiec72a1d62006-03-31 02:31:04 -0800192 led_cdev->flags &= ~LED_SUSPENDED;
193}
194EXPORT_SYMBOL_GPL(led_classdev_resume);
195
Grygorii Strashko084609b2015-04-24 14:57:10 +0300196#ifdef CONFIG_PM_SLEEP
Shuah Khan73e1ab42013-06-20 12:08:44 -0700197static int led_suspend(struct device *dev)
Richard Purdie859cb7f2009-01-08 17:55:03 +0000198{
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
207static 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 Strashko084609b2015-04-24 14:57:10 +0300216#endif
Richard Purdie859cb7f2009-01-08 17:55:03 +0000217
Grygorii Strashko084609b2015-04-24 14:57:10 +0300218static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
Shuah Khan73e1ab42013-06-20 12:08:44 -0700219
Hans de Goedefafef582023-01-20 12:45:15 +0100220static struct led_classdev *led_module_get(struct device *led_dev)
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200221{
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200222 struct led_classdev *led_cdev;
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200223
224 if (!led_dev)
225 return ERR_PTR(-EPROBE_DEFER);
226
227 led_cdev = dev_get_drvdata(led_dev);
228
Hans de Goede44511092023-01-20 12:45:14 +0100229 if (!try_module_get(led_cdev->dev->parent->driver->owner)) {
230 put_device(led_cdev->dev);
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200231 return ERR_PTR(-ENODEV);
Hans de Goede44511092023-01-20 12:45:14 +0100232 }
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200233
234 return led_cdev;
235}
Hans de Goedefafef582023-01-20 12:45:15 +0100236
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 */
245struct 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 Linda1afe82022-12-20 16:18:07 +0400256 put_device(led_dev);
Hans de Goedefafef582023-01-20 12:45:15 +0100257
258 return led_module_get(led_dev);
259}
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200260EXPORT_SYMBOL_GPL(of_led_get);
261
262/**
263 * led_put() - release a LED device
264 * @led_cdev: LED device
265 */
266void led_put(struct led_classdev *led_cdev)
267{
268 module_put(led_cdev->dev->parent->driver->owner);
Hans de Goede44511092023-01-20 12:45:14 +0100269 put_device(led_cdev->dev);
Tomi Valkeinen699a8c72019-10-03 10:28:09 +0200270}
271EXPORT_SYMBOL_GPL(led_put);
272
Jean-Jacques Hiblote3892402019-10-03 10:28:10 +0200273static 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 Goede537bdca2023-01-20 12:45:16 +0100280static 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 Hiblote3892402019-10-03 10:28:10 +0200296/**
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 */
307struct led_classdev *__must_check devm_of_led_get(struct device *dev,
308 int index)
309{
310 struct led_classdev *led;
Jean-Jacques Hiblote3892402019-10-03 10:28:10 +0200311
312 if (!dev)
313 return ERR_PTR(-EINVAL);
314
Jean-Jacques Hiblote3892402019-10-03 10:28:10 +0200315 led = of_led_get(dev->of_node, index);
316 if (IS_ERR(led))
317 return led;
318
Hans de Goede537bdca2023-01-20 12:45:16 +0100319 return __devm_led_get(dev, led);
Jean-Jacques Hiblote3892402019-10-03 10:28:10 +0200320}
321EXPORT_SYMBOL_GPL(devm_of_led_get);
322
Hans de Goedeabc31002023-01-20 12:45:17 +0100323/**
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 */
330struct 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}
354EXPORT_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 */
366struct 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}
376EXPORT_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 */
385void 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}
391EXPORT_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 */
397void 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}
403EXPORT_SYMBOL_GPL(led_remove_lookup);
404
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700405static 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 Delgadoe5b5a612015-07-31 13:36:21 +0200410 struct device *dev;
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700411
412 strlcpy(name, init_name, len);
413
Ricardo Ribalda Delgadoe5b5a612015-07-31 13:36:21 +0200414 while ((ret < len) &&
Suzuki K Poulose6cda08a2019-07-23 23:18:32 +0100415 (dev = class_find_device_by_name(leds_class, name))) {
Ricardo Ribalda Delgadoe5b5a612015-07-31 13:36:21 +0200416 put_device(dev);
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700417 ret = snprintf(name, len, "%s_%u", init_name, ++i);
Ricardo Ribalda Delgadoe5b5a612015-07-31 13:36:21 +0200418 }
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700419
420 if (ret >= len)
421 return -ENOMEM;
422
423 return i;
424}
425
Richard Purdiec72a1d62006-03-31 02:31:04 -0800426/**
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200427 * led_classdev_register_ext - register a new object of led_classdev class
428 * with init data.
Rafał Miłecki442c6092017-03-06 06:19:44 +0100429 *
430 * @parent: parent of LED device
Richard Purdiec72a1d62006-03-31 02:31:04 -0800431 * @led_cdev: the led_classdev structure for this device.
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200432 * @init_data: LED class device initialization data
Richard Purdiec72a1d62006-03-31 02:31:04 -0800433 */
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200434int led_classdev_register_ext(struct device *parent,
435 struct led_classdev *led_cdev,
436 struct led_init_data *init_data)
Richard Purdiec72a1d62006-03-31 02:31:04 -0800437{
Jacek Anaszewskibb4e9af2019-06-09 20:19:04 +0200438 char composed_name[LED_MAX_NAME_SIZE];
439 char final_name[LED_MAX_NAME_SIZE];
440 const char *proposed_name = composed_name;
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700441 int ret;
442
Jacek Anaszewskibb4e9af2019-06-09 20:19:04 +0200443 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únc49d6ca2020-09-19 20:03:04 +0200451
Eddie James41906632021-07-16 17:03:26 -0500452 if (init_data->fwnode) {
Marek Behúnc49d6ca2020-09-19 20:03:04 +0200453 fwnode_property_read_string(init_data->fwnode,
454 "linux,default-trigger",
455 &led_cdev->default_trigger);
Eddie James41906632021-07-16 17:03:26 -0500456
457 if (fwnode_property_present(init_data->fwnode,
458 "retain-state-shutdown"))
459 led_cdev->flags |= LED_RETAIN_AT_SHUTDOWN;
460 }
Jacek Anaszewskibb4e9af2019-06-09 20:19:04 +0200461 } else {
462 proposed_name = led_cdev->name;
463 }
464
465 ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700466 if (ret < 0)
467 return ret;
468
Luis Henriques6d710212018-05-23 23:22:21 +0100469 mutex_init(&led_cdev->led_access);
470 mutex_lock(&led_cdev->led_access);
Johan Hovoldd0d480c2014-06-25 10:08:44 -0700471 led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
Jacek Anaszewskibb4e9af2019-06-09 20:19:04 +0200472 led_cdev, led_cdev->groups, "%s", final_name);
Luis Henriques6d710212018-05-23 23:22:21 +0100473 if (IS_ERR(led_cdev->dev)) {
474 mutex_unlock(&led_cdev->led_access);
Richard Purdief8a7c6f2007-07-08 23:19:31 +0100475 return PTR_ERR(led_cdev->dev);
Luis Henriques6d710212018-05-23 23:22:21 +0100476 }
Sander Vanheule495b8962021-11-13 22:11:13 +0100477 if (init_data && init_data->fwnode)
478 device_set_node(led_cdev->dev, init_data->fwnode);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800479
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700480 if (ret)
Sakari Ailus6f06c7f2015-03-26 16:42:05 -0700481 dev_warn(parent, "Led %s renamed to %s due to name collision",
Ricardo Ribalda Delgado64ed6582020-04-01 11:51:47 +0200482 proposed_name, dev_name(led_cdev->dev));
Ricardo Ribalda Delgadoa96aa642015-03-30 10:45:59 -0700483
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100484 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 Shevchenko1dbb9fb42019-08-16 13:52:29 +0300488 led_cdev->dev = NULL;
Luis Henriques6d710212018-05-23 23:22:21 +0100489 mutex_unlock(&led_cdev->led_access);
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100490 return ret;
491 }
492 }
493
Hans de Goedea9c6ce52016-11-08 14:38:46 +0100494 led_cdev->work_flags = 0;
Richard Purdie270c3952008-10-20 23:16:17 +0100495#ifdef CONFIG_LEDS_TRIGGERS
496 init_rwsem(&led_cdev->trigger_lock);
497#endif
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100498#ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
499 led_cdev->brightness_hw_changed = -1;
500#endif
Richard Purdiec72a1d62006-03-31 02:31:04 -0800501 /* add to the list of leds */
Richard Purdie72f8da32007-12-31 23:09:44 +0000502 down_write(&leds_list_lock);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800503 list_add_tail(&led_cdev->node, &leds_list);
Richard Purdie72f8da32007-12-31 23:09:44 +0000504 up_write(&leds_list_lock);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800505
Guennadi Liakhovetski1bd465e2009-01-10 18:54:39 +0000506 if (!led_cdev->max_brightness)
507 led_cdev->max_brightness = LED_FULL;
508
Henrique de Moraes Holschuh29d76df2008-03-18 09:47:48 +0000509 led_update_brightness(led_cdev);
510
Jacek Anaszewski757b06a2015-09-28 14:38:04 +0200511 led_init_core(led_cdev);
Johannes Berg5ada28b2010-11-11 14:05:21 -0800512
Richard Purdiec3bc9952006-03-31 02:31:05 -0800513#ifdef CONFIG_LEDS_TRIGGERS
Jeff Garzik12fda162006-10-17 00:10:20 -0700514 led_trigger_set_default(led_cdev);
Richard Purdiec3bc9952006-03-31 02:31:05 -0800515#endif
516
Luis Henriques6d710212018-05-23 23:22:21 +0100517 mutex_unlock(&led_cdev->led_access);
518
Sachin Kamatd23e7b82012-11-25 10:57:35 +0530519 dev_dbg(parent, "Registered led device: %s\n",
Richard Purdief8a7c6f2007-07-08 23:19:31 +0100520 led_cdev->name);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800521
522 return 0;
523}
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200524EXPORT_SYMBOL_GPL(led_classdev_register_ext);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800525
526/**
Qinghuang Feng0266a452008-10-20 23:04:36 +0100527 * led_classdev_unregister - unregisters a object of led_properties class.
Henrik Kretzschmar70d63cc2006-10-03 23:31:30 +0200528 * @led_cdev: the led device to unregister
Richard Purdiec72a1d62006-03-31 02:31:04 -0800529 *
530 * Unregisters a previously registered via led_classdev_register object.
531 */
Rafael J. Wysockib844eba2008-03-23 20:28:24 +0100532void led_classdev_unregister(struct led_classdev *led_cdev)
Richard Purdiec72a1d62006-03-31 02:31:04 -0800533{
Andy Shevchenko1dbb9fb42019-08-16 13:52:29 +0300534 if (IS_ERR_OR_NULL(led_cdev->dev))
535 return;
536
Richard Purdiec3bc9952006-03-31 02:31:05 -0800537#ifdef CONFIG_LEDS_TRIGGERS
Richard Purdiedc472062007-11-10 13:29:04 +0000538 down_write(&led_cdev->trigger_lock);
Richard Purdiec3bc9952006-03-31 02:31:05 -0800539 if (led_cdev->trigger)
540 led_trigger_set(led_cdev, NULL);
Richard Purdiedc472062007-11-10 13:29:04 +0000541 up_write(&led_cdev->trigger_lock);
Richard Purdiec3bc9952006-03-31 02:31:05 -0800542#endif
Richard Purdiec72a1d62006-03-31 02:31:04 -0800543
Heiner Kallweitd84d80f32016-01-22 21:43:48 +0100544 led_cdev->flags |= LED_UNREGISTERING;
545
Johannes Berg5ada28b2010-11-11 14:05:21 -0800546 /* Stop blinking */
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800547 led_stop_software_blink(led_cdev);
Milo Kimd1aa5772015-11-20 17:03:00 +0900548
Eddie James41906632021-07-16 17:03:26 -0500549 if (!(led_cdev->flags & LED_RETAIN_AT_SHUTDOWN))
550 led_set_brightness(led_cdev, LED_OFF);
Johannes Berg5ada28b2010-11-11 14:05:21 -0800551
Milo Kimd1aa5772015-11-20 17:03:00 +0900552 flush_work(&led_cdev->set_brightness_work);
553
Hans de Goede0cb8eb32017-01-29 14:42:52 +0100554 if (led_cdev->flags & LED_BRIGHT_HW_CHANGED)
555 led_remove_brightness_hw_changed(led_cdev);
556
Rafael J. Wysockib844eba2008-03-23 20:28:24 +0100557 device_unregister(led_cdev->dev);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800558
Richard Purdie72f8da32007-12-31 23:09:44 +0000559 down_write(&leds_list_lock);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800560 list_del(&led_cdev->node);
Richard Purdie72f8da32007-12-31 23:09:44 +0000561 up_write(&leds_list_lock);
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -0700562
563 mutex_destroy(&led_cdev->led_access);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800564}
Rafael J. Wysockib844eba2008-03-23 20:28:24 +0100565EXPORT_SYMBOL_GPL(led_classdev_unregister);
Richard Purdiec72a1d62006-03-31 02:31:04 -0800566
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800567static void devm_led_classdev_release(struct device *dev, void *res)
568{
569 led_classdev_unregister(*(struct led_classdev **)res);
570}
571
572/**
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200573 * devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
Rafał Miłecki442c6092017-03-06 06:19:44 +0100574 *
575 * @parent: parent of LED device
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800576 * @led_cdev: the led_classdev structure for this device.
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200577 * @init_data: LED class device initialization data
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800578 */
Jacek Anaszewskib2b998c2019-06-09 20:19:03 +0200579int devm_led_classdev_register_ext(struct device *parent,
580 struct led_classdev *led_cdev,
581 struct led_init_data *init_data)
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800582{
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 Anaszewskib2b998c2019-06-09 20:19:03 +0200590 rc = led_classdev_register_ext(parent, led_cdev, init_data);
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800591 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 Anaszewskib2b998c2019-06-09 20:19:03 +0200601EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800602
603static int devm_led_classdev_match(struct device *dev, void *res, void *data)
604{
Dan Murphy4b83cf02019-10-02 07:40:41 -0500605 struct led_classdev **p = res;
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800606
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 Jones6a3a8712021-05-28 10:06:17 +0100615 * @dev: The device to unregister.
Bjorn Anderssonca1bb4e2015-02-23 16:11:41 -0800616 * @led_cdev: the led_classdev structure for this device.
617 */
618void 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}
625EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
626
Richard Purdiec72a1d62006-03-31 02:31:04 -0800627static 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 Khan73e1ab42013-06-20 12:08:44 -0700632 leds_class->pm = &leds_class_dev_pm_ops;
Greg Kroah-Hartman5baa7502013-07-24 15:05:13 -0700633 leds_class->dev_groups = led_groups;
Richard Purdiec72a1d62006-03-31 02:31:04 -0800634 return 0;
635}
636
637static void __exit leds_exit(void)
638{
639 class_destroy(leds_class);
640}
641
642subsys_initcall(leds_init);
643module_exit(leds_exit);
644
645MODULE_AUTHOR("John Lenz, Richard Purdie");
646MODULE_LICENSE("GPL");
647MODULE_DESCRIPTION("LED Class Interface");