drivers/leds/uleds.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Userspace driver for the LED subsystem
0004  *
0005  * Copyright (C) 2016 David Lechner <david@lechnology.com>
0006  *
0007  * Based on uinput.c: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
0008  */
0009 #include <linux/fs.h>
0010 #include <linux/init.h>
0011 #include <linux/leds.h>
0012 #include <linux/miscdevice.h>
0013 #include <linux/module.h>
0014 #include <linux/poll.h>
0015 #include <linux/sched.h>
0016 #include <linux/slab.h>
0017
0018 #include <uapi/linux/uleds.h>
0019
0020 #define ULEDS_NAME  "uleds"
0021
0022 enum uleds_state {
0023     ULEDS_STATE_UNKNOWN,
0024     ULEDS_STATE_REGISTERED,
0025 };
0026
0027 struct uleds_device {
0028     struct uleds_user_dev   user_dev;
0029     struct led_classdev led_cdev;
0030     struct mutex        mutex;
0031     enum uleds_state    state;
0032     wait_queue_head_t   waitq;
0033     int         brightness;
0034     bool            new_data;
0035 };
0036
0037 static struct miscdevice uleds_misc;
0038
0039 static void uleds_brightness_set(struct led_classdev *led_cdev,
0040                  enum led_brightness brightness)
0041 {
0042     struct uleds_device *udev = container_of(led_cdev, struct uleds_device,
0043                          led_cdev);
0044
0045     if (udev->brightness != brightness) {
0046         udev->brightness = brightness;
0047         udev->new_data = true;
0048         wake_up_interruptible(&udev->waitq);
0049     }
0050 }
0051
0052 static int uleds_open(struct inode *inode, struct file *file)
0053 {
0054     struct uleds_device *udev;
0055
0056     udev = kzalloc(sizeof(*udev), GFP_KERNEL);
0057     if (!udev)
0058         return -ENOMEM;
0059
0060     udev->led_cdev.name = udev->user_dev.name;
0061     udev->led_cdev.brightness_set = uleds_brightness_set;
0062
0063     mutex_init(&udev->mutex);
0064     init_waitqueue_head(&udev->waitq);
0065     udev->state = ULEDS_STATE_UNKNOWN;
0066
0067     file->private_data = udev;
0068     stream_open(inode, file);
0069
0070     return 0;
0071 }
0072
0073 static ssize_t uleds_write(struct file *file, const char __user *buffer,
0074                size_t count, loff_t *ppos)
0075 {
0076     struct uleds_device *udev = file->private_data;
0077     const char *name;
0078     int ret;
0079
0080     if (count == 0)
0081         return 0;
0082
0083     ret = mutex_lock_interruptible(&udev->mutex);
0084     if (ret)
0085         return ret;
0086
0087     if (udev->state == ULEDS_STATE_REGISTERED) {
0088         ret = -EBUSY;
0089         goto out;
0090     }
0091
0092     if (count != sizeof(struct uleds_user_dev)) {
0093         ret = -EINVAL;
0094         goto out;
0095     }
0096
0097     if (copy_from_user(&udev->user_dev, buffer,
0098                sizeof(struct uleds_user_dev))) {
0099         ret = -EFAULT;
0100         goto out;
0101     }
0102
0103     name = udev->user_dev.name;
0104     if (!name[0] || !strcmp(name, ".") || !strcmp(name, "..") ||
0105         strchr(name, '/')) {
0106         ret = -EINVAL;
0107         goto out;
0108     }
0109
0110     if (udev->user_dev.max_brightness <= 0) {
0111         ret = -EINVAL;
0112         goto out;
0113     }
0114     udev->led_cdev.max_brightness = udev->user_dev.max_brightness;
0115
0116     ret = devm_led_classdev_register(uleds_misc.this_device,
0117                      &udev->led_cdev);
0118     if (ret < 0)
0119         goto out;
0120
0121     udev->new_data = true;
0122     udev->state = ULEDS_STATE_REGISTERED;
0123     ret = count;
0124
0125 out:
0126     mutex_unlock(&udev->mutex);
0127
0128     return ret;
0129 }
0130
0131 static ssize_t uleds_read(struct file *file, char __user *buffer, size_t count,
0132               loff_t *ppos)
0133 {
0134     struct uleds_device *udev = file->private_data;
0135     ssize_t retval;
0136
0137     if (count < sizeof(udev->brightness))
0138         return 0;
0139
0140     do {
0141         retval = mutex_lock_interruptible(&udev->mutex);
0142         if (retval)
0143             return retval;
0144
0145         if (udev->state != ULEDS_STATE_REGISTERED) {
0146             retval = -ENODEV;
0147         } else if (!udev->new_data && (file->f_flags & O_NONBLOCK)) {
0148             retval = -EAGAIN;
0149         } else if (udev->new_data) {
0150             retval = copy_to_user(buffer, &udev->brightness,
0151                           sizeof(udev->brightness));
0152             udev->new_data = false;
0153             retval = sizeof(udev->brightness);
0154         }
0155
0156         mutex_unlock(&udev->mutex);
0157
0158         if (retval)
0159             break;
0160
0161         if (!(file->f_flags & O_NONBLOCK))
0162             retval = wait_event_interruptible(udev->waitq,
0163                     udev->new_data ||
0164                     udev->state != ULEDS_STATE_REGISTERED);
0165     } while (retval == 0);
0166
0167     return retval;
0168 }
0169
0170 static __poll_t uleds_poll(struct file *file, poll_table *wait)
0171 {
0172     struct uleds_device *udev = file->private_data;
0173
0174     poll_wait(file, &udev->waitq, wait);
0175
0176     if (udev->new_data)
0177         return EPOLLIN | EPOLLRDNORM;
0178
0179     return 0;
0180 }
0181
0182 static int uleds_release(struct inode *inode, struct file *file)
0183 {
0184     struct uleds_device *udev = file->private_data;
0185
0186     if (udev->state == ULEDS_STATE_REGISTERED) {
0187         udev->state = ULEDS_STATE_UNKNOWN;
0188         devm_led_classdev_unregister(uleds_misc.this_device,
0189                          &udev->led_cdev);
0190     }
0191     kfree(udev);
0192
0193     return 0;
0194 }
0195
0196 static const struct file_operations uleds_fops = {
0197     .owner      = THIS_MODULE,
0198     .open       = uleds_open,
0199     .release    = uleds_release,
0200     .read       = uleds_read,
0201     .write      = uleds_write,
0202     .poll       = uleds_poll,
0203     .llseek     = no_llseek,
0204 };
0205
0206 static struct miscdevice uleds_misc = {
0207     .fops       = &uleds_fops,
0208     .minor      = MISC_DYNAMIC_MINOR,
0209     .name       = ULEDS_NAME,
0210 };
0211
0212 static int __init uleds_init(void)
0213 {
0214     return misc_register(&uleds_misc);
0215 }
0216 module_init(uleds_init);
0217
0218 static void __exit uleds_exit(void)
0219 {
0220     misc_deregister(&uleds_misc);
0221 }
0222 module_exit(uleds_exit);
0223
0224 MODULE_AUTHOR("David Lechner <david@lechnology.com>");
0225 MODULE_DESCRIPTION("Userspace driver for the LED subsystem");
0226 MODULE_LICENSE("GPL");