led-class.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LED Class Core
  4. *
  5. * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
  6. * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
  7. */
  8. #include <linux/ctype.h>
  9. #include <linux/device.h>
  10. #include <linux/err.h>
  11. #include <linux/init.h>
  12. #include <linux/kernel.h>
  13. #include <linux/leds.h>
  14. #include <linux/list.h>
  15. #include <linux/module.h>
  16. #include <linux/property.h>
  17. #include <linux/slab.h>
  18. #include <linux/spinlock.h>
  19. #include <linux/timer.h>
  20. #include <uapi/linux/uleds.h>
  21. #include <linux/of.h>
  22. #include "leds.h"
  23. static struct class *leds_class;
  24. static ssize_t brightness_show(struct device *dev,
  25. struct device_attribute *attr, char *buf)
  26. {
  27. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  28. /* no lock needed for this */
  29. led_update_brightness(led_cdev);
  30. return sprintf(buf, "%u\n", led_cdev->brightness);
  31. }
  32. static ssize_t brightness_store(struct device *dev,
  33. struct device_attribute *attr, const char *buf, size_t size)
  34. {
  35. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  36. unsigned long state;
  37. ssize_t ret;
  38. mutex_lock(&led_cdev->led_access);
  39. if (led_sysfs_is_disabled(led_cdev)) {
  40. ret = -EBUSY;
  41. goto unlock;
  42. }
  43. ret = kstrtoul(buf, 10, &state);
  44. if (ret)
  45. goto unlock;
  46. if (state == LED_OFF)
  47. led_trigger_remove(led_cdev);
  48. led_set_brightness(led_cdev, state);
  49. flush_work(&led_cdev->set_brightness_work);
  50. ret = size;
  51. unlock:
  52. mutex_unlock(&led_cdev->led_access);
  53. return ret;
  54. }
  55. static DEVICE_ATTR_RW(brightness);
  56. static ssize_t max_brightness_show(struct device *dev,
  57. struct device_attribute *attr, char *buf)
  58. {
  59. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  60. return sprintf(buf, "%u\n", led_cdev->max_brightness);
  61. }
  62. static DEVICE_ATTR_RO(max_brightness);
  63. #ifdef CONFIG_LEDS_TRIGGERS
  64. static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0);
  65. static struct bin_attribute *led_trigger_bin_attrs[] = {
  66. &bin_attr_trigger,
  67. NULL,
  68. };
  69. static const struct attribute_group led_trigger_group = {
  70. .bin_attrs = led_trigger_bin_attrs,
  71. };
  72. #endif
  73. static struct attribute *led_class_attrs[] = {
  74. &dev_attr_brightness.attr,
  75. &dev_attr_max_brightness.attr,
  76. NULL,
  77. };
  78. static const struct attribute_group led_group = {
  79. .attrs = led_class_attrs,
  80. };
  81. static const struct attribute_group *led_groups[] = {
  82. &led_group,
  83. #ifdef CONFIG_LEDS_TRIGGERS
  84. &led_trigger_group,
  85. #endif
  86. NULL,
  87. };
  88. #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
  89. static ssize_t brightness_hw_changed_show(struct device *dev,
  90. struct device_attribute *attr, char *buf)
  91. {
  92. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  93. if (led_cdev->brightness_hw_changed == -1)
  94. return -ENODATA;
  95. return sprintf(buf, "%u\n", led_cdev->brightness_hw_changed);
  96. }
  97. static DEVICE_ATTR_RO(brightness_hw_changed);
  98. static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
  99. {
  100. struct device *dev = led_cdev->dev;
  101. int ret;
  102. ret = device_create_file(dev, &dev_attr_brightness_hw_changed);
  103. if (ret) {
  104. dev_err(dev, "Error creating brightness_hw_changed\n");
  105. return ret;
  106. }
  107. led_cdev->brightness_hw_changed_kn =
  108. sysfs_get_dirent(dev->kobj.sd, "brightness_hw_changed");
  109. if (!led_cdev->brightness_hw_changed_kn) {
  110. dev_err(dev, "Error getting brightness_hw_changed kn\n");
  111. device_remove_file(dev, &dev_attr_brightness_hw_changed);
  112. return -ENXIO;
  113. }
  114. return 0;
  115. }
  116. static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
  117. {
  118. sysfs_put(led_cdev->brightness_hw_changed_kn);
  119. device_remove_file(led_cdev->dev, &dev_attr_brightness_hw_changed);
  120. }
  121. void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev,
  122. enum led_brightness brightness)
  123. {
  124. if (WARN_ON(!led_cdev->brightness_hw_changed_kn))
  125. return;
  126. led_cdev->brightness_hw_changed = brightness;
  127. sysfs_notify_dirent(led_cdev->brightness_hw_changed_kn);
  128. }
  129. EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed);
  130. #else
  131. static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
  132. {
  133. return 0;
  134. }
  135. static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
  136. {
  137. }
  138. #endif
  139. /**
  140. * led_classdev_suspend - suspend an led_classdev.
  141. * @led_cdev: the led_classdev to suspend.
  142. */
  143. void led_classdev_suspend(struct led_classdev *led_cdev)
  144. {
  145. led_cdev->flags |= LED_SUSPENDED;
  146. led_set_brightness_nopm(led_cdev, 0);
  147. flush_work(&led_cdev->set_brightness_work);
  148. }
  149. EXPORT_SYMBOL_GPL(led_classdev_suspend);
  150. /**
  151. * led_classdev_resume - resume an led_classdev.
  152. * @led_cdev: the led_classdev to resume.
  153. */
  154. void led_classdev_resume(struct led_classdev *led_cdev)
  155. {
  156. led_set_brightness_nopm(led_cdev, led_cdev->brightness);
  157. if (led_cdev->flash_resume)
  158. led_cdev->flash_resume(led_cdev);
  159. led_cdev->flags &= ~LED_SUSPENDED;
  160. }
  161. EXPORT_SYMBOL_GPL(led_classdev_resume);
  162. #ifdef CONFIG_PM_SLEEP
  163. static int led_suspend(struct device *dev)
  164. {
  165. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  166. if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
  167. led_classdev_suspend(led_cdev);
  168. return 0;
  169. }
  170. static int led_resume(struct device *dev)
  171. {
  172. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  173. if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
  174. led_classdev_resume(led_cdev);
  175. return 0;
  176. }
  177. #endif
  178. static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
  179. /**
  180. * of_led_get() - request a LED device via the LED framework
  181. * @np: device node to get the LED device from
  182. * @index: the index of the LED
  183. *
  184. * Returns the LED device parsed from the phandle specified in the "leds"
  185. * property of a device tree node or a negative error-code on failure.
  186. */
  187. struct led_classdev *of_led_get(struct device_node *np, int index)
  188. {
  189. struct device *led_dev;
  190. struct led_classdev *led_cdev;
  191. struct device_node *led_node;
  192. led_node = of_parse_phandle(np, "leds", index);
  193. if (!led_node)
  194. return ERR_PTR(-ENOENT);
  195. led_dev = class_find_device_by_of_node(leds_class, led_node);
  196. of_node_put(led_node);
  197. if (!led_dev)
  198. return ERR_PTR(-EPROBE_DEFER);
  199. led_cdev = dev_get_drvdata(led_dev);
  200. if (!try_module_get(led_cdev->dev->parent->driver->owner))
  201. return ERR_PTR(-ENODEV);
  202. return led_cdev;
  203. }
  204. EXPORT_SYMBOL_GPL(of_led_get);
  205. /**
  206. * led_put() - release a LED device
  207. * @led_cdev: LED device
  208. */
  209. void led_put(struct led_classdev *led_cdev)
  210. {
  211. module_put(led_cdev->dev->parent->driver->owner);
  212. }
  213. EXPORT_SYMBOL_GPL(led_put);
  214. static void devm_led_release(struct device *dev, void *res)
  215. {
  216. struct led_classdev **p = res;
  217. led_put(*p);
  218. }
  219. /**
  220. * devm_of_led_get - Resource-managed request of a LED device
  221. * @dev: LED consumer
  222. * @index: index of the LED to obtain in the consumer
  223. *
  224. * The device node of the device is parse to find the request LED device.
  225. * The LED device returned from this function is automatically released
  226. * on driver detach.
  227. *
  228. * @return a pointer to a LED device or ERR_PTR(errno) on failure.
  229. */
  230. struct led_classdev *__must_check devm_of_led_get(struct device *dev,
  231. int index)
  232. {
  233. struct led_classdev *led;
  234. struct led_classdev **dr;
  235. if (!dev)
  236. return ERR_PTR(-EINVAL);
  237. led = of_led_get(dev->of_node, index);
  238. if (IS_ERR(led))
  239. return led;
  240. dr = devres_alloc(devm_led_release, sizeof(struct led_classdev *),
  241. GFP_KERNEL);
  242. if (!dr) {
  243. led_put(led);
  244. return ERR_PTR(-ENOMEM);
  245. }
  246. *dr = led;
  247. devres_add(dev, dr);
  248. return led;
  249. }
  250. EXPORT_SYMBOL_GPL(devm_of_led_get);
  251. static int led_classdev_next_name(const char *init_name, char *name,
  252. size_t len)
  253. {
  254. unsigned int i = 0;
  255. int ret = 0;
  256. struct device *dev;
  257. strlcpy(name, init_name, len);
  258. while ((ret < len) &&
  259. (dev = class_find_device_by_name(leds_class, name))) {
  260. put_device(dev);
  261. ret = snprintf(name, len, "%s_%u", init_name, ++i);
  262. }
  263. if (ret >= len)
  264. return -ENOMEM;
  265. return i;
  266. }
  267. /**
  268. * led_classdev_register_ext - register a new object of led_classdev class
  269. * with init data.
  270. *
  271. * @parent: parent of LED device
  272. * @led_cdev: the led_classdev structure for this device.
  273. * @init_data: LED class device initialization data
  274. */
  275. int led_classdev_register_ext(struct device *parent,
  276. struct led_classdev *led_cdev,
  277. struct led_init_data *init_data)
  278. {
  279. char composed_name[LED_MAX_NAME_SIZE];
  280. char final_name[LED_MAX_NAME_SIZE];
  281. const char *proposed_name = composed_name;
  282. int ret;
  283. if (init_data) {
  284. if (init_data->devname_mandatory && !init_data->devicename) {
  285. dev_err(parent, "Mandatory device name is missing");
  286. return -EINVAL;
  287. }
  288. ret = led_compose_name(parent, init_data, composed_name);
  289. if (ret < 0)
  290. return ret;
  291. if (init_data->fwnode)
  292. fwnode_property_read_string(init_data->fwnode,
  293. "linux,default-trigger",
  294. &led_cdev->default_trigger);
  295. } else {
  296. proposed_name = led_cdev->name;
  297. }
  298. ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
  299. if (ret < 0)
  300. return ret;
  301. mutex_init(&led_cdev->led_access);
  302. mutex_lock(&led_cdev->led_access);
  303. led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
  304. led_cdev, led_cdev->groups, "%s", final_name);
  305. if (IS_ERR(led_cdev->dev)) {
  306. mutex_unlock(&led_cdev->led_access);
  307. return PTR_ERR(led_cdev->dev);
  308. }
  309. if (init_data && init_data->fwnode) {
  310. led_cdev->dev->fwnode = init_data->fwnode;
  311. led_cdev->dev->of_node = to_of_node(init_data->fwnode);
  312. }
  313. if (ret)
  314. dev_warn(parent, "Led %s renamed to %s due to name collision",
  315. proposed_name, dev_name(led_cdev->dev));
  316. if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) {
  317. ret = led_add_brightness_hw_changed(led_cdev);
  318. if (ret) {
  319. device_unregister(led_cdev->dev);
  320. led_cdev->dev = NULL;
  321. mutex_unlock(&led_cdev->led_access);
  322. return ret;
  323. }
  324. }
  325. led_cdev->work_flags = 0;
  326. #ifdef CONFIG_LEDS_TRIGGERS
  327. init_rwsem(&led_cdev->trigger_lock);
  328. #endif
  329. #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
  330. led_cdev->brightness_hw_changed = -1;
  331. #endif
  332. /* add to the list of leds */
  333. down_write(&leds_list_lock);
  334. list_add_tail(&led_cdev->node, &leds_list);
  335. up_write(&leds_list_lock);
  336. if (!led_cdev->max_brightness)
  337. led_cdev->max_brightness = LED_FULL;
  338. led_update_brightness(led_cdev);
  339. led_init_core(led_cdev);
  340. #ifdef CONFIG_LEDS_TRIGGERS
  341. led_trigger_set_default(led_cdev);
  342. #endif
  343. mutex_unlock(&led_cdev->led_access);
  344. dev_dbg(parent, "Registered led device: %s\n",
  345. led_cdev->name);
  346. return 0;
  347. }
  348. EXPORT_SYMBOL_GPL(led_classdev_register_ext);
  349. /**
  350. * led_classdev_unregister - unregisters a object of led_properties class.
  351. * @led_cdev: the led device to unregister
  352. *
  353. * Unregisters a previously registered via led_classdev_register object.
  354. */
  355. void led_classdev_unregister(struct led_classdev *led_cdev)
  356. {
  357. if (IS_ERR_OR_NULL(led_cdev->dev))
  358. return;
  359. #ifdef CONFIG_LEDS_TRIGGERS
  360. down_write(&led_cdev->trigger_lock);
  361. if (led_cdev->trigger)
  362. led_trigger_set(led_cdev, NULL);
  363. up_write(&led_cdev->trigger_lock);
  364. #endif
  365. led_cdev->flags |= LED_UNREGISTERING;
  366. /* Stop blinking */
  367. led_stop_software_blink(led_cdev);
  368. led_set_brightness(led_cdev, LED_OFF);
  369. flush_work(&led_cdev->set_brightness_work);
  370. if (led_cdev->flags & LED_BRIGHT_HW_CHANGED)
  371. led_remove_brightness_hw_changed(led_cdev);
  372. device_unregister(led_cdev->dev);
  373. down_write(&leds_list_lock);
  374. list_del(&led_cdev->node);
  375. up_write(&leds_list_lock);
  376. mutex_destroy(&led_cdev->led_access);
  377. }
  378. EXPORT_SYMBOL_GPL(led_classdev_unregister);
  379. static void devm_led_classdev_release(struct device *dev, void *res)
  380. {
  381. led_classdev_unregister(*(struct led_classdev **)res);
  382. }
  383. /**
  384. * devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
  385. *
  386. * @parent: parent of LED device
  387. * @led_cdev: the led_classdev structure for this device.
  388. * @init_data: LED class device initialization data
  389. */
  390. int devm_led_classdev_register_ext(struct device *parent,
  391. struct led_classdev *led_cdev,
  392. struct led_init_data *init_data)
  393. {
  394. struct led_classdev **dr;
  395. int rc;
  396. dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
  397. if (!dr)
  398. return -ENOMEM;
  399. rc = led_classdev_register_ext(parent, led_cdev, init_data);
  400. if (rc) {
  401. devres_free(dr);
  402. return rc;
  403. }
  404. *dr = led_cdev;
  405. devres_add(parent, dr);
  406. return 0;
  407. }
  408. EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
  409. static int devm_led_classdev_match(struct device *dev, void *res, void *data)
  410. {
  411. struct led_classdev **p = res;
  412. if (WARN_ON(!p || !*p))
  413. return 0;
  414. return *p == data;
  415. }
  416. /**
  417. * devm_led_classdev_unregister() - resource managed led_classdev_unregister()
  418. * @parent: The device to unregister.
  419. * @led_cdev: the led_classdev structure for this device.
  420. */
  421. void devm_led_classdev_unregister(struct device *dev,
  422. struct led_classdev *led_cdev)
  423. {
  424. WARN_ON(devres_release(dev,
  425. devm_led_classdev_release,
  426. devm_led_classdev_match, led_cdev));
  427. }
  428. EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
  429. static int __init leds_init(void)
  430. {
  431. leds_class = class_create(THIS_MODULE, "leds");
  432. if (IS_ERR(leds_class))
  433. return PTR_ERR(leds_class);
  434. leds_class->pm = &leds_class_dev_pm_ops;
  435. leds_class->dev_groups = led_groups;
  436. return 0;
  437. }
  438. static void __exit leds_exit(void)
  439. {
  440. class_destroy(leds_class);
  441. }
  442. subsys_initcall(leds_init);
  443. module_exit(leds_exit);
  444. MODULE_AUTHOR("John Lenz, Richard Purdie");
  445. MODULE_LICENSE("GPL");
  446. MODULE_DESCRIPTION("LED Class Interface");