1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/module.h>
3 #include <linux/virtio.h>
4 #include <linux/virtio_config.h>
5 #include <linux/input.h>
6 #include <linux/slab.h>
7 #include <linux/input/mt.h>
8
9 #include <uapi/linux/virtio_ids.h>
10 #include <uapi/linux/virtio_input.h>
11
12 struct virtio_input {
13 struct virtio_device *vdev;
14 struct input_dev *idev;
15 char name[64];
16 char serial[64];
17 char phys[64];
18 struct virtqueue *evt, *sts;
19 struct virtio_input_event evts[64];
20 spinlock_t lock;
21 bool ready;
22 };
23
virtinput_queue_evtbuf(struct virtio_input * vi,struct virtio_input_event * evtbuf)24 static void virtinput_queue_evtbuf(struct virtio_input *vi,
25 struct virtio_input_event *evtbuf)
26 {
27 struct scatterlist sg[1];
28
29 sg_init_one(sg, evtbuf, sizeof(*evtbuf));
30 virtqueue_add_inbuf(vi->evt, sg, 1, evtbuf, GFP_ATOMIC);
31 }
32
virtinput_recv_events(struct virtqueue * vq)33 static void virtinput_recv_events(struct virtqueue *vq)
34 {
35 struct virtio_input *vi = vq->vdev->priv;
36 struct virtio_input_event *event;
37 unsigned long flags;
38 unsigned int len;
39
40 spin_lock_irqsave(&vi->lock, flags);
41 if (vi->ready) {
42 while ((event = virtqueue_get_buf(vi->evt, &len)) != NULL) {
43 spin_unlock_irqrestore(&vi->lock, flags);
44 input_event(vi->idev,
45 le16_to_cpu(event->type),
46 le16_to_cpu(event->code),
47 le32_to_cpu(event->value));
48 spin_lock_irqsave(&vi->lock, flags);
49 virtinput_queue_evtbuf(vi, event);
50 }
51 virtqueue_kick(vq);
52 }
53 spin_unlock_irqrestore(&vi->lock, flags);
54 }
55
56 /*
57 * On error we are losing the status update, which isn't critical as
58 * this is typically used for stuff like keyboard leds.
59 */
virtinput_send_status(struct virtio_input * vi,u16 type,u16 code,s32 value)60 static int virtinput_send_status(struct virtio_input *vi,
61 u16 type, u16 code, s32 value)
62 {
63 struct virtio_input_event *stsbuf;
64 struct scatterlist sg[1];
65 unsigned long flags;
66 int rc;
67
68 stsbuf = kzalloc(sizeof(*stsbuf), GFP_ATOMIC);
69 if (!stsbuf)
70 return -ENOMEM;
71
72 stsbuf->type = cpu_to_le16(type);
73 stsbuf->code = cpu_to_le16(code);
74 stsbuf->value = cpu_to_le32(value);
75 sg_init_one(sg, stsbuf, sizeof(*stsbuf));
76
77 spin_lock_irqsave(&vi->lock, flags);
78 if (vi->ready) {
79 rc = virtqueue_add_outbuf(vi->sts, sg, 1, stsbuf, GFP_ATOMIC);
80 virtqueue_kick(vi->sts);
81 } else {
82 rc = -ENODEV;
83 }
84 spin_unlock_irqrestore(&vi->lock, flags);
85
86 if (rc != 0)
87 kfree(stsbuf);
88 return rc;
89 }
90
virtinput_recv_status(struct virtqueue * vq)91 static void virtinput_recv_status(struct virtqueue *vq)
92 {
93 struct virtio_input *vi = vq->vdev->priv;
94 struct virtio_input_event *stsbuf;
95 unsigned long flags;
96 unsigned int len;
97
98 spin_lock_irqsave(&vi->lock, flags);
99 while ((stsbuf = virtqueue_get_buf(vi->sts, &len)) != NULL)
100 kfree(stsbuf);
101 spin_unlock_irqrestore(&vi->lock, flags);
102 }
103
virtinput_status(struct input_dev * idev,unsigned int type,unsigned int code,int value)104 static int virtinput_status(struct input_dev *idev, unsigned int type,
105 unsigned int code, int value)
106 {
107 struct virtio_input *vi = input_get_drvdata(idev);
108
109 return virtinput_send_status(vi, type, code, value);
110 }
111
virtinput_cfg_select(struct virtio_input * vi,u8 select,u8 subsel)112 static u8 virtinput_cfg_select(struct virtio_input *vi,
113 u8 select, u8 subsel)
114 {
115 u8 size;
116
117 virtio_cwrite_le(vi->vdev, struct virtio_input_config, select, &select);
118 virtio_cwrite_le(vi->vdev, struct virtio_input_config, subsel, &subsel);
119 virtio_cread_le(vi->vdev, struct virtio_input_config, size, &size);
120 return size;
121 }
122
virtinput_cfg_bits(struct virtio_input * vi,int select,int subsel,unsigned long * bits,unsigned int bitcount)123 static void virtinput_cfg_bits(struct virtio_input *vi, int select, int subsel,
124 unsigned long *bits, unsigned int bitcount)
125 {
126 unsigned int bit;
127 u8 *virtio_bits;
128 u8 bytes;
129
130 bytes = virtinput_cfg_select(vi, select, subsel);
131 if (!bytes)
132 return;
133 if (bitcount > bytes * 8)
134 bitcount = bytes * 8;
135
136 /*
137 * Bitmap in virtio config space is a simple stream of bytes,
138 * with the first byte carrying bits 0-7, second bits 8-15 and
139 * so on.
140 */
141 virtio_bits = kzalloc(bytes, GFP_KERNEL);
142 if (!virtio_bits)
143 return;
144 virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
145 u.bitmap),
146 virtio_bits, bytes);
147 for (bit = 0; bit < bitcount; bit++) {
148 if (virtio_bits[bit / 8] & (1 << (bit % 8)))
149 __set_bit(bit, bits);
150 }
151 kfree(virtio_bits);
152
153 if (select == VIRTIO_INPUT_CFG_EV_BITS)
154 __set_bit(subsel, vi->idev->evbit);
155 }
156
virtinput_cfg_abs(struct virtio_input * vi,int abs)157 static void virtinput_cfg_abs(struct virtio_input *vi, int abs)
158 {
159 u32 mi, ma, re, fu, fl;
160
161 virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ABS_INFO, abs);
162 virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.min, &mi);
163 virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.max, &ma);
164 virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.res, &re);
165 virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.fuzz, &fu);
166 virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.flat, &fl);
167 input_set_abs_params(vi->idev, abs, mi, ma, fu, fl);
168 input_abs_set_res(vi->idev, abs, re);
169 if (abs == ABS_MT_TRACKING_ID) {
170 unsigned int slot_flags =
171 test_bit(INPUT_PROP_DIRECT, vi->idev->propbit) ?
172 INPUT_MT_DIRECT : 0;
173
174 input_mt_init_slots(vi->idev,
175 ma, /* input max finger */
176 slot_flags);
177 }
178 }
179
virtinput_init_vqs(struct virtio_input * vi)180 static int virtinput_init_vqs(struct virtio_input *vi)
181 {
182 struct virtqueue *vqs[2];
183 vq_callback_t *cbs[] = { virtinput_recv_events,
184 virtinput_recv_status };
185 static const char * const names[] = { "events", "status" };
186 int err;
187
188 err = virtio_find_vqs(vi->vdev, 2, vqs, cbs, names, NULL);
189 if (err)
190 return err;
191 vi->evt = vqs[0];
192 vi->sts = vqs[1];
193
194 return 0;
195 }
196
virtinput_fill_evt(struct virtio_input * vi)197 static void virtinput_fill_evt(struct virtio_input *vi)
198 {
199 unsigned long flags;
200 int i, size;
201
202 spin_lock_irqsave(&vi->lock, flags);
203 size = virtqueue_get_vring_size(vi->evt);
204 if (size > ARRAY_SIZE(vi->evts))
205 size = ARRAY_SIZE(vi->evts);
206 for (i = 0; i < size; i++)
207 virtinput_queue_evtbuf(vi, &vi->evts[i]);
208 virtqueue_kick(vi->evt);
209 spin_unlock_irqrestore(&vi->lock, flags);
210 }
211
virtinput_probe(struct virtio_device * vdev)212 static int virtinput_probe(struct virtio_device *vdev)
213 {
214 struct virtio_input *vi;
215 unsigned long flags;
216 size_t size;
217 int abs, err;
218
219 if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
220 return -ENODEV;
221
222 vi = kzalloc(sizeof(*vi), GFP_KERNEL);
223 if (!vi)
224 return -ENOMEM;
225
226 vdev->priv = vi;
227 vi->vdev = vdev;
228 spin_lock_init(&vi->lock);
229
230 err = virtinput_init_vqs(vi);
231 if (err)
232 goto err_init_vq;
233
234 vi->idev = input_allocate_device();
235 if (!vi->idev) {
236 err = -ENOMEM;
237 goto err_input_alloc;
238 }
239 input_set_drvdata(vi->idev, vi);
240
241 size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_NAME, 0);
242 virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
243 u.string),
244 vi->name, min(size, sizeof(vi->name)));
245 size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_SERIAL, 0);
246 virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
247 u.string),
248 vi->serial, min(size, sizeof(vi->serial)));
249 snprintf(vi->phys, sizeof(vi->phys),
250 "virtio%d/input0", vdev->index);
251 vi->idev->name = vi->name;
252 vi->idev->phys = vi->phys;
253 vi->idev->uniq = vi->serial;
254
255 size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_DEVIDS, 0);
256 if (size >= sizeof(struct virtio_input_devids)) {
257 virtio_cread_le(vi->vdev, struct virtio_input_config,
258 u.ids.bustype, &vi->idev->id.bustype);
259 virtio_cread_le(vi->vdev, struct virtio_input_config,
260 u.ids.vendor, &vi->idev->id.vendor);
261 virtio_cread_le(vi->vdev, struct virtio_input_config,
262 u.ids.product, &vi->idev->id.product);
263 virtio_cread_le(vi->vdev, struct virtio_input_config,
264 u.ids.version, &vi->idev->id.version);
265 } else {
266 vi->idev->id.bustype = BUS_VIRTUAL;
267 }
268
269 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_PROP_BITS, 0,
270 vi->idev->propbit, INPUT_PROP_CNT);
271 size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REP);
272 if (size)
273 __set_bit(EV_REP, vi->idev->evbit);
274
275 vi->idev->dev.parent = &vdev->dev;
276 vi->idev->event = virtinput_status;
277
278 /* device -> kernel */
279 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_KEY,
280 vi->idev->keybit, KEY_CNT);
281 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REL,
282 vi->idev->relbit, REL_CNT);
283 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_ABS,
284 vi->idev->absbit, ABS_CNT);
285 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_MSC,
286 vi->idev->mscbit, MSC_CNT);
287 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SW,
288 vi->idev->swbit, SW_CNT);
289
290 /* kernel -> device */
291 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_LED,
292 vi->idev->ledbit, LED_CNT);
293 virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SND,
294 vi->idev->sndbit, SND_CNT);
295
296 if (test_bit(EV_ABS, vi->idev->evbit)) {
297 for (abs = 0; abs < ABS_CNT; abs++) {
298 if (!test_bit(abs, vi->idev->absbit))
299 continue;
300 virtinput_cfg_abs(vi, abs);
301 }
302 }
303
304 virtio_device_ready(vdev);
305 vi->ready = true;
306 err = input_register_device(vi->idev);
307 if (err)
308 goto err_input_register;
309
310 virtinput_fill_evt(vi);
311 return 0;
312
313 err_input_register:
314 spin_lock_irqsave(&vi->lock, flags);
315 vi->ready = false;
316 spin_unlock_irqrestore(&vi->lock, flags);
317 input_free_device(vi->idev);
318 err_input_alloc:
319 vdev->config->del_vqs(vdev);
320 err_init_vq:
321 kfree(vi);
322 return err;
323 }
324
virtinput_remove(struct virtio_device * vdev)325 static void virtinput_remove(struct virtio_device *vdev)
326 {
327 struct virtio_input *vi = vdev->priv;
328 void *buf;
329 unsigned long flags;
330
331 spin_lock_irqsave(&vi->lock, flags);
332 vi->ready = false;
333 spin_unlock_irqrestore(&vi->lock, flags);
334
335 input_unregister_device(vi->idev);
336 vdev->config->reset(vdev);
337 while ((buf = virtqueue_detach_unused_buf(vi->sts)) != NULL)
338 kfree(buf);
339 vdev->config->del_vqs(vdev);
340 kfree(vi);
341 }
342
343 #ifdef CONFIG_PM_SLEEP
virtinput_freeze(struct virtio_device * vdev)344 static int virtinput_freeze(struct virtio_device *vdev)
345 {
346 struct virtio_input *vi = vdev->priv;
347 unsigned long flags;
348
349 spin_lock_irqsave(&vi->lock, flags);
350 vi->ready = false;
351 spin_unlock_irqrestore(&vi->lock, flags);
352
353 vdev->config->del_vqs(vdev);
354 return 0;
355 }
356
virtinput_restore(struct virtio_device * vdev)357 static int virtinput_restore(struct virtio_device *vdev)
358 {
359 struct virtio_input *vi = vdev->priv;
360 int err;
361
362 err = virtinput_init_vqs(vi);
363 if (err)
364 return err;
365
366 virtio_device_ready(vdev);
367 vi->ready = true;
368 virtinput_fill_evt(vi);
369 return 0;
370 }
371 #endif
372
373 static unsigned int features[] = {
374 /* none */
375 };
376 static const struct virtio_device_id id_table[] = {
377 { VIRTIO_ID_INPUT, VIRTIO_DEV_ANY_ID },
378 { 0 },
379 };
380
381 static struct virtio_driver virtio_input_driver = {
382 .driver.name = KBUILD_MODNAME,
383 .driver.owner = THIS_MODULE,
384 .feature_table = features,
385 .feature_table_size = ARRAY_SIZE(features),
386 .id_table = id_table,
387 .probe = virtinput_probe,
388 .remove = virtinput_remove,
389 #ifdef CONFIG_PM_SLEEP
390 .freeze = virtinput_freeze,
391 .restore = virtinput_restore,
392 #endif
393 };
394
395 module_virtio_driver(virtio_input_driver);
396 MODULE_DEVICE_TABLE(virtio, id_table);
397
398 MODULE_LICENSE("GPL");
399 MODULE_DESCRIPTION("Virtio input device driver");
400 MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>");
401