led-core.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LED Class Core
  4. *
  5. * Copyright 2005-2006 Openedhand Ltd.
  6. *
  7. * Author: Richard Purdie <rpurdie@openedhand.com>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/leds.h>
  11. #include <linux/list.h>
  12. #include <linux/module.h>
  13. #include <linux/mutex.h>
  14. #include <linux/of.h>
  15. #include <linux/property.h>
  16. #include <linux/rwsem.h>
  17. #include <linux/slab.h>
  18. #include <uapi/linux/uleds.h>
  19. #include "leds.h"
  20. DECLARE_RWSEM(leds_list_lock);
  21. EXPORT_SYMBOL_GPL(leds_list_lock);
  22. LIST_HEAD(leds_list);
  23. EXPORT_SYMBOL_GPL(leds_list);
  24. const char * const led_colors[LED_COLOR_ID_MAX] = {
  25. [LED_COLOR_ID_WHITE] = "white",
  26. [LED_COLOR_ID_RED] = "red",
  27. [LED_COLOR_ID_GREEN] = "green",
  28. [LED_COLOR_ID_BLUE] = "blue",
  29. [LED_COLOR_ID_AMBER] = "amber",
  30. [LED_COLOR_ID_VIOLET] = "violet",
  31. [LED_COLOR_ID_YELLOW] = "yellow",
  32. [LED_COLOR_ID_IR] = "ir",
  33. [LED_COLOR_ID_MULTI] = "multicolor",
  34. [LED_COLOR_ID_RGB] = "rgb",
  35. };
  36. EXPORT_SYMBOL_GPL(led_colors);
  37. static int __led_set_brightness(struct led_classdev *led_cdev,
  38. enum led_brightness value)
  39. {
  40. if (!led_cdev->brightness_set)
  41. return -ENOTSUPP;
  42. led_cdev->brightness_set(led_cdev, value);
  43. return 0;
  44. }
  45. static int __led_set_brightness_blocking(struct led_classdev *led_cdev,
  46. enum led_brightness value)
  47. {
  48. if (!led_cdev->brightness_set_blocking)
  49. return -ENOTSUPP;
  50. return led_cdev->brightness_set_blocking(led_cdev, value);
  51. }
  52. static void led_timer_function(struct timer_list *t)
  53. {
  54. struct led_classdev *led_cdev = from_timer(led_cdev, t, blink_timer);
  55. unsigned long brightness;
  56. unsigned long delay;
  57. if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
  58. led_set_brightness_nosleep(led_cdev, LED_OFF);
  59. clear_bit(LED_BLINK_SW, &led_cdev->work_flags);
  60. return;
  61. }
  62. if (test_and_clear_bit(LED_BLINK_ONESHOT_STOP,
  63. &led_cdev->work_flags)) {
  64. clear_bit(LED_BLINK_SW, &led_cdev->work_flags);
  65. return;
  66. }
  67. brightness = led_get_brightness(led_cdev);
  68. if (!brightness) {
  69. /* Time to switch the LED on. */
  70. if (test_and_clear_bit(LED_BLINK_BRIGHTNESS_CHANGE,
  71. &led_cdev->work_flags))
  72. brightness = led_cdev->new_blink_brightness;
  73. else
  74. brightness = led_cdev->blink_brightness;
  75. delay = led_cdev->blink_delay_on;
  76. } else {
  77. /* Store the current brightness value to be able
  78. * to restore it when the delay_off period is over.
  79. */
  80. led_cdev->blink_brightness = brightness;
  81. brightness = LED_OFF;
  82. delay = led_cdev->blink_delay_off;
  83. }
  84. led_set_brightness_nosleep(led_cdev, brightness);
  85. /* Return in next iteration if led is in one-shot mode and we are in
  86. * the final blink state so that the led is toggled each delay_on +
  87. * delay_off milliseconds in worst case.
  88. */
  89. if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags)) {
  90. if (test_bit(LED_BLINK_INVERT, &led_cdev->work_flags)) {
  91. if (brightness)
  92. set_bit(LED_BLINK_ONESHOT_STOP,
  93. &led_cdev->work_flags);
  94. } else {
  95. if (!brightness)
  96. set_bit(LED_BLINK_ONESHOT_STOP,
  97. &led_cdev->work_flags);
  98. }
  99. }
  100. mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
  101. }
  102. static void set_brightness_delayed(struct work_struct *ws)
  103. {
  104. struct led_classdev *led_cdev =
  105. container_of(ws, struct led_classdev, set_brightness_work);
  106. int ret = 0;
  107. if (test_and_clear_bit(LED_BLINK_DISABLE, &led_cdev->work_flags)) {
  108. led_cdev->delayed_set_value = LED_OFF;
  109. led_stop_software_blink(led_cdev);
  110. }
  111. ret = __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
  112. if (ret == -ENOTSUPP)
  113. ret = __led_set_brightness_blocking(led_cdev,
  114. led_cdev->delayed_set_value);
  115. if (ret < 0 &&
  116. /* LED HW might have been unplugged, therefore don't warn */
  117. !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) &&
  118. (led_cdev->flags & LED_HW_PLUGGABLE)))
  119. dev_err(led_cdev->dev,
  120. "Setting an LED's brightness failed (%d)\n", ret);
  121. }
  122. static void led_set_software_blink(struct led_classdev *led_cdev,
  123. unsigned long delay_on,
  124. unsigned long delay_off)
  125. {
  126. int current_brightness;
  127. current_brightness = led_get_brightness(led_cdev);
  128. if (current_brightness)
  129. led_cdev->blink_brightness = current_brightness;
  130. if (!led_cdev->blink_brightness)
  131. led_cdev->blink_brightness = led_cdev->max_brightness;
  132. led_cdev->blink_delay_on = delay_on;
  133. led_cdev->blink_delay_off = delay_off;
  134. /* never on - just set to off */
  135. if (!delay_on) {
  136. led_set_brightness_nosleep(led_cdev, LED_OFF);
  137. return;
  138. }
  139. /* never off - just set to brightness */
  140. if (!delay_off) {
  141. led_set_brightness_nosleep(led_cdev,
  142. led_cdev->blink_brightness);
  143. return;
  144. }
  145. set_bit(LED_BLINK_SW, &led_cdev->work_flags);
  146. mod_timer(&led_cdev->blink_timer, jiffies + 1);
  147. }
  148. static void led_blink_setup(struct led_classdev *led_cdev,
  149. unsigned long *delay_on,
  150. unsigned long *delay_off)
  151. {
  152. if (!test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) &&
  153. led_cdev->blink_set &&
  154. !led_cdev->blink_set(led_cdev, delay_on, delay_off))
  155. return;
  156. /* blink with 1 Hz as default if nothing specified */
  157. if (!*delay_on && !*delay_off)
  158. *delay_on = *delay_off = 500;
  159. led_set_software_blink(led_cdev, *delay_on, *delay_off);
  160. }
  161. void led_init_core(struct led_classdev *led_cdev)
  162. {
  163. INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed);
  164. timer_setup(&led_cdev->blink_timer, led_timer_function, 0);
  165. }
  166. EXPORT_SYMBOL_GPL(led_init_core);
  167. void led_blink_set(struct led_classdev *led_cdev,
  168. unsigned long *delay_on,
  169. unsigned long *delay_off)
  170. {
  171. del_timer_sync(&led_cdev->blink_timer);
  172. clear_bit(LED_BLINK_SW, &led_cdev->work_flags);
  173. clear_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags);
  174. clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags);
  175. led_blink_setup(led_cdev, delay_on, delay_off);
  176. }
  177. EXPORT_SYMBOL_GPL(led_blink_set);
  178. void led_blink_set_oneshot(struct led_classdev *led_cdev,
  179. unsigned long *delay_on,
  180. unsigned long *delay_off,
  181. int invert)
  182. {
  183. if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) &&
  184. timer_pending(&led_cdev->blink_timer))
  185. return;
  186. set_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags);
  187. clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags);
  188. if (invert)
  189. set_bit(LED_BLINK_INVERT, &led_cdev->work_flags);
  190. else
  191. clear_bit(LED_BLINK_INVERT, &led_cdev->work_flags);
  192. led_blink_setup(led_cdev, delay_on, delay_off);
  193. }
  194. EXPORT_SYMBOL_GPL(led_blink_set_oneshot);
  195. void led_stop_software_blink(struct led_classdev *led_cdev)
  196. {
  197. del_timer_sync(&led_cdev->blink_timer);
  198. led_cdev->blink_delay_on = 0;
  199. led_cdev->blink_delay_off = 0;
  200. clear_bit(LED_BLINK_SW, &led_cdev->work_flags);
  201. }
  202. EXPORT_SYMBOL_GPL(led_stop_software_blink);
  203. void led_set_brightness(struct led_classdev *led_cdev,
  204. enum led_brightness brightness)
  205. {
  206. /*
  207. * If software blink is active, delay brightness setting
  208. * until the next timer tick.
  209. */
  210. if (test_bit(LED_BLINK_SW, &led_cdev->work_flags)) {
  211. /*
  212. * If we need to disable soft blinking delegate this to the
  213. * work queue task to avoid problems in case we are called
  214. * from hard irq context.
  215. */
  216. if (brightness == LED_OFF) {
  217. set_bit(LED_BLINK_DISABLE, &led_cdev->work_flags);
  218. schedule_work(&led_cdev->set_brightness_work);
  219. } else {
  220. set_bit(LED_BLINK_BRIGHTNESS_CHANGE,
  221. &led_cdev->work_flags);
  222. led_cdev->new_blink_brightness = brightness;
  223. }
  224. return;
  225. }
  226. led_set_brightness_nosleep(led_cdev, brightness);
  227. }
  228. EXPORT_SYMBOL_GPL(led_set_brightness);
  229. void led_set_brightness_nopm(struct led_classdev *led_cdev,
  230. enum led_brightness value)
  231. {
  232. /* Use brightness_set op if available, it is guaranteed not to sleep */
  233. if (!__led_set_brightness(led_cdev, value))
  234. return;
  235. /* If brightness setting can sleep, delegate it to a work queue task */
  236. led_cdev->delayed_set_value = value;
  237. schedule_work(&led_cdev->set_brightness_work);
  238. }
  239. EXPORT_SYMBOL_GPL(led_set_brightness_nopm);
  240. void led_set_brightness_nosleep(struct led_classdev *led_cdev,
  241. enum led_brightness value)
  242. {
  243. led_cdev->brightness = min(value, led_cdev->max_brightness);
  244. if (led_cdev->flags & LED_SUSPENDED)
  245. return;
  246. led_set_brightness_nopm(led_cdev, led_cdev->brightness);
  247. }
  248. EXPORT_SYMBOL_GPL(led_set_brightness_nosleep);
  249. int led_set_brightness_sync(struct led_classdev *led_cdev,
  250. enum led_brightness value)
  251. {
  252. if (led_cdev->blink_delay_on || led_cdev->blink_delay_off)
  253. return -EBUSY;
  254. led_cdev->brightness = min(value, led_cdev->max_brightness);
  255. if (led_cdev->flags & LED_SUSPENDED)
  256. return 0;
  257. return __led_set_brightness_blocking(led_cdev, led_cdev->brightness);
  258. }
  259. EXPORT_SYMBOL_GPL(led_set_brightness_sync);
  260. int led_update_brightness(struct led_classdev *led_cdev)
  261. {
  262. int ret = 0;
  263. if (led_cdev->brightness_get) {
  264. ret = led_cdev->brightness_get(led_cdev);
  265. if (ret >= 0) {
  266. led_cdev->brightness = ret;
  267. return 0;
  268. }
  269. }
  270. return ret;
  271. }
  272. EXPORT_SYMBOL_GPL(led_update_brightness);
  273. u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size)
  274. {
  275. struct fwnode_handle *fwnode = led_cdev->dev->fwnode;
  276. u32 *pattern;
  277. int count;
  278. count = fwnode_property_count_u32(fwnode, "led-pattern");
  279. if (count < 0)
  280. return NULL;
  281. pattern = kcalloc(count, sizeof(*pattern), GFP_KERNEL);
  282. if (!pattern)
  283. return NULL;
  284. if (fwnode_property_read_u32_array(fwnode, "led-pattern", pattern, count)) {
  285. kfree(pattern);
  286. return NULL;
  287. }
  288. *size = count;
  289. return pattern;
  290. }
  291. EXPORT_SYMBOL_GPL(led_get_default_pattern);
  292. /* Caller must ensure led_cdev->led_access held */
  293. void led_sysfs_disable(struct led_classdev *led_cdev)
  294. {
  295. lockdep_assert_held(&led_cdev->led_access);
  296. led_cdev->flags |= LED_SYSFS_DISABLE;
  297. }
  298. EXPORT_SYMBOL_GPL(led_sysfs_disable);
  299. /* Caller must ensure led_cdev->led_access held */
  300. void led_sysfs_enable(struct led_classdev *led_cdev)
  301. {
  302. lockdep_assert_held(&led_cdev->led_access);
  303. led_cdev->flags &= ~LED_SYSFS_DISABLE;
  304. }
  305. EXPORT_SYMBOL_GPL(led_sysfs_enable);
  306. static void led_parse_fwnode_props(struct device *dev,
  307. struct fwnode_handle *fwnode,
  308. struct led_properties *props)
  309. {
  310. int ret;
  311. if (!fwnode)
  312. return;
  313. if (fwnode_property_present(fwnode, "label")) {
  314. ret = fwnode_property_read_string(fwnode, "label", &props->label);
  315. if (ret)
  316. dev_err(dev, "Error parsing 'label' property (%d)\n", ret);
  317. return;
  318. }
  319. if (fwnode_property_present(fwnode, "color")) {
  320. ret = fwnode_property_read_u32(fwnode, "color", &props->color);
  321. if (ret)
  322. dev_err(dev, "Error parsing 'color' property (%d)\n", ret);
  323. else if (props->color >= LED_COLOR_ID_MAX)
  324. dev_err(dev, "LED color identifier out of range\n");
  325. else
  326. props->color_present = true;
  327. }
  328. if (!fwnode_property_present(fwnode, "function"))
  329. return;
  330. ret = fwnode_property_read_string(fwnode, "function", &props->function);
  331. if (ret) {
  332. dev_err(dev,
  333. "Error parsing 'function' property (%d)\n",
  334. ret);
  335. }
  336. if (!fwnode_property_present(fwnode, "function-enumerator"))
  337. return;
  338. ret = fwnode_property_read_u32(fwnode, "function-enumerator",
  339. &props->func_enum);
  340. if (ret) {
  341. dev_err(dev,
  342. "Error parsing 'function-enumerator' property (%d)\n",
  343. ret);
  344. } else {
  345. props->func_enum_present = true;
  346. }
  347. }
  348. int led_compose_name(struct device *dev, struct led_init_data *init_data,
  349. char *led_classdev_name)
  350. {
  351. struct led_properties props = {};
  352. struct fwnode_handle *fwnode = init_data->fwnode;
  353. const char *devicename = init_data->devicename;
  354. /* We want to label LEDs that can produce full range of colors
  355. * as RGB, not multicolor */
  356. BUG_ON(props.color == LED_COLOR_ID_MULTI);
  357. if (!led_classdev_name)
  358. return -EINVAL;
  359. led_parse_fwnode_props(dev, fwnode, &props);
  360. if (props.label) {
  361. /*
  362. * If init_data.devicename is NULL, then it indicates that
  363. * DT label should be used as-is for LED class device name.
  364. * Otherwise the label is prepended with devicename to compose
  365. * the final LED class device name.
  366. */
  367. if (!devicename) {
  368. strscpy(led_classdev_name, props.label,
  369. LED_MAX_NAME_SIZE);
  370. } else {
  371. snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
  372. devicename, props.label);
  373. }
  374. } else if (props.function || props.color_present) {
  375. char tmp_buf[LED_MAX_NAME_SIZE];
  376. if (props.func_enum_present) {
  377. snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s-%d",
  378. props.color_present ? led_colors[props.color] : "",
  379. props.function ?: "", props.func_enum);
  380. } else {
  381. snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s",
  382. props.color_present ? led_colors[props.color] : "",
  383. props.function ?: "");
  384. }
  385. if (init_data->devname_mandatory) {
  386. snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
  387. devicename, tmp_buf);
  388. } else {
  389. strscpy(led_classdev_name, tmp_buf, LED_MAX_NAME_SIZE);
  390. }
  391. } else if (init_data->default_label) {
  392. if (!devicename) {
  393. dev_err(dev, "Legacy LED naming requires devicename segment");
  394. return -EINVAL;
  395. }
  396. snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
  397. devicename, init_data->default_label);
  398. } else if (is_of_node(fwnode)) {
  399. strscpy(led_classdev_name, to_of_node(fwnode)->name,
  400. LED_MAX_NAME_SIZE);
  401. } else
  402. return -EINVAL;
  403. return 0;
  404. }
  405. EXPORT_SYMBOL_GPL(led_compose_name);