drivers/input/input-poller.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Support for polling mode for input devices.
   4  */
   5
   6 #include <linux/device.h>
   7 #include <linux/input.h>
   8 #include <linux/jiffies.h>
   9 #include <linux/mutex.h>
  10 #include <linux/slab.h>
  11 #include <linux/types.h>
  12 #include <linux/workqueue.h>
  13 #include "input-poller.h"
  14
  15 struct input_dev_poller {
  16         void (*poll)(struct input_dev *dev);
  17
  18         unsigned int poll_interval; /* msec */
  19         unsigned int poll_interval_max; /* msec */
  20         unsigned int poll_interval_min; /* msec */
  21
  22         struct input_dev *input;
  23         struct delayed_work work;
  24 };
  25
  26 static void input_dev_poller_queue_work(struct input_dev_poller *poller)
  27 {
  28         unsigned long delay;
  29
  30         delay = msecs_to_jiffies(poller->poll_interval);
  31         if (delay >= HZ)
  32                 delay = round_jiffies_relative(delay);
  33
  34         queue_delayed_work(system_freezable_wq, &poller->work, delay);
  35 }
  36
  37 static void input_dev_poller_work(struct work_struct *work)
  38 {
  39         struct input_dev_poller *poller =
  40                 container_of(work, struct input_dev_poller, work.work);
  41
  42         poller->poll(poller->input);
  43         input_dev_poller_queue_work(poller);
  44 }
  45
  46 void input_dev_poller_finalize(struct input_dev_poller *poller)
  47 {
  48         if (!poller->poll_interval)
  49                 poller->poll_interval = 500;
  50         if (!poller->poll_interval_max)
  51                 poller->poll_interval_max = poller->poll_interval;
  52 }
  53
  54 void input_dev_poller_start(struct input_dev_poller *poller)
  55 {
  56         /* Only start polling if polling is enabled */
  57         if (poller->poll_interval > 0) {
  58                 poller->poll(poller->input);
  59                 input_dev_poller_queue_work(poller);
  60         }
  61 }
  62
  63 void input_dev_poller_stop(struct input_dev_poller *poller)
  64 {
  65         cancel_delayed_work_sync(&poller->work);
  66 }
  67
  68 int input_setup_polling(struct input_dev *dev,
  69                         void (*poll_fn)(struct input_dev *dev))
  70 {
  71         struct input_dev_poller *poller;
  72
  73         poller = kzalloc(sizeof(*poller), GFP_KERNEL);
  74         if (!poller) {
  75                 /*
  76                  * We want to show message even though kzalloc() may have
  77                  * printed backtrace as knowing what instance of input
  78                  * device we were dealing with is helpful.
  79                  */
  80                 dev_err(dev->dev.parent ?: &dev->dev,
  81                         "%s: unable to allocate poller structure\n", __func__);
  82                 return -ENOMEM;
  83         }
  84
  85         INIT_DELAYED_WORK(&poller->work, input_dev_poller_work);
  86         poller->input = dev;
  87         poller->poll = poll_fn;
  88
  89         dev->poller = poller;
  90         return 0;
  91 }
  92 EXPORT_SYMBOL(input_setup_polling);
  93
  94 static bool input_dev_ensure_poller(struct input_dev *dev)
  95 {
  96         if (!dev->poller) {
  97                 dev_err(dev->dev.parent ?: &dev->dev,
  98                         "poller structure has not been set up\n");
  99                 return false;
 100         }
 101
 102         return true;
 103 }
 104
 105 void input_set_poll_interval(struct input_dev *dev, unsigned int interval)
 106 {
 107         if (input_dev_ensure_poller(dev))
 108                 dev->poller->poll_interval = interval;
 109 }
 110 EXPORT_SYMBOL(input_set_poll_interval);
 111
 112 void input_set_min_poll_interval(struct input_dev *dev, unsigned int interval)
 113 {
 114         if (input_dev_ensure_poller(dev))
 115                 dev->poller->poll_interval_min = interval;
 116 }
 117 EXPORT_SYMBOL(input_set_min_poll_interval);
 118
 119 void input_set_max_poll_interval(struct input_dev *dev, unsigned int interval)
 120 {
 121         if (input_dev_ensure_poller(dev))
 122                 dev->poller->poll_interval_max = interval;
 123 }
 124 EXPORT_SYMBOL(input_set_max_poll_interval);
 125
 126 int input_get_poll_interval(struct input_dev *dev)
 127 {
 128         if (!dev->poller)
 129                 return -EINVAL;
 130
 131         return dev->poller->poll_interval;
 132 }
 133 EXPORT_SYMBOL(input_get_poll_interval);
 134
 135 /* SYSFS interface */
 136
 137 static ssize_t input_dev_get_poll_interval(struct device *dev,
 138                                            struct device_attribute *attr,
 139                                            char *buf)
 140 {
 141         struct input_dev *input = to_input_dev(dev);
 142
 143         return sprintf(buf, "%d\n", input->poller->poll_interval);
 144 }
 145
 146 static ssize_t input_dev_set_poll_interval(struct device *dev,
 147                                            struct device_attribute *attr,
 148                                            const char *buf, size_t count)
 149 {
 150         struct input_dev *input = to_input_dev(dev);
 151         struct input_dev_poller *poller = input->poller;
 152         unsigned int interval;
 153         int err;
 154
 155         err = kstrtouint(buf, 0, &interval);
 156         if (err)
 157                 return err;
 158
 159         if (interval < poller->poll_interval_min)
 160                 return -EINVAL;
 161
 162         if (interval > poller->poll_interval_max)
 163                 return -EINVAL;
 164
 165         mutex_lock(&input->mutex);
 166
 167         poller->poll_interval = interval;
 168
 169         if (input->users) {
 170                 cancel_delayed_work_sync(&poller->work);
 171                 if (poller->poll_interval > 0)
 172                         input_dev_poller_queue_work(poller);
 173         }
 174
 175         mutex_unlock(&input->mutex);
 176
 177         return count;
 178 }
 179
 180 static DEVICE_ATTR(poll, 0644,
 181                    input_dev_get_poll_interval, input_dev_set_poll_interval);
 182
 183 static ssize_t input_dev_get_poll_max(struct device *dev,
 184                                       struct device_attribute *attr, char *buf)
 185 {
 186         struct input_dev *input = to_input_dev(dev);
 187
 188         return sprintf(buf, "%d\n", input->poller->poll_interval_max);
 189 }
 190
 191 static DEVICE_ATTR(max, 0444, input_dev_get_poll_max, NULL);
 192
 193 static ssize_t input_dev_get_poll_min(struct device *dev,
 194                                      struct device_attribute *attr, char *buf)
 195 {
 196         struct input_dev *input = to_input_dev(dev);
 197
 198         return sprintf(buf, "%d\n", input->poller->poll_interval_min);
 199 }
 200
 201 static DEVICE_ATTR(min, 0444, input_dev_get_poll_min, NULL);
 202
 203 static umode_t input_poller_attrs_visible(struct kobject *kobj,
 204                                           struct attribute *attr, int n)
 205 {
 206         struct device *dev = kobj_to_dev(kobj);
 207         struct input_dev *input = to_input_dev(dev);
 208
 209         return input->poller ? attr->mode : 0;
 210 }
 211
 212 static struct attribute *input_poller_attrs[] = {
 213         &dev_attr_poll.attr,
 214         &dev_attr_max.attr,
 215         &dev_attr_min.attr,
 216         NULL
 217 };
 218
 219 struct attribute_group input_poller_attribute_group = {
 220         .is_visible     = input_poller_attrs_visible,
 221         .attrs          = input_poller_attrs,
 222 };