drivers/virtio/virtio_input.c

   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(vi->evt, sg, 1, 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(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  */
  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(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(vi->sts, sg, 1, stsbuf, GFP_ATOMIC);
  95                 virtqueue_kick(vi->sts);
  96         } else {
  97                 rc = -ENODEV;
  98         }
  99         spin_unlock_irqrestore(&vi->lock, flags);
 100
 101         if (rc != 0)
 102                 kfree(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(vi->sts, &len)) != NULL)
 115                 kfree(stsbuf);
 116         spin_unlock_irqrestore(&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(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(bytes, GFP_KERNEL);
 157         if (!virtio_bits)
 158                 return;
 159         virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
 160                                               u.bitmap),
 161                            virtio_bits, 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(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, 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);
 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(vi->vdev, 2, vqs, 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(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);
 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(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(vi->idev, vi);
 246
 247         size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_NAME, 0);
 248         virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
 249                                               u.string),
 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,
 253                                               u.string),
 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;
 260
 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);
 271         } else {
 272                 vi->idev->id.bustype = BUS_VIRTUAL;
 273         }
 274
 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);
 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, 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);
 295
 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);
 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(vi->idev, ABS_MT_SLOT) + 1;
 311                         err = input_mt_init_slots(vi->idev, nslots, 0);
 312                         if (err)
 313                                 goto err_mt_init_slots;
 314                 }
 315         }
 316
 317         virtio_device_ready(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(&vi->lock, flags);
 330 err_mt_init_slots:
 331         input_free_device(vi->idev);
 332 err_input_alloc:
 333         vdev->config->del_vqs(vdev);
 334 err_init_vq:
 335         kfree(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(&vi->lock, flags);
 348
 349         input_unregister_device(vi->idev);
 350         virtio_reset_device(vdev);
 351         while ((buf = virtqueue_detach_unused_buf(vi->sts)) != NULL)
 352                 kfree(buf);
 353         vdev->config->del_vqs(vdev);
 354         kfree(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(&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(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>");