drivers/input/input-poller.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Support for polling mode for input devices.
0004  */
0005
0006 #include <linux/device.h>
0007 #include <linux/input.h>
0008 #include <linux/jiffies.h>
0009 #include <linux/mutex.h>
0010 #include <linux/slab.h>
0011 #include <linux/types.h>
0012 #include <linux/workqueue.h>
0013 #include "input-poller.h"
0014
0015 struct input_dev_poller {
0016     void (*poll)(struct input_dev *dev);
0017
0018     unsigned int poll_interval; /* msec */
0019     unsigned int poll_interval_max; /* msec */
0020     unsigned int poll_interval_min; /* msec */
0021
0022     struct input_dev *input;
0023     struct delayed_work work;
0024 };
0025
0026 static void input_dev_poller_queue_work(struct input_dev_poller *poller)
0027 {
0028     unsigned long delay;
0029
0030     delay = msecs_to_jiffies(poller->poll_interval);
0031     if (delay >= HZ)
0032         delay = round_jiffies_relative(delay);
0033
0034     queue_delayed_work(system_freezable_wq, &poller->work, delay);
0035 }
0036
0037 static void input_dev_poller_work(struct work_struct *work)
0038 {
0039     struct input_dev_poller *poller =
0040         container_of(work, struct input_dev_poller, work.work);
0041
0042     poller->poll(poller->input);
0043     input_dev_poller_queue_work(poller);
0044 }
0045
0046 void input_dev_poller_finalize(struct input_dev_poller *poller)
0047 {
0048     if (!poller->poll_interval)
0049         poller->poll_interval = 500;
0050     if (!poller->poll_interval_max)
0051         poller->poll_interval_max = poller->poll_interval;
0052 }
0053
0054 void input_dev_poller_start(struct input_dev_poller *poller)
0055 {
0056     /* Only start polling if polling is enabled */
0057     if (poller->poll_interval > 0) {
0058         poller->poll(poller->input);
0059         input_dev_poller_queue_work(poller);
0060     }
0061 }
0062
0063 void input_dev_poller_stop(struct input_dev_poller *poller)
0064 {
0065     cancel_delayed_work_sync(&poller->work);
0066 }
0067
0068 int input_setup_polling(struct input_dev *dev,
0069             void (*poll_fn)(struct input_dev *dev))
0070 {
0071     struct input_dev_poller *poller;
0072
0073     poller = kzalloc(sizeof(*poller), GFP_KERNEL);
0074     if (!poller) {
0075         /*
0076          * We want to show message even though kzalloc() may have
0077          * printed backtrace as knowing what instance of input
0078          * device we were dealing with is helpful.
0079          */
0080         dev_err(dev->dev.parent ?: &dev->dev,
0081             "%s: unable to allocate poller structure\n", __func__);
0082         return -ENOMEM;
0083     }
0084
0085     INIT_DELAYED_WORK(&poller->work, input_dev_poller_work);
0086     poller->input = dev;
0087     poller->poll = poll_fn;
0088
0089     dev->poller = poller;
0090     return 0;
0091 }
0092 EXPORT_SYMBOL(input_setup_polling);
0093
0094 static bool input_dev_ensure_poller(struct input_dev *dev)
0095 {
0096     if (!dev->poller) {
0097         dev_err(dev->dev.parent ?: &dev->dev,
0098             "poller structure has not been set up\n");
0099         return false;
0100     }
0101
0102     return true;
0103 }
0104
0105 void input_set_poll_interval(struct input_dev *dev, unsigned int interval)
0106 {
0107     if (input_dev_ensure_poller(dev))
0108         dev->poller->poll_interval = interval;
0109 }
0110 EXPORT_SYMBOL(input_set_poll_interval);
0111
0112 void input_set_min_poll_interval(struct input_dev *dev, unsigned int interval)
0113 {
0114     if (input_dev_ensure_poller(dev))
0115         dev->poller->poll_interval_min = interval;
0116 }
0117 EXPORT_SYMBOL(input_set_min_poll_interval);
0118
0119 void input_set_max_poll_interval(struct input_dev *dev, unsigned int interval)
0120 {
0121     if (input_dev_ensure_poller(dev))
0122         dev->poller->poll_interval_max = interval;
0123 }
0124 EXPORT_SYMBOL(input_set_max_poll_interval);
0125
0126 int input_get_poll_interval(struct input_dev *dev)
0127 {
0128     if (!dev->poller)
0129         return -EINVAL;
0130
0131     return dev->poller->poll_interval;
0132 }
0133 EXPORT_SYMBOL(input_get_poll_interval);
0134
0135 /* SYSFS interface */
0136
0137 static ssize_t input_dev_get_poll_interval(struct device *dev,
0138                        struct device_attribute *attr,
0139                        char *buf)
0140 {
0141     struct input_dev *input = to_input_dev(dev);
0142
0143     return sprintf(buf, "%d\n", input->poller->poll_interval);
0144 }
0145
0146 static ssize_t input_dev_set_poll_interval(struct device *dev,
0147                        struct device_attribute *attr,
0148                        const char *buf, size_t count)
0149 {
0150     struct input_dev *input = to_input_dev(dev);
0151     struct input_dev_poller *poller = input->poller;
0152     unsigned int interval;
0153     int err;
0154
0155     err = kstrtouint(buf, 0, &interval);
0156     if (err)
0157         return err;
0158
0159     if (interval < poller->poll_interval_min)
0160         return -EINVAL;
0161
0162     if (interval > poller->poll_interval_max)
0163         return -EINVAL;
0164
0165     mutex_lock(&input->mutex);
0166
0167     poller->poll_interval = interval;
0168
0169     if (input_device_enabled(input)) {
0170         cancel_delayed_work_sync(&poller->work);
0171         if (poller->poll_interval > 0)
0172             input_dev_poller_queue_work(poller);
0173     }
0174
0175     mutex_unlock(&input->mutex);
0176
0177     return count;
0178 }
0179
0180 static DEVICE_ATTR(poll, 0644,
0181            input_dev_get_poll_interval, input_dev_set_poll_interval);
0182
0183 static ssize_t input_dev_get_poll_max(struct device *dev,
0184                       struct device_attribute *attr, char *buf)
0185 {
0186     struct input_dev *input = to_input_dev(dev);
0187
0188     return sprintf(buf, "%d\n", input->poller->poll_interval_max);
0189 }
0190
0191 static DEVICE_ATTR(max, 0444, input_dev_get_poll_max, NULL);
0192
0193 static ssize_t input_dev_get_poll_min(struct device *dev,
0194                      struct device_attribute *attr, char *buf)
0195 {
0196     struct input_dev *input = to_input_dev(dev);
0197
0198     return sprintf(buf, "%d\n", input->poller->poll_interval_min);
0199 }
0200
0201 static DEVICE_ATTR(min, 0444, input_dev_get_poll_min, NULL);
0202
0203 static umode_t input_poller_attrs_visible(struct kobject *kobj,
0204                       struct attribute *attr, int n)
0205 {
0206     struct device *dev = kobj_to_dev(kobj);
0207     struct input_dev *input = to_input_dev(dev);
0208
0209     return input->poller ? attr->mode : 0;
0210 }
0211
0212 static struct attribute *input_poller_attrs[] = {
0213     &dev_attr_poll.attr,
0214     &dev_attr_max.attr,
0215     &dev_attr_min.attr,
0216     NULL
0217 };
0218
0219 struct attribute_group input_poller_attribute_group = {
0220     .is_visible = input_poller_attrs_visible,
0221     .attrs      = input_poller_attrs,
0222 };