Input: evdev - convert to dynamic event buffer

#define EVDEV_MINOR_BASE	64

#define EVDEV_MINORS		32

#define EVDEV_BUFFER_SIZE	64

#define EVDEV_MIN_BUFFER_SIZE	64

#include <linux/poll.h>

#include <linux/sched.h>

};

struct evdev_client {

	struct input_event buffer[EVDEV_BUFFER_SIZE];

	int head;

	int tail;

	spinlock_t buffer_lock; /* protects access to buffer, head and tail */

	struct fasync_struct *fasync;

	struct evdev *evdev;

	struct list_head node;

	int bufsize;

	struct input_event buffer[];

};

static struct evdev *evdev_table[EVDEV_MINORS];

	 */

	spin_lock(&client->buffer_lock);

	client->buffer[client->head++] = *event;

	client->head &= EVDEV_BUFFER_SIZE - 1;

	client->head &= client->bufsize - 1;

	spin_unlock(&client->buffer_lock);

	if (event->type == EV_SYN)

	return 0;

}

static unsigned int evdev_compute_buffer_size(struct input_dev *dev)

{

	return EVDEV_MIN_BUFFER_SIZE;

}

static int evdev_open(struct inode *inode, struct file *file)

{

	struct evdev *evdev;

	struct evdev_client *client;

	int i = iminor(inode) - EVDEV_MINOR_BASE;

	unsigned int bufsize;

	int error;

	if (i >= EVDEV_MINORS)

	if (!evdev)

		return -ENODEV;

	client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);

	bufsize = evdev_compute_buffer_size(evdev->handle.dev);

	client = kzalloc(sizeof(struct evdev_client) +

				bufsize * sizeof(struct input_event),

			 GFP_KERNEL);

	if (!client) {

		error = -ENOMEM;

		goto err_put_evdev;

	}

	client->bufsize = bufsize;

	spin_lock_init(&client->buffer_lock);

	client->evdev = evdev;

	evdev_attach_client(evdev, client);

	have_event = client->head != client->tail;

	if (have_event) {

		*event = client->buffer[client->tail++];

		client->tail &= EVDEV_BUFFER_SIZE - 1;

		client->tail &= client->bufsize - 1;

	}

	spin_unlock_irq(&client->buffer_lock);