linux-imx

#include <linux/module.h>

#include <linux/virtio.h>

#include <linux/virtio_config.h>

#include <linux/input.h>

​

#include <uapi/linux/virtio_ids.h>

#include <uapi/linux/virtio_input.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;

    struct virtio_input_event  evts[64];

    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(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;

​

    stsbuf = kzalloc(sizeof(*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;