HID: uhid: add internal message buffer

When receiving messages from the HID subsystem, we need to process them
and store them in an internal buffer so user-space can read() on the char
device to retrieve the messages.

This adds a static buffer for 32 messages to each uhid device. Each
message is dynamically allocated so the uhid_device structure does not get
too big.

uhid_queue() adds a message to the buffer. If the buffer is full, the
message is discarded. uhid_queue_event() is an helper for messages without
payload.

This also adds a public header: uhid.h. It contains the declarations for
the user-space API. It is built around "struct uhid_event" which contains
a type field which specifies the event type and each event can then add a
variable-length payload. For now, there is only a dummy event but later
patches will add new event types and payloads.

Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

1 files changed, 65 insertions, 0 deletions

diff --git a/drivers/hid/uhid.c b/drivers/hid/uhid.c
index 5b02d6cb0e60..05ef4b05a63e 100644
--- a/drivers/hid/uhid.c
+++ b/drivers/hid/uhid.c
@@ -25,16 +25,81 @@
 #include <linux/wait.h>
 
 #define UHID_NAME       "uhid"
+#define UHID_BUFSIZE    32
+
+struct uhid_device {
+        struct hid_device *hid;
+
+        wait_queue_head_t waitq;
+        spinlock_t qlock;
+        __u8 head;
+        __u8 tail;
+        struct uhid_event *outq[UHID_BUFSIZE];
+};
 
 static struct miscdevice uhid_misc;
 
+static void uhid_queue(struct uhid_device *uhid, struct uhid_event *ev)
+{
+        __u8 newhead;
+
+        newhead = (uhid->head + 1) % UHID_BUFSIZE;
+
+        if (newhead != uhid->tail) {
+                uhid->outq[uhid->head] = ev;
+                uhid->head = newhead;
+                wake_up_interruptible(&uhid->waitq);
+        } else {
+                hid_warn(uhid->hid, "Output queue is full\n");
+                kfree(ev);
+        }
+}
+
+static int uhid_queue_event(struct uhid_device *uhid, __u32 event)
+{
+        unsigned long flags;
+        struct uhid_event *ev;
+
+        ev = kzalloc(sizeof(*ev), GFP_KERNEL);
+        if (!ev)
+                return -ENOMEM;
+
+        ev->type = event;
+
+        spin_lock_irqsave(&uhid->qlock, flags);
+        uhid_queue(uhid, ev);
+        spin_unlock_irqrestore(&uhid->qlock, flags);
+
+        return 0;
+}
+
 static int uhid_char_open(struct inode *inode, struct file *file)
 {
+        struct uhid_device *uhid;
+
+        uhid = kzalloc(sizeof(*uhid), GFP_KERNEL);
+        if (!uhid)
+                return -ENOMEM;
+
+        spin_lock_init(&uhid->qlock);
+        init_waitqueue_head(&uhid->waitq);
+
+        file->private_data = uhid;
+        nonseekable_open(inode, file);
+
         return 0;
 }
 
 static int uhid_char_release(struct inode *inode, struct file *file)
 {
+        struct uhid_device *uhid = file->private_data;
+        unsigned int i;
+
+        for (i = 0; i < UHID_BUFSIZE; ++i)
+                kfree(uhid->outq[i]);
+
+        kfree(uhid);
+
         return 0;
 }