uleds.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Userspace driver for the LED subsystem
  4. *
  5. * Copyright (C) 2016 David Lechner <david@lechnology.com>
  6. *
  7. * Based on uinput.c: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
  8. */
  9. #include <linux/fs.h>
  10. #include <linux/init.h>
  11. #include <linux/leds.h>
  12. #include <linux/miscdevice.h>
  13. #include <linux/module.h>
  14. #include <linux/poll.h>
  15. #include <linux/sched.h>
  16. #include <linux/slab.h>
  17. #include <uapi/linux/uleds.h>
  18. #define ULEDS_NAME "uleds"
  19. enum uleds_state {
  20. ULEDS_STATE_UNKNOWN,
  21. ULEDS_STATE_REGISTERED,
  22. };
  23. struct uleds_device {
  24. struct uleds_user_dev user_dev;
  25. struct led_classdev led_cdev;
  26. struct mutex mutex;
  27. enum uleds_state state;
  28. wait_queue_head_t waitq;
  29. int brightness;
  30. bool new_data;
  31. };
  32. static struct miscdevice uleds_misc;
  33. static void uleds_brightness_set(struct led_classdev *led_cdev,
  34. enum led_brightness brightness)
  35. {
  36. struct uleds_device *udev = container_of(led_cdev, struct uleds_device,
  37. led_cdev);
  38. if (udev->brightness != brightness) {
  39. udev->brightness = brightness;
  40. udev->new_data = true;
  41. wake_up_interruptible(&udev->waitq);
  42. }
  43. }
  44. static int uleds_open(struct inode *inode, struct file *file)
  45. {
  46. struct uleds_device *udev;
  47. udev = kzalloc(sizeof(*udev), GFP_KERNEL);
  48. if (!udev)
  49. return -ENOMEM;
  50. udev->led_cdev.name = udev->user_dev.name;
  51. udev->led_cdev.brightness_set = uleds_brightness_set;
  52. mutex_init(&udev->mutex);
  53. init_waitqueue_head(&udev->waitq);
  54. udev->state = ULEDS_STATE_UNKNOWN;
  55. file->private_data = udev;
  56. stream_open(inode, file);
  57. return 0;
  58. }
  59. static ssize_t uleds_write(struct file *file, const char __user *buffer,
  60. size_t count, loff_t *ppos)
  61. {
  62. struct uleds_device *udev = file->private_data;
  63. const char *name;
  64. int ret;
  65. if (count == 0)
  66. return 0;
  67. ret = mutex_lock_interruptible(&udev->mutex);
  68. if (ret)
  69. return ret;
  70. if (udev->state == ULEDS_STATE_REGISTERED) {
  71. ret = -EBUSY;
  72. goto out;
  73. }
  74. if (count != sizeof(struct uleds_user_dev)) {
  75. ret = -EINVAL;
  76. goto out;
  77. }
  78. if (copy_from_user(&udev->user_dev, buffer,
  79. sizeof(struct uleds_user_dev))) {
  80. ret = -EFAULT;
  81. goto out;
  82. }
  83. name = udev->user_dev.name;
  84. if (!name[0] || !strcmp(name, ".") || !strcmp(name, "..") ||
  85. strchr(name, '/')) {
  86. ret = -EINVAL;
  87. goto out;
  88. }
  89. if (udev->user_dev.max_brightness <= 0) {
  90. ret = -EINVAL;
  91. goto out;
  92. }
  93. udev->led_cdev.max_brightness = udev->user_dev.max_brightness;
  94. ret = devm_led_classdev_register(uleds_misc.this_device,
  95. &udev->led_cdev);
  96. if (ret < 0)
  97. goto out;
  98. udev->new_data = true;
  99. udev->state = ULEDS_STATE_REGISTERED;
  100. ret = count;
  101. out:
  102. mutex_unlock(&udev->mutex);
  103. return ret;
  104. }
  105. static ssize_t uleds_read(struct file *file, char __user *buffer, size_t count,
  106. loff_t *ppos)
  107. {
  108. struct uleds_device *udev = file->private_data;
  109. ssize_t retval;
  110. if (count < sizeof(udev->brightness))
  111. return 0;
  112. do {
  113. retval = mutex_lock_interruptible(&udev->mutex);
  114. if (retval)
  115. return retval;
  116. if (udev->state != ULEDS_STATE_REGISTERED) {
  117. retval = -ENODEV;
  118. } else if (!udev->new_data && (file->f_flags & O_NONBLOCK)) {
  119. retval = -EAGAIN;
  120. } else if (udev->new_data) {
  121. retval = copy_to_user(buffer, &udev->brightness,
  122. sizeof(udev->brightness));
  123. udev->new_data = false;
  124. retval = sizeof(udev->brightness);
  125. }
  126. mutex_unlock(&udev->mutex);
  127. if (retval)
  128. break;
  129. if (!(file->f_flags & O_NONBLOCK))
  130. retval = wait_event_interruptible(udev->waitq,
  131. udev->new_data ||
  132. udev->state != ULEDS_STATE_REGISTERED);
  133. } while (retval == 0);
  134. return retval;
  135. }
  136. static __poll_t uleds_poll(struct file *file, poll_table *wait)
  137. {
  138. struct uleds_device *udev = file->private_data;
  139. poll_wait(file, &udev->waitq, wait);
  140. if (udev->new_data)
  141. return EPOLLIN | EPOLLRDNORM;
  142. return 0;
  143. }
  144. static int uleds_release(struct inode *inode, struct file *file)
  145. {
  146. struct uleds_device *udev = file->private_data;
  147. if (udev->state == ULEDS_STATE_REGISTERED) {
  148. udev->state = ULEDS_STATE_UNKNOWN;
  149. devm_led_classdev_unregister(uleds_misc.this_device,
  150. &udev->led_cdev);
  151. }
  152. kfree(udev);
  153. return 0;
  154. }
  155. static const struct file_operations uleds_fops = {
  156. .owner = THIS_MODULE,
  157. .open = uleds_open,
  158. .release = uleds_release,
  159. .read = uleds_read,
  160. .write = uleds_write,
  161. .poll = uleds_poll,
  162. .llseek = no_llseek,
  163. };
  164. static struct miscdevice uleds_misc = {
  165. .fops = &uleds_fops,
  166. .minor = MISC_DYNAMIC_MINOR,
  167. .name = ULEDS_NAME,
  168. };
  169. static int __init uleds_init(void)
  170. {
  171. return misc_register(&uleds_misc);
  172. }
  173. module_init(uleds_init);
  174. static void __exit uleds_exit(void)
  175. {
  176. misc_deregister(&uleds_misc);
  177. }
  178. module_exit(uleds_exit);
  179. MODULE_AUTHOR("David Lechner <david@lechnology.com>");
  180. MODULE_DESCRIPTION("Userspace driver for the LED subsystem");
  181. MODULE_LICENSE("GPL");