Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422// SPDX-License-Identifier: GPL-2.0-only#include <linux/module.h>#include <linux/virtio.h>#include <linux/virtio_config.h>#include <linux/input.h>#include <linux/slab.h>#include <linux/dma-mapping.h>
#include <uapi/linux/virtio_ids.h>#include <uapi/linux/virtio_input.h>#include <linux/input/mt.h>
struct virtio_input { struct virtio_device *vdev; struct input_dev *idev; char name[64]; char serial[64]; char phys[64]; struct virtqueue *evt, *sts; __dma_from_device_group_begin(); struct virtio_input_event evts[64]; __dma_from_device_group_end(); spinlock_t lock; bool ready;};
static void virtinput_queue_evtbuf(struct virtio_input *vi, struct virtio_input_event *evtbuf){ struct scatterlist sg[1];
sg_init_one(sg, evtbuf, sizeof(*evtbuf)); virtqueue_add_inbuf_cache_clean(vi->evt, sg, 1, evtbuf, GFP_ATOMIC);}
static void virtinput_recv_events(struct virtqueue *vq){ struct virtio_input *vi = vq->vdev->priv; struct virtio_input_event *event; unsigned long flags; unsigned int len;
spin_lock_irqsave(&vi->lock, flags); if (vi->ready) { while ((event = virtqueue_get_buf(vi->evt, &len)) != NULL) { spin_unlock_irqrestore(&vi->lock, flags); input_event(vi->idev, le16_to_cpu(event->type), le16_to_cpu(event->code), le32_to_cpu(event->value)); spin_lock_irqsave(&vi->lock, flags); virtinput_queue_evtbuf(vi, event); } virtqueue_kick(vq); } spin_unlock_irqrestore(&vi->lock, flags);}
/* * On error we are losing the status update, which isn't critical as * this is typically used for stuff like keyboard leds. */static int virtinput_send_status(struct virtio_input *vi, u16 type, u16 code, s32 value){ struct virtio_input_event *stsbuf; struct scatterlist sg[1]; unsigned long flags; int rc;
/* * Since 29cc309d8bf1 (HID: hid-multitouch: forward MSC_TIMESTAMP), * EV_MSC/MSC_TIMESTAMP is added to each before EV_SYN event. * EV_MSC is configured as INPUT_PASS_TO_ALL. * In case of touch device: * BE pass EV_MSC/MSC_TIMESTAMP to FE on receiving event from evdev. * FE pass EV_MSC/MSC_TIMESTAMP back to BE. * BE writes EV_MSC/MSC_TIMESTAMP to evdev due to INPUT_PASS_TO_ALL. * BE receives extra EV_MSC/MSC_TIMESTAMP and pass to FE. * >>> Each new frame becomes larger and larger. * Disable EV_MSC/MSC_TIMESTAMP forwarding for MT. */ if (vi->idev->mt && type == EV_MSC && code == MSC_TIMESTAMP) return 0;
stsbuf = kzalloc_obj(*stsbuf, GFP_ATOMIC); if (!stsbuf) return -ENOMEM;
stsbuf->type = cpu_to_le16(type); stsbuf->code = cpu_to_le16(code); stsbuf->value = cpu_to_le32(value); sg_init_one(sg, stsbuf, sizeof(*stsbuf));
spin_lock_irqsave(&vi->lock, flags); if (vi->ready) { rc = virtqueue_add_outbuf(vi->sts, sg, 1, stsbuf, GFP_ATOMIC); virtqueue_kick(vi->sts); } else { rc = -ENODEV; } spin_unlock_irqrestore(&vi->lock, flags);
if (rc != 0) kfree(stsbuf); return rc;}
static void virtinput_recv_status(struct virtqueue *vq){ struct virtio_input *vi = vq->vdev->priv; struct virtio_input_event *stsbuf; unsigned long flags; unsigned int len;
spin_lock_irqsave(&vi->lock, flags); while ((stsbuf = virtqueue_get_buf(vi->sts, &len)) != NULL) kfree(stsbuf); spin_unlock_irqrestore(&vi->lock, flags);}
static int virtinput_status(struct input_dev *idev, unsigned int type, unsigned int code, int value){ struct virtio_input *vi = input_get_drvdata(idev);
return virtinput_send_status(vi, type, code, value);}
static u8 virtinput_cfg_select(struct virtio_input *vi, u8 select, u8 subsel){ u8 size;
virtio_cwrite_le(vi->vdev, struct virtio_input_config, select, &select); virtio_cwrite_le(vi->vdev, struct virtio_input_config, subsel, &subsel); virtio_cread_le(vi->vdev, struct virtio_input_config, size, &size); return size;}
static void virtinput_cfg_bits(struct virtio_input *vi, int select, int subsel, unsigned long *bits, unsigned int bitcount){ unsigned int bit; u8 *virtio_bits; u8 bytes;
bytes = virtinput_cfg_select(vi, select, subsel); if (!bytes) return; if (bitcount > bytes * 8) bitcount = bytes * 8;
/* * Bitmap in virtio config space is a simple stream of bytes, * with the first byte carrying bits 0-7, second bits 8-15 and * so on. */ virtio_bits = kzalloc(bytes, GFP_KERNEL); if (!virtio_bits) return; virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config, u.bitmap), virtio_bits, bytes); for (bit = 0; bit < bitcount; bit++) { if (virtio_bits[bit / 8] & (1 << (bit % 8))) __set_bit(bit, bits); } kfree(virtio_bits);
if (select == VIRTIO_INPUT_CFG_EV_BITS) __set_bit(subsel, vi->idev->evbit);}
static void virtinput_cfg_abs(struct virtio_input *vi, int abs){ u32 mi, ma, re, fu, fl;
virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ABS_INFO, abs); virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.min, &mi); virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.max, &ma); virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.res, &re); virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.fuzz, &fu); virtio_cread_le(vi->vdev, struct virtio_input_config, u.abs.flat, &fl); input_set_abs_params(vi->idev, abs, mi, ma, fu, fl); input_abs_set_res(vi->idev, abs, re);}
static int virtinput_init_vqs(struct virtio_input *vi){ struct virtqueue_info vqs_info[] = { { "events", virtinput_recv_events }, { "status", virtinput_recv_status }, }; struct virtqueue *vqs[2]; int err;
err = virtio_find_vqs(vi->vdev, 2, vqs, vqs_info, NULL); if (err) return err; vi->evt = vqs[0]; vi->sts = vqs[1];
return 0;}
static void virtinput_fill_evt(struct virtio_input *vi){ unsigned long flags; int i, size;
spin_lock_irqsave(&vi->lock, flags); size = virtqueue_get_vring_size(vi->evt); if (size > ARRAY_SIZE(vi->evts)) size = ARRAY_SIZE(vi->evts); for (i = 0; i < size; i++) virtinput_queue_evtbuf(vi, &vi->evts[i]); virtqueue_kick(vi->evt); spin_unlock_irqrestore(&vi->lock, flags);}
static int virtinput_probe(struct virtio_device *vdev){ struct virtio_input *vi; unsigned long flags; size_t size; int abs, err, nslots;
if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) return -ENODEV;
vi = kzalloc_obj(*vi); if (!vi) return -ENOMEM;
vdev->priv = vi; vi->vdev = vdev; spin_lock_init(&vi->lock);
err = virtinput_init_vqs(vi); if (err) goto err_init_vq;
vi->idev = input_allocate_device(); if (!vi->idev) { err = -ENOMEM; goto err_input_alloc; } input_set_drvdata(vi->idev, vi);
size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_NAME, 0); virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config, u.string), vi->name, min(size, sizeof(vi->name))); size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_SERIAL, 0); virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config, u.string), vi->serial, min(size, sizeof(vi->serial))); snprintf(vi->phys, sizeof(vi->phys), "virtio%d/input0", vdev->index); vi->idev->name = vi->name; vi->idev->phys = vi->phys; vi->idev->uniq = vi->serial;
size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_DEVIDS, 0); if (size >= sizeof(struct virtio_input_devids)) { virtio_cread_le(vi->vdev, struct virtio_input_config, u.ids.bustype, &vi->idev->id.bustype); virtio_cread_le(vi->vdev, struct virtio_input_config, u.ids.vendor, &vi->idev->id.vendor); virtio_cread_le(vi->vdev, struct virtio_input_config, u.ids.product, &vi->idev->id.product); virtio_cread_le(vi->vdev, struct virtio_input_config, u.ids.version, &vi->idev->id.version); } else { vi->idev->id.bustype = BUS_VIRTUAL; }
virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_PROP_BITS, 0, vi->idev->propbit, INPUT_PROP_CNT); size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REP); if (size) __set_bit(EV_REP, vi->idev->evbit);
vi->idev->dev.parent = &vdev->dev; vi->idev->event = virtinput_status;
/* device -> kernel */ virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_KEY, vi->idev->keybit, KEY_CNT); virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REL, vi->idev->relbit, REL_CNT); virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_ABS, vi->idev->absbit, ABS_CNT); virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_MSC, vi->idev->mscbit, MSC_CNT); virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SW, vi->idev->swbit, SW_CNT);
/* kernel -> device */ virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_LED, vi->idev->ledbit, LED_CNT); virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SND, vi->idev->sndbit, SND_CNT);
if (test_bit(EV_ABS, vi->idev->evbit)) { for (abs = 0; abs < ABS_CNT; abs++) { if (!test_bit(abs, vi->idev->absbit)) continue; virtinput_cfg_abs(vi, abs); }
if (test_bit(ABS_MT_SLOT, vi->idev->absbit)) { nslots = input_abs_get_max(vi->idev, ABS_MT_SLOT) + 1; err = input_mt_init_slots(vi->idev, nslots, 0); if (err) goto err_mt_init_slots; } }
virtio_device_ready(vdev); vi->ready = true; err = input_register_device(vi->idev); if (err) goto err_input_register;
virtinput_fill_evt(vi); return 0;
err_input_register: spin_lock_irqsave(&vi->lock, flags); vi->ready = false; spin_unlock_irqrestore(&vi->lock, flags);err_mt_init_slots: input_free_device(vi->idev);err_input_alloc: vdev->config->del_vqs(vdev);err_init_vq: kfree(vi); return err;}
static void virtinput_remove(struct virtio_device *vdev){ struct virtio_input *vi = vdev->priv; void *buf; unsigned long flags;
spin_lock_irqsave(&vi->lock, flags); vi->ready = false; spin_unlock_irqrestore(&vi->lock, flags);
input_unregister_device(vi->idev); virtio_reset_device(vdev); while ((buf = virtqueue_detach_unused_buf(vi->sts)) != NULL) kfree(buf); vdev->config->del_vqs(vdev); kfree(vi);}
#ifdef CONFIG_PM_SLEEPstatic int virtinput_freeze(struct virtio_device *vdev){ struct virtio_input *vi = vdev->priv; unsigned long flags; void *buf;
spin_lock_irqsave(&vi->lock, flags); vi->ready = false; spin_unlock_irqrestore(&vi->lock, flags);
virtio_reset_device(vdev); while ((buf = virtqueue_detach_unused_buf(vi->sts)) != NULL) kfree(buf); vdev->config->del_vqs(vdev); return 0;}
static int virtinput_restore(struct virtio_device *vdev){ struct virtio_input *vi = vdev->priv; int err;
err = virtinput_init_vqs(vi); if (err) return err;
virtio_device_ready(vdev); vi->ready = true; virtinput_fill_evt(vi); return 0;}#endif
static unsigned int features[] = { /* none */};static const struct virtio_device_id id_table[] = { { VIRTIO_ID_INPUT, VIRTIO_DEV_ANY_ID }, { 0 },};
static struct virtio_driver virtio_input_driver = { .driver.name = KBUILD_MODNAME, .feature_table = features, .feature_table_size = ARRAY_SIZE(features), .id_table = id_table, .probe = virtinput_probe, .remove = virtinput_remove,#ifdef CONFIG_PM_SLEEP .freeze = virtinput_freeze, .restore = virtinput_restore,#endif};
module_virtio_driver(virtio_input_driver);MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_LICENSE("GPL");MODULE_DESCRIPTION("Virtio input device driver");MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>");