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