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