Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
7aea8389 JA |
2 | /* |
3 | * LED Flash class interface | |
4 | * | |
5 | * Copyright (C) 2015 Samsung Electronics Co., Ltd. | |
6 | * Author: Jacek Anaszewski <j.anaszewski@samsung.com> | |
7aea8389 JA |
7 | */ |
8 | ||
9 | #include <linux/device.h> | |
10 | #include <linux/init.h> | |
11 | #include <linux/led-class-flash.h> | |
12 | #include <linux/leds.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/slab.h> | |
15 | #include "leds.h" | |
16 | ||
17 | #define has_flash_op(fled_cdev, op) \ | |
18 | (fled_cdev && fled_cdev->ops->op) | |
19 | ||
20 | #define call_flash_op(fled_cdev, op, args...) \ | |
21 | ((has_flash_op(fled_cdev, op)) ? \ | |
22 | (fled_cdev->ops->op(fled_cdev, args)) : \ | |
23 | -EINVAL) | |
24 | ||
25 | static const char * const led_flash_fault_names[] = { | |
26 | "led-over-voltage", | |
27 | "flash-timeout-exceeded", | |
28 | "controller-over-temperature", | |
29 | "controller-short-circuit", | |
30 | "led-power-supply-over-current", | |
31 | "indicator-led-fault", | |
32 | "led-under-voltage", | |
33 | "controller-under-voltage", | |
34 | "led-over-temperature", | |
35 | }; | |
36 | ||
37 | static ssize_t flash_brightness_store(struct device *dev, | |
38 | struct device_attribute *attr, const char *buf, size_t size) | |
39 | { | |
40 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
41 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
42 | unsigned long state; | |
43 | ssize_t ret; | |
44 | ||
45 | mutex_lock(&led_cdev->led_access); | |
46 | ||
47 | if (led_sysfs_is_disabled(led_cdev)) { | |
48 | ret = -EBUSY; | |
49 | goto unlock; | |
50 | } | |
51 | ||
52 | ret = kstrtoul(buf, 10, &state); | |
53 | if (ret) | |
54 | goto unlock; | |
55 | ||
56 | ret = led_set_flash_brightness(fled_cdev, state); | |
57 | if (ret < 0) | |
58 | goto unlock; | |
59 | ||
60 | ret = size; | |
61 | unlock: | |
62 | mutex_unlock(&led_cdev->led_access); | |
63 | return ret; | |
64 | } | |
65 | ||
66 | static ssize_t flash_brightness_show(struct device *dev, | |
67 | struct device_attribute *attr, char *buf) | |
68 | { | |
69 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
70 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
71 | ||
72 | /* no lock needed for this */ | |
73 | led_update_flash_brightness(fled_cdev); | |
74 | ||
75 | return sprintf(buf, "%u\n", fled_cdev->brightness.val); | |
76 | } | |
77 | static DEVICE_ATTR_RW(flash_brightness); | |
78 | ||
79 | static ssize_t max_flash_brightness_show(struct device *dev, | |
80 | struct device_attribute *attr, char *buf) | |
81 | { | |
82 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
83 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
84 | ||
85 | return sprintf(buf, "%u\n", fled_cdev->brightness.max); | |
86 | } | |
87 | static DEVICE_ATTR_RO(max_flash_brightness); | |
88 | ||
89 | static ssize_t flash_strobe_store(struct device *dev, | |
90 | struct device_attribute *attr, const char *buf, size_t size) | |
91 | { | |
92 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
93 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
94 | unsigned long state; | |
654933ae | 95 | ssize_t ret = -EBUSY; |
7aea8389 JA |
96 | |
97 | mutex_lock(&led_cdev->led_access); | |
98 | ||
654933ae | 99 | if (led_sysfs_is_disabled(led_cdev)) |
7aea8389 | 100 | goto unlock; |
7aea8389 JA |
101 | |
102 | ret = kstrtoul(buf, 10, &state); | |
103 | if (ret) | |
104 | goto unlock; | |
105 | ||
abc19635 | 106 | if (state > 1) { |
7aea8389 JA |
107 | ret = -EINVAL; |
108 | goto unlock; | |
109 | } | |
110 | ||
111 | ret = led_set_flash_strobe(fled_cdev, state); | |
112 | if (ret < 0) | |
113 | goto unlock; | |
114 | ret = size; | |
115 | unlock: | |
116 | mutex_unlock(&led_cdev->led_access); | |
117 | return ret; | |
118 | } | |
119 | ||
120 | static ssize_t flash_strobe_show(struct device *dev, | |
121 | struct device_attribute *attr, char *buf) | |
122 | { | |
123 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
124 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
125 | bool state; | |
126 | int ret; | |
127 | ||
128 | /* no lock needed for this */ | |
129 | ret = led_get_flash_strobe(fled_cdev, &state); | |
130 | if (ret < 0) | |
131 | return ret; | |
132 | ||
133 | return sprintf(buf, "%u\n", state); | |
134 | } | |
135 | static DEVICE_ATTR_RW(flash_strobe); | |
136 | ||
137 | static ssize_t flash_timeout_store(struct device *dev, | |
138 | struct device_attribute *attr, const char *buf, size_t size) | |
139 | { | |
140 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
141 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
142 | unsigned long flash_timeout; | |
143 | ssize_t ret; | |
144 | ||
145 | mutex_lock(&led_cdev->led_access); | |
146 | ||
147 | if (led_sysfs_is_disabled(led_cdev)) { | |
148 | ret = -EBUSY; | |
149 | goto unlock; | |
150 | } | |
151 | ||
152 | ret = kstrtoul(buf, 10, &flash_timeout); | |
153 | if (ret) | |
154 | goto unlock; | |
155 | ||
156 | ret = led_set_flash_timeout(fled_cdev, flash_timeout); | |
157 | if (ret < 0) | |
158 | goto unlock; | |
159 | ||
160 | ret = size; | |
161 | unlock: | |
162 | mutex_unlock(&led_cdev->led_access); | |
163 | return ret; | |
164 | } | |
165 | ||
166 | static ssize_t flash_timeout_show(struct device *dev, | |
167 | struct device_attribute *attr, char *buf) | |
168 | { | |
169 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
170 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
171 | ||
172 | return sprintf(buf, "%u\n", fled_cdev->timeout.val); | |
173 | } | |
174 | static DEVICE_ATTR_RW(flash_timeout); | |
175 | ||
176 | static ssize_t max_flash_timeout_show(struct device *dev, | |
177 | struct device_attribute *attr, char *buf) | |
178 | { | |
179 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
180 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
181 | ||
182 | return sprintf(buf, "%u\n", fled_cdev->timeout.max); | |
183 | } | |
184 | static DEVICE_ATTR_RO(max_flash_timeout); | |
185 | ||
186 | static ssize_t flash_fault_show(struct device *dev, | |
187 | struct device_attribute *attr, char *buf) | |
188 | { | |
189 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
190 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
191 | u32 fault, mask = 0x1; | |
192 | char *pbuf = buf; | |
193 | int i, ret, buf_len; | |
194 | ||
195 | ret = led_get_flash_fault(fled_cdev, &fault); | |
196 | if (ret < 0) | |
197 | return -EINVAL; | |
198 | ||
199 | *buf = '\0'; | |
200 | ||
201 | for (i = 0; i < LED_NUM_FLASH_FAULTS; ++i) { | |
202 | if (fault & mask) { | |
203 | buf_len = sprintf(pbuf, "%s ", | |
204 | led_flash_fault_names[i]); | |
205 | pbuf += buf_len; | |
206 | } | |
207 | mask <<= 1; | |
208 | } | |
209 | ||
811b5440 | 210 | return strlen(strcat(buf, "\n")); |
7aea8389 JA |
211 | } |
212 | static DEVICE_ATTR_RO(flash_fault); | |
213 | ||
7aea8389 JA |
214 | static struct attribute *led_flash_strobe_attrs[] = { |
215 | &dev_attr_flash_strobe.attr, | |
216 | NULL, | |
217 | }; | |
218 | ||
219 | static struct attribute *led_flash_timeout_attrs[] = { | |
220 | &dev_attr_flash_timeout.attr, | |
221 | &dev_attr_max_flash_timeout.attr, | |
222 | NULL, | |
223 | }; | |
224 | ||
225 | static struct attribute *led_flash_brightness_attrs[] = { | |
226 | &dev_attr_flash_brightness.attr, | |
227 | &dev_attr_max_flash_brightness.attr, | |
228 | NULL, | |
229 | }; | |
230 | ||
231 | static struct attribute *led_flash_fault_attrs[] = { | |
232 | &dev_attr_flash_fault.attr, | |
233 | NULL, | |
234 | }; | |
235 | ||
7aea8389 JA |
236 | static const struct attribute_group led_flash_strobe_group = { |
237 | .attrs = led_flash_strobe_attrs, | |
238 | }; | |
239 | ||
240 | static const struct attribute_group led_flash_timeout_group = { | |
241 | .attrs = led_flash_timeout_attrs, | |
242 | }; | |
243 | ||
244 | static const struct attribute_group led_flash_brightness_group = { | |
245 | .attrs = led_flash_brightness_attrs, | |
246 | }; | |
247 | ||
248 | static const struct attribute_group led_flash_fault_group = { | |
249 | .attrs = led_flash_fault_attrs, | |
250 | }; | |
251 | ||
7aea8389 JA |
252 | static void led_flash_resume(struct led_classdev *led_cdev) |
253 | { | |
254 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
255 | ||
256 | call_flash_op(fled_cdev, flash_brightness_set, | |
257 | fled_cdev->brightness.val); | |
258 | call_flash_op(fled_cdev, timeout_set, fled_cdev->timeout.val); | |
259 | } | |
260 | ||
261 | static void led_flash_init_sysfs_groups(struct led_classdev_flash *fled_cdev) | |
262 | { | |
263 | struct led_classdev *led_cdev = &fled_cdev->led_cdev; | |
264 | const struct led_flash_ops *ops = fled_cdev->ops; | |
265 | const struct attribute_group **flash_groups = fled_cdev->sysfs_groups; | |
266 | ||
267 | int num_sysfs_groups = 0; | |
268 | ||
269 | flash_groups[num_sysfs_groups++] = &led_flash_strobe_group; | |
270 | ||
271 | if (ops->flash_brightness_set) | |
272 | flash_groups[num_sysfs_groups++] = &led_flash_brightness_group; | |
273 | ||
274 | if (ops->timeout_set) | |
275 | flash_groups[num_sysfs_groups++] = &led_flash_timeout_group; | |
276 | ||
277 | if (ops->fault_get) | |
278 | flash_groups[num_sysfs_groups++] = &led_flash_fault_group; | |
279 | ||
7aea8389 JA |
280 | led_cdev->groups = flash_groups; |
281 | } | |
282 | ||
b2b998c0 JA |
283 | int led_classdev_flash_register_ext(struct device *parent, |
284 | struct led_classdev_flash *fled_cdev, | |
285 | struct led_init_data *init_data) | |
7aea8389 JA |
286 | { |
287 | struct led_classdev *led_cdev; | |
288 | const struct led_flash_ops *ops; | |
289 | int ret; | |
290 | ||
291 | if (!fled_cdev) | |
292 | return -EINVAL; | |
293 | ||
294 | led_cdev = &fled_cdev->led_cdev; | |
295 | ||
296 | if (led_cdev->flags & LED_DEV_CAP_FLASH) { | |
437a4240 | 297 | if (!led_cdev->brightness_set_blocking) |
7aea8389 JA |
298 | return -EINVAL; |
299 | ||
300 | ops = fled_cdev->ops; | |
301 | if (!ops || !ops->strobe_set) | |
302 | return -EINVAL; | |
303 | ||
304 | led_cdev->flash_resume = led_flash_resume; | |
305 | ||
306 | /* Select the sysfs attributes to be created for the device */ | |
307 | led_flash_init_sysfs_groups(fled_cdev); | |
308 | } | |
309 | ||
310 | /* Register led class device */ | |
b2b998c0 | 311 | ret = led_classdev_register_ext(parent, led_cdev, init_data); |
7aea8389 JA |
312 | if (ret < 0) |
313 | return ret; | |
314 | ||
7aea8389 JA |
315 | return 0; |
316 | } | |
b2b998c0 | 317 | EXPORT_SYMBOL_GPL(led_classdev_flash_register_ext); |
7aea8389 JA |
318 | |
319 | void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev) | |
320 | { | |
321 | if (!fled_cdev) | |
322 | return; | |
323 | ||
324 | led_classdev_unregister(&fled_cdev->led_cdev); | |
325 | } | |
326 | EXPORT_SYMBOL_GPL(led_classdev_flash_unregister); | |
327 | ||
20cdba9d DM |
328 | static void devm_led_classdev_flash_release(struct device *dev, void *res) |
329 | { | |
330 | led_classdev_flash_unregister(*(struct led_classdev_flash **)res); | |
331 | } | |
332 | ||
333 | int devm_led_classdev_flash_register_ext(struct device *parent, | |
334 | struct led_classdev_flash *fled_cdev, | |
335 | struct led_init_data *init_data) | |
336 | { | |
337 | struct led_classdev_flash **dr; | |
338 | int ret; | |
339 | ||
340 | dr = devres_alloc(devm_led_classdev_flash_release, sizeof(*dr), | |
341 | GFP_KERNEL); | |
342 | if (!dr) | |
343 | return -ENOMEM; | |
344 | ||
345 | ret = led_classdev_flash_register_ext(parent, fled_cdev, init_data); | |
346 | if (ret) { | |
347 | devres_free(dr); | |
348 | return ret; | |
349 | } | |
350 | ||
351 | *dr = fled_cdev; | |
352 | devres_add(parent, dr); | |
353 | ||
354 | return 0; | |
355 | } | |
356 | EXPORT_SYMBOL_GPL(devm_led_classdev_flash_register_ext); | |
357 | ||
358 | static int devm_led_classdev_flash_match(struct device *dev, | |
359 | void *res, void *data) | |
360 | { | |
361 | struct led_classdev_flash **p = res; | |
362 | ||
363 | if (WARN_ON(!p || !*p)) | |
364 | return 0; | |
365 | ||
366 | return *p == data; | |
367 | } | |
368 | ||
369 | void devm_led_classdev_flash_unregister(struct device *dev, | |
370 | struct led_classdev_flash *fled_cdev) | |
371 | { | |
372 | WARN_ON(devres_release(dev, | |
373 | devm_led_classdev_flash_release, | |
374 | devm_led_classdev_flash_match, fled_cdev)); | |
375 | } | |
376 | EXPORT_SYMBOL_GPL(devm_led_classdev_flash_unregister); | |
377 | ||
7aea8389 JA |
378 | static void led_clamp_align(struct led_flash_setting *s) |
379 | { | |
380 | u32 v, offset; | |
381 | ||
382 | v = s->val + s->step / 2; | |
383 | v = clamp(v, s->min, s->max); | |
384 | offset = v - s->min; | |
385 | offset = s->step * (offset / s->step); | |
386 | s->val = s->min + offset; | |
387 | } | |
388 | ||
389 | int led_set_flash_timeout(struct led_classdev_flash *fled_cdev, u32 timeout) | |
390 | { | |
391 | struct led_classdev *led_cdev = &fled_cdev->led_cdev; | |
392 | struct led_flash_setting *s = &fled_cdev->timeout; | |
393 | ||
394 | s->val = timeout; | |
395 | led_clamp_align(s); | |
396 | ||
397 | if (!(led_cdev->flags & LED_SUSPENDED)) | |
398 | return call_flash_op(fled_cdev, timeout_set, s->val); | |
399 | ||
400 | return 0; | |
401 | } | |
402 | EXPORT_SYMBOL_GPL(led_set_flash_timeout); | |
403 | ||
404 | int led_get_flash_fault(struct led_classdev_flash *fled_cdev, u32 *fault) | |
405 | { | |
406 | return call_flash_op(fled_cdev, fault_get, fault); | |
407 | } | |
408 | EXPORT_SYMBOL_GPL(led_get_flash_fault); | |
409 | ||
410 | int led_set_flash_brightness(struct led_classdev_flash *fled_cdev, | |
411 | u32 brightness) | |
412 | { | |
413 | struct led_classdev *led_cdev = &fled_cdev->led_cdev; | |
414 | struct led_flash_setting *s = &fled_cdev->brightness; | |
415 | ||
416 | s->val = brightness; | |
417 | led_clamp_align(s); | |
418 | ||
419 | if (!(led_cdev->flags & LED_SUSPENDED)) | |
420 | return call_flash_op(fled_cdev, flash_brightness_set, s->val); | |
421 | ||
422 | return 0; | |
423 | } | |
424 | EXPORT_SYMBOL_GPL(led_set_flash_brightness); | |
425 | ||
426 | int led_update_flash_brightness(struct led_classdev_flash *fled_cdev) | |
427 | { | |
428 | struct led_flash_setting *s = &fled_cdev->brightness; | |
429 | u32 brightness; | |
430 | ||
431 | if (has_flash_op(fled_cdev, flash_brightness_get)) { | |
432 | int ret = call_flash_op(fled_cdev, flash_brightness_get, | |
433 | &brightness); | |
434 | if (ret < 0) | |
435 | return ret; | |
436 | ||
437 | s->val = brightness; | |
438 | } | |
439 | ||
440 | return 0; | |
441 | } | |
442 | EXPORT_SYMBOL_GPL(led_update_flash_brightness); | |
443 | ||
444 | MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>"); | |
445 | MODULE_DESCRIPTION("LED Flash class interface"); | |
446 | MODULE_LICENSE("GPL v2"); |