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