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>
8 #include <uapi/linux/virtio_ids.h>
9 #include <uapi/linux/virtio_input.h>
10 #include <linux/input/mt.h>
13 struct virtio_device
*vdev
;
14 struct input_dev
*idev
;
18 struct virtqueue
*evt
, *sts
;
19 struct virtio_input_event evts
[64];
24 static void virtinput_queue_evtbuf(struct virtio_input
*vi
,
25 struct virtio_input_event
*evtbuf
)
27 struct scatterlist sg
[1];
29 sg_init_one(sg
, evtbuf
, sizeof(*evtbuf
));
30 virtqueue_add_inbuf(vi
->evt
, sg
, 1, evtbuf
, GFP_ATOMIC
);
33 static void virtinput_recv_events(struct virtqueue
*vq
)
35 struct virtio_input
*vi
= vq
->vdev
->priv
;
36 struct virtio_input_event
*event
;
40 spin_lock_irqsave(&vi
->lock
, flags
);
42 while ((event
= virtqueue_get_buf(vi
->evt
, &len
)) != NULL
) {
43 spin_unlock_irqrestore(&vi
->lock
, flags
);
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
);
53 spin_unlock_irqrestore(&vi
->lock
, flags
);
57 * On error we are losing the status update, which isn't critical as
58 * this is typically used for stuff like keyboard leds.
60 static int virtinput_send_status(struct virtio_input
*vi
,
61 u16 type
, u16 code
, s32 value
)
63 struct virtio_input_event
*stsbuf
;
64 struct scatterlist sg
[1];
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.
80 if (vi
->idev
->mt
&& type
== EV_MSC
&& code
== MSC_TIMESTAMP
)
83 stsbuf
= kzalloc(sizeof(*stsbuf
), GFP_ATOMIC
);
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
));
92 spin_lock_irqsave(&vi
->lock
, flags
);
94 rc
= virtqueue_add_outbuf(vi
->sts
, sg
, 1, stsbuf
, GFP_ATOMIC
);
95 virtqueue_kick(vi
->sts
);
99 spin_unlock_irqrestore(&vi
->lock
, flags
);
106 static void virtinput_recv_status(struct virtqueue
*vq
)
108 struct virtio_input
*vi
= vq
->vdev
->priv
;
109 struct virtio_input_event
*stsbuf
;
113 spin_lock_irqsave(&vi
->lock
, flags
);
114 while ((stsbuf
= virtqueue_get_buf(vi
->sts
, &len
)) != NULL
)
116 spin_unlock_irqrestore(&vi
->lock
, flags
);
119 static int virtinput_status(struct input_dev
*idev
, unsigned int type
,
120 unsigned int code
, int value
)
122 struct virtio_input
*vi
= input_get_drvdata(idev
);
124 return virtinput_send_status(vi
, type
, code
, value
);
127 static u8
virtinput_cfg_select(struct virtio_input
*vi
,
128 u8 select
, u8 subsel
)
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
);
138 static void virtinput_cfg_bits(struct virtio_input
*vi
, int select
, int subsel
,
139 unsigned long *bits
, unsigned int bitcount
)
145 bytes
= virtinput_cfg_select(vi
, select
, subsel
);
148 if (bitcount
> bytes
* 8)
149 bitcount
= bytes
* 8;
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
156 virtio_bits
= kzalloc(bytes
, GFP_KERNEL
);
159 virtio_cread_bytes(vi
->vdev
, offsetof(struct virtio_input_config
,
162 for (bit
= 0; bit
< bitcount
; bit
++) {
163 if (virtio_bits
[bit
/ 8] & (1 << (bit
% 8)))
164 __set_bit(bit
, bits
);
168 if (select
== VIRTIO_INPUT_CFG_EV_BITS
)
169 __set_bit(subsel
, vi
->idev
->evbit
);
172 static void virtinput_cfg_abs(struct virtio_input
*vi
, int abs
)
174 u32 mi
, ma
, re
, fu
, fl
;
176 virtinput_cfg_select(vi
, VIRTIO_INPUT_CFG_ABS_INFO
, 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(vi
->idev
, abs
, mi
, ma
, fu
, fl
);
183 input_abs_set_res(vi
->idev
, abs
, re
);
186 static int virtinput_init_vqs(struct virtio_input
*vi
)
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" };
194 err
= virtio_find_vqs(vi
->vdev
, 2, vqs
, cbs
, names
, NULL
);
203 static void virtinput_fill_evt(struct virtio_input
*vi
)
208 spin_lock_irqsave(&vi
->lock
, flags
);
209 size
= virtqueue_get_vring_size(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
, &vi
->evts
[i
]);
214 virtqueue_kick(vi
->evt
);
215 spin_unlock_irqrestore(&vi
->lock
, flags
);
218 static int virtinput_probe(struct virtio_device
*vdev
)
220 struct virtio_input
*vi
;
223 int abs
, err
, nslots
;
225 if (!virtio_has_feature(vdev
, VIRTIO_F_VERSION_1
))
228 vi
= kzalloc(sizeof(*vi
), GFP_KERNEL
);
234 spin_lock_init(&vi
->lock
);
236 err
= virtinput_init_vqs(vi
);
240 vi
->idev
= input_allocate_device();
243 goto err_input_alloc
;
245 input_set_drvdata(vi
->idev
, vi
);
247 size
= virtinput_cfg_select(vi
, VIRTIO_INPUT_CFG_ID_NAME
, 0);
248 virtio_cread_bytes(vi
->vdev
, offsetof(struct virtio_input_config
,
250 vi
->name
, min(size
, sizeof(vi
->name
)));
251 size
= virtinput_cfg_select(vi
, VIRTIO_INPUT_CFG_ID_SERIAL
, 0);
252 virtio_cread_bytes(vi
->vdev
, offsetof(struct virtio_input_config
,
254 vi
->serial
, min(size
, sizeof(vi
->serial
)));
255 snprintf(vi
->phys
, sizeof(vi
->phys
),
256 "virtio%d/input0", vdev
->index
);
257 vi
->idev
->name
= vi
->name
;
258 vi
->idev
->phys
= vi
->phys
;
259 vi
->idev
->uniq
= vi
->serial
;
261 size
= virtinput_cfg_select(vi
, VIRTIO_INPUT_CFG_ID_DEVIDS
, 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
);
272 vi
->idev
->id
.bustype
= BUS_VIRTUAL
;
275 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_PROP_BITS
, 0,
276 vi
->idev
->propbit
, INPUT_PROP_CNT
);
277 size
= virtinput_cfg_select(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_REP
);
279 __set_bit(EV_REP
, vi
->idev
->evbit
);
281 vi
->idev
->dev
.parent
= &vdev
->dev
;
282 vi
->idev
->event
= virtinput_status
;
284 /* device -> kernel */
285 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_KEY
,
286 vi
->idev
->keybit
, KEY_CNT
);
287 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_REL
,
288 vi
->idev
->relbit
, REL_CNT
);
289 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_ABS
,
290 vi
->idev
->absbit
, ABS_CNT
);
291 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_MSC
,
292 vi
->idev
->mscbit
, MSC_CNT
);
293 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_SW
,
294 vi
->idev
->swbit
, SW_CNT
);
296 /* kernel -> device */
297 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_LED
,
298 vi
->idev
->ledbit
, LED_CNT
);
299 virtinput_cfg_bits(vi
, VIRTIO_INPUT_CFG_EV_BITS
, EV_SND
,
300 vi
->idev
->sndbit
, SND_CNT
);
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
))
306 virtinput_cfg_abs(vi
, abs
);
309 if (test_bit(ABS_MT_SLOT
, vi
->idev
->absbit
)) {
310 nslots
= input_abs_get_max(vi
->idev
, ABS_MT_SLOT
) + 1;
311 err
= input_mt_init_slots(vi
->idev
, nslots
, 0);
313 goto err_mt_init_slots
;
317 virtio_device_ready(vdev
);
319 err
= input_register_device(vi
->idev
);
321 goto err_input_register
;
323 virtinput_fill_evt(vi
);
327 spin_lock_irqsave(&vi
->lock
, flags
);
329 spin_unlock_irqrestore(&vi
->lock
, flags
);
331 input_free_device(vi
->idev
);
333 vdev
->config
->del_vqs(vdev
);
339 static void virtinput_remove(struct virtio_device
*vdev
)
341 struct virtio_input
*vi
= vdev
->priv
;
345 spin_lock_irqsave(&vi
->lock
, flags
);
347 spin_unlock_irqrestore(&vi
->lock
, flags
);
349 input_unregister_device(vi
->idev
);
350 vdev
->config
->reset(vdev
);
351 while ((buf
= virtqueue_detach_unused_buf(vi
->sts
)) != NULL
)
353 vdev
->config
->del_vqs(vdev
);
357 #ifdef CONFIG_PM_SLEEP
358 static int virtinput_freeze(struct virtio_device
*vdev
)
360 struct virtio_input
*vi
= vdev
->priv
;
363 spin_lock_irqsave(&vi
->lock
, flags
);
365 spin_unlock_irqrestore(&vi
->lock
, flags
);
367 vdev
->config
->del_vqs(vdev
);
371 static int virtinput_restore(struct virtio_device
*vdev
)
373 struct virtio_input
*vi
= vdev
->priv
;
376 err
= virtinput_init_vqs(vi
);
380 virtio_device_ready(vdev
);
382 virtinput_fill_evt(vi
);
387 static unsigned int features
[] = {
390 static const struct virtio_device_id id_table
[] = {
391 { VIRTIO_ID_INPUT
, VIRTIO_DEV_ANY_ID
},
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
,
409 module_virtio_driver(virtio_input_driver
);
410 MODULE_DEVICE_TABLE(virtio
, id_table
);
412 MODULE_LICENSE("GPL");
413 MODULE_DESCRIPTION("Virtio input device driver");
414 MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>");