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_info vqs_info[] = {
 189                 { "events", virtinput_recv_events },
 190                 { "status", virtinput_recv_status },
 191         };
 192         struct virtqueue *vqs[2];
 193         int err;
 194
 195         err = virtio_find_vqs(vi->vdev, 2, vqs, vqs_info, NULL);
 196         if (err)
 197                 return err;
 198         vi->evt = vqs[0];
 199         vi->sts = vqs[1];
 200
 201         return 0;
 202 }
 203
 204 static void virtinput_fill_evt(struct virtio_input *vi)
 205 {
 206         unsigned long flags;
 207         int i, size;
 208
 209         spin_lock_irqsave(&vi->lock, flags);
 210         size = virtqueue_get_vring_size(vi->evt);
 211         if (size > ARRAY_SIZE(vi->evts))
 212                 size = ARRAY_SIZE(vi->evts);
 213         for (i = 0; i < size; i++)
 214                 virtinput_queue_evtbuf(vi, &vi->evts[i]);
 215         virtqueue_kick(vi->evt);
 216         spin_unlock_irqrestore(&vi->lock, flags);
 217 }
 218
 219 static int virtinput_probe(struct virtio_device *vdev)
 220 {
 221         struct virtio_input *vi;
 222         unsigned long flags;
 223         size_t size;
 224         int abs, err, nslots;
 225
 226         if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
 227                 return -ENODEV;
 228
 229         vi = kzalloc(sizeof(*vi), GFP_KERNEL);
 230         if (!vi)
 231                 return -ENOMEM;
 232
 233         vdev->priv = vi;
 234         vi->vdev = vdev;
 235         spin_lock_init(&vi->lock);
 236
 237         err = virtinput_init_vqs(vi);
 238         if (err)
 239                 goto err_init_vq;
 240
 241         vi->idev = input_allocate_device();
 242         if (!vi->idev) {
 243                 err = -ENOMEM;
 244                 goto err_input_alloc;
 245         }
 246         input_set_drvdata(vi->idev, vi);
 247
 248         size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_NAME, 0);
 249         virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
 250                                               u.string),
 251                            vi->name, min(size, sizeof(vi->name)));
 252         size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_SERIAL, 0);
 253         virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,
 254                                               u.string),
 255                            vi->serial, min(size, sizeof(vi->serial)));
 256         snprintf(vi->phys, sizeof(vi->phys),
 257                  "virtio%d/input0", vdev->index);
 258         vi->idev->name = vi->name;
 259         vi->idev->phys = vi->phys;
 260         vi->idev->uniq = vi->serial;
 261
 262         size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_DEVIDS, 0);
 263         if (size >= sizeof(struct virtio_input_devids)) {
 264                 virtio_cread_le(vi->vdev, struct virtio_input_config,
 265                                 u.ids.bustype, &vi->idev->id.bustype);
 266                 virtio_cread_le(vi->vdev, struct virtio_input_config,
 267                                 u.ids.vendor, &vi->idev->id.vendor);
 268                 virtio_cread_le(vi->vdev, struct virtio_input_config,
 269                                 u.ids.product, &vi->idev->id.product);
 270                 virtio_cread_le(vi->vdev, struct virtio_input_config,
 271                                 u.ids.version, &vi->idev->id.version);
 272         } else {
 273                 vi->idev->id.bustype = BUS_VIRTUAL;
 274         }
 275
 276         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_PROP_BITS, 0,
 277                            vi->idev->propbit, INPUT_PROP_CNT);
 278         size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REP);
 279         if (size)
 280                 __set_bit(EV_REP, vi->idev->evbit);
 281
 282         vi->idev->dev.parent = &vdev->dev;
 283         vi->idev->event = virtinput_status;
 284
 285         /* device -> kernel */
 286         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_KEY,
 287                            vi->idev->keybit, KEY_CNT);
 288         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REL,
 289                            vi->idev->relbit, REL_CNT);
 290         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_ABS,
 291                            vi->idev->absbit, ABS_CNT);
 292         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_MSC,
 293                            vi->idev->mscbit, MSC_CNT);
 294         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SW,
 295                            vi->idev->swbit,  SW_CNT);
 296
 297         /* kernel -> device */
 298         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_LED,
 299                            vi->idev->ledbit, LED_CNT);
 300         virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SND,
 301                            vi->idev->sndbit, SND_CNT);
 302
 303         if (test_bit(EV_ABS, vi->idev->evbit)) {
 304                 for (abs = 0; abs < ABS_CNT; abs++) {
 305                         if (!test_bit(abs, vi->idev->absbit))
 306                                 continue;
 307                         virtinput_cfg_abs(vi, abs);
 308                 }
 309
 310                 if (test_bit(ABS_MT_SLOT, vi->idev->absbit)) {
 311                         nslots = input_abs_get_max(vi->idev, ABS_MT_SLOT) + 1;
 312                         err = input_mt_init_slots(vi->idev, nslots, 0);
 313                         if (err)
 314                                 goto err_mt_init_slots;
 315                 }
 316         }
 317
 318         virtio_device_ready(vdev);
 319         vi->ready = true;
 320         err = input_register_device(vi->idev);
 321         if (err)
 322                 goto err_input_register;
 323
 324         virtinput_fill_evt(vi);
 325         return 0;
 326
 327 err_input_register:
 328         spin_lock_irqsave(&vi->lock, flags);
 329         vi->ready = false;
 330         spin_unlock_irqrestore(&vi->lock, flags);
 331 err_mt_init_slots:
 332         input_free_device(vi->idev);
 333 err_input_alloc:
 334         vdev->config->del_vqs(vdev);
 335 err_init_vq:
 336         kfree(vi);
 337         return err;
 338 }
 339
 340 static void virtinput_remove(struct virtio_device *vdev)
 341 {
 342         struct virtio_input *vi = vdev->priv;
 343         void *buf;
 344         unsigned long flags;
 345
 346         spin_lock_irqsave(&vi->lock, flags);
 347         vi->ready = false;
 348         spin_unlock_irqrestore(&vi->lock, flags);
 349
 350         input_unregister_device(vi->idev);
 351         virtio_reset_device(vdev);
 352         while ((buf = virtqueue_detach_unused_buf(vi->sts)) != NULL)
 353                 kfree(buf);
 354         vdev->config->del_vqs(vdev);
 355         kfree(vi);
 356 }
 357
 358 #ifdef CONFIG_PM_SLEEP
 359 static int virtinput_freeze(struct virtio_device *vdev)
 360 {
 361         struct virtio_input *vi = vdev->priv;
 362         unsigned long flags;
 363
 364         spin_lock_irqsave(&vi->lock, flags);
 365         vi->ready = false;
 366         spin_unlock_irqrestore(&vi->lock, flags);
 367
 368         vdev->config->del_vqs(vdev);
 369         return 0;
 370 }
 371
 372 static int virtinput_restore(struct virtio_device *vdev)
 373 {
 374         struct virtio_input *vi = vdev->priv;
 375         int err;
 376
 377         err = virtinput_init_vqs(vi);
 378         if (err)
 379                 return err;
 380
 381         virtio_device_ready(vdev);
 382         vi->ready = true;
 383         virtinput_fill_evt(vi);
 384         return 0;
 385 }
 386 #endif
 387
 388 static unsigned int features[] = {
 389         /* none */
 390 };
 391 static const struct virtio_device_id id_table[] = {
 392         { VIRTIO_ID_INPUT, VIRTIO_DEV_ANY_ID },
 393         { 0 },
 394 };
 395
 396 static struct virtio_driver virtio_input_driver = {
 397         .driver.name         = KBUILD_MODNAME,
 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>");