URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [input/] [evdev.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * $Id: evdev.c,v 1.1.1.1 2004-04-15 02:18:54 phoenix Exp $
 *
 *  Copyright (c) 1999-2001 Vojtech Pavlik
 *
 *  Event char devices, giving access to raw input device events.
 *
 *  Sponsored by SuSE
 */
 
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
 * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
 */
 
#define EVDEV_MINOR_BASE        64
#define EVDEV_MINORS            32
#define EVDEV_BUFFER_SIZE       64
 
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/smp_lock.h>
 
struct evdev {
        int exist;
        int open;
        int minor;
        struct input_handle handle;
        wait_queue_head_t wait;
        devfs_handle_t devfs;
        struct evdev_list *list;
};
 
struct evdev_list {
        struct input_event buffer[EVDEV_BUFFER_SIZE];
        int head;
        int tail;
        struct fasync_struct *fasync;
        struct evdev *evdev;
        struct evdev_list *next;
};
 
static struct evdev *evdev_table[EVDEV_MINORS] = { NULL, /* ... */ };
 
static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
        struct evdev *evdev = handle->private;
        struct evdev_list *list = evdev->list;
 
        while (list) {
 
                do_gettimeofday(&list->buffer[list->head].time);
                list->buffer[list->head].type = type;
                list->buffer[list->head].code = code;
                list->buffer[list->head].value = value;
                list->head = (list->head + 1) & (EVDEV_BUFFER_SIZE - 1);
 
                kill_fasync(&list->fasync, SIGIO, POLL_IN);
 
                list = list->next;
        }
 
        wake_up_interruptible(&evdev->wait);
}
 
static int evdev_fasync(int fd, struct file *file, int on)
{
        int retval;
        struct evdev_list *list = file->private_data;
        retval = fasync_helper(fd, file, on, &list->fasync);
        return retval < 0 ? retval : 0;
}
 
static int evdev_release(struct inode * inode, struct file * file)
{
        struct evdev_list *list = file->private_data;
        struct evdev_list **listptr;
 
        lock_kernel();
        listptr = &list->evdev->list;
        evdev_fasync(-1, file, 0);
 
        while (*listptr && (*listptr != list))
                listptr = &((*listptr)->next);
        *listptr = (*listptr)->next;
 
        if (!--list->evdev->open) {
                if (list->evdev->exist) {
                        input_close_device(&list->evdev->handle);
                } else {
                        input_unregister_minor(list->evdev->devfs);
                        evdev_table[list->evdev->minor] = NULL;
                        kfree(list->evdev);
                }
        }
 
        kfree(list);
        unlock_kernel();
 
        return 0;
}
 
static int evdev_open(struct inode * inode, struct file * file)
{
        struct evdev_list *list;
        int i = MINOR(inode->i_rdev) - EVDEV_MINOR_BASE;
 
        if (i >= EVDEV_MINORS || !evdev_table[i])
                return -ENODEV;
 
        if (!(list = kmalloc(sizeof(struct evdev_list), GFP_KERNEL)))
                return -ENOMEM;
        memset(list, 0, sizeof(struct evdev_list));
 
        list->evdev = evdev_table[i];
        list->next = evdev_table[i]->list;
        evdev_table[i]->list = list;
 
        file->private_data = list;
 
        if (!list->evdev->open++)
                if (list->evdev->exist)
                        input_open_device(&list->evdev->handle);
 
        return 0;
}
 
static ssize_t evdev_write(struct file * file, const char * buffer, size_t count, loff_t *ppos)
{
        struct evdev_list *list = file->private_data;
        struct input_event event;
        int retval = 0;
 
        while (retval < count) {
 
                if (copy_from_user(&event, buffer + retval, sizeof(struct input_event)))
                        return -EFAULT;
                input_event(list->evdev->handle.dev, event.type, event.code, event.value);
                retval += sizeof(struct input_event);
        }
 
        return retval;
}
 
static ssize_t evdev_read(struct file * file, char * buffer, size_t count, loff_t *ppos)
{
        DECLARE_WAITQUEUE(wait, current);
        struct evdev_list *list = file->private_data;
        int retval = 0;
 
        if (list->head == list->tail) {
 
                add_wait_queue(&list->evdev->wait, &wait);
                current->state = TASK_INTERRUPTIBLE;
 
                while (list->head == list->tail) {
 
                        if (!list->evdev->exist) {
                                retval = -ENODEV;
                                break;
                        }
                        if (file->f_flags & O_NONBLOCK) {
                                retval = -EAGAIN;
                                break;
                        }
                        if (signal_pending(current)) {
                                retval = -ERESTARTSYS;
                                break;
                        }
 
                        schedule();
                }
 
                current->state = TASK_RUNNING;
                remove_wait_queue(&list->evdev->wait, &wait);
        }
 
        if (retval)
                return retval;
 
        while (list->head != list->tail && retval + sizeof(struct input_event) <= count) {
                if (copy_to_user(buffer + retval, list->buffer + list->tail,
                         sizeof(struct input_event))) return -EFAULT;
                list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);
                retval += sizeof(struct input_event);
        }
 
        return retval;
}
 
/* No kernel lock - fine */
static unsigned int evdev_poll(struct file *file, poll_table *wait)
{
        struct evdev_list *list = file->private_data;
        poll_wait(file, &list->evdev->wait, wait);
        if (list->head != list->tail)
                return POLLIN | POLLRDNORM;
        return 0;
}
 
static int evdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
        struct evdev_list *list = file->private_data;
        struct evdev *evdev = list->evdev;
        struct input_dev *dev = evdev->handle.dev;
        int retval;
 
        if (!evdev->exist)
                return -ENODEV;
 
        switch (cmd) {
 
                case EVIOCGVERSION:
                        return put_user(EV_VERSION, (int *) arg);
 
                case EVIOCGID:
                        if ((retval = put_user(dev->idbus,     ((short *) arg) + 0))) return retval;
                        if ((retval = put_user(dev->idvendor,  ((short *) arg) + 1))) return retval;
                        if ((retval = put_user(dev->idproduct, ((short *) arg) + 2))) return retval;
                        if ((retval = put_user(dev->idversion, ((short *) arg) + 3))) return retval;
                        return 0;
 
                case EVIOCSFF:
                        if (dev->upload_effect) {
                                struct ff_effect effect;
                                int err;
 
                                if (copy_from_user((void*)(&effect), (void*)arg, sizeof(effect))) {
                                        return -EINVAL;
                                }
                                err = dev->upload_effect(dev, &effect);
                                if (put_user(effect.id, &(((struct ff_effect*)arg)->id))) {
                                        return -EINVAL;
                                }
                                return err;
                        }
                        else return -ENOSYS;
 
                case EVIOCRMFF:
                        if (dev->erase_effect) {
                                return dev->erase_effect(dev, (int)arg);
                        }
                        else return -ENOSYS;
 
                case EVIOCGEFFECTS:
                        put_user(dev->ff_effects_max, (int*) arg);
                        return 0;
 
                default:
 
                        if (_IOC_TYPE(cmd) != 'E' || _IOC_DIR(cmd) != _IOC_READ)
                                return -EINVAL;
 
                        if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
 
                                long *bits;
                                int len;
 
                                switch (_IOC_NR(cmd) & EV_MAX) {
                                        case      0: bits = dev->evbit;  len = EV_MAX;  break;
                                        case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
                                        case EV_REL: bits = dev->relbit; len = REL_MAX; break;
                                        case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
                                        case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
                                        case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
                                        case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
                                        default: return -EINVAL;
                                }
                                len = NBITS(len) * sizeof(long);
                                if (len > _IOC_SIZE(cmd)) {
                                        printk(KERN_WARNING "evdev.c: Truncating bitfield length from %d to %d\n",
                                                len, _IOC_SIZE(cmd));
                                        len = _IOC_SIZE(cmd);
                                }
                                return copy_to_user((char *) arg, bits, len) ? -EFAULT : len;
                        }
 
                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
                                int len;
                                if (!dev->name) return 0;
                                len = strlen(dev->name) + 1;
                                if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
                                return copy_to_user((char *) arg, dev->name, len) ? -EFAULT : len;
                        }
 
                        if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 
                                int t = _IOC_NR(cmd) & ABS_MAX;
 
                                if ((retval = put_user(dev->abs[t],     ((int *) arg) + 0))) return retval;
                                if ((retval = put_user(dev->absmin[t],  ((int *) arg) + 1))) return retval;
                                if ((retval = put_user(dev->absmax[t],  ((int *) arg) + 2))) return retval;
                                if ((retval = put_user(dev->absfuzz[t], ((int *) arg) + 3))) return retval;
                                if ((retval = put_user(dev->absflat[t], ((int *) arg) + 4))) return retval;
 
                                return 0;
                        }
        }
        return -EINVAL;
}
 
static struct file_operations evdev_fops = {
        owner:          THIS_MODULE,
        read:           evdev_read,
        write:          evdev_write,
        poll:           evdev_poll,
        open:           evdev_open,
        release:        evdev_release,
        ioctl:          evdev_ioctl,
        fasync:         evdev_fasync,
};
 
static struct input_handle *evdev_connect(struct input_handler *handler, struct input_dev *dev)
{
        struct evdev *evdev;
        int minor;
 
        for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
        if (minor == EVDEV_MINORS) {
                printk(KERN_ERR "evdev: no more free evdev devices\n");
                return NULL;
        }
 
        if (!(evdev = kmalloc(sizeof(struct evdev), GFP_KERNEL)))
                return NULL;
        memset(evdev, 0, sizeof(struct evdev));
 
        init_waitqueue_head(&evdev->wait);
 
        evdev->minor = minor;
        evdev_table[minor] = evdev;
 
        evdev->handle.dev = dev;
        evdev->handle.handler = handler;
        evdev->handle.private = evdev;
 
        evdev->exist = 1;
 
        evdev->devfs = input_register_minor("event%d", minor, EVDEV_MINOR_BASE);
 
//      printk(KERN_INFO "event%d: Event device for input%d\n", minor, dev->number);
 
        return &evdev->handle;
}
 
static void evdev_disconnect(struct input_handle *handle)
{
        struct evdev *evdev = handle->private;
 
        evdev->exist = 0;
 
        if (evdev->open) {
                input_close_device(handle);
                wake_up_interruptible(&evdev->wait);
        } else {
                input_unregister_minor(evdev->devfs);
                evdev_table[evdev->minor] = NULL;
                kfree(evdev);
        }
}
 
static struct input_handler evdev_handler = {
        event:          evdev_event,
        connect:        evdev_connect,
        disconnect:     evdev_disconnect,
        fops:           &evdev_fops,
        minor:          EVDEV_MINOR_BASE,
};
 
static int __init evdev_init(void)
{
        input_register_handler(&evdev_handler);
        return 0;
}
 
static void __exit evdev_exit(void)
{
        input_unregister_handler(&evdev_handler);
}
 
module_init(evdev_init);
module_exit(evdev_exit);
 
MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
MODULE_DESCRIPTION("Event character device driver");
MODULE_LICENSE("GPL");
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [input/] [evdev.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* $Id: evdev.c,v 1.1.1.1 2004-04-15 02:18:54 phoenix Exp $`
3			`*`
4			`* Copyright (c) 1999-2001 Vojtech Pavlik`
5			`*`
6			`* Event char devices, giving access to raw input device events.`
7			`*`
8			`* Sponsored by SuSE`
9			`*/`
10
11			`/*`
12			`* This program is free software; you can redistribute it and/or modify`
13			`* it under the terms of the GNU General Public License as published by`
14			`* the Free Software Foundation; either version 2 of the License, or`
15			`* (at your option) any later version.`
16			`*`
17			`* This program is distributed in the hope that it will be useful,`
18			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
19			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
20			`* GNU General Public License for more details.`
21			`*`
22			`* You should have received a copy of the GNU General Public License`
23			`* along with this program; if not, write to the Free Software`
24			`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
25			`*`
26			`* Should you need to contact me, the author, you can do so either by`
27			`* e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:`
28			`* Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic`
29			`*/`
30
31			`#define EVDEV_MINOR_BASE 64`
32			`#define EVDEV_MINORS 32`
33			`#define EVDEV_BUFFER_SIZE 64`
34
35			`#include <linux/poll.h>`
36			`#include <linux/slab.h>`
37			`#include <linux/module.h>`
38			`#include <linux/init.h>`
39			`#include <linux/input.h>`
40			`#include <linux/smp_lock.h>`
41
42			`struct evdev {`
43			`int exist;`
44			`int open;`
45			`int minor;`
46			`struct input_handle handle;`
47			`wait_queue_head_t wait;`
48			`devfs_handle_t devfs;`
49			`struct evdev_list *list;`
50			`};`
51
52			`struct evdev_list {`
53			`struct input_event buffer[EVDEV_BUFFER_SIZE];`
54			`int head;`
55			`int tail;`
56			`struct fasync_struct *fasync;`
57			`struct evdev *evdev;`
58			`struct evdev_list *next;`
59			`};`
60
61			`static struct evdev evdev_table[EVDEV_MINORS] = { NULL, / ... */ };`
62
63			`static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)`
64			`{`
65			`struct evdev *evdev = handle->private;`
66			`struct evdev_list *list = evdev->list;`
67
68			`while (list) {`
69
70			`do_gettimeofday(&list->buffer[list->head].time);`
71			`list->buffer[list->head].type = type;`
72			`list->buffer[list->head].code = code;`
73			`list->buffer[list->head].value = value;`
74			`list->head = (list->head + 1) & (EVDEV_BUFFER_SIZE - 1);`
75
76			`kill_fasync(&list->fasync, SIGIO, POLL_IN);`
77
78			`list = list->next;`
79			`}`
80
81			`wake_up_interruptible(&evdev->wait);`
82			`}`
83
84			`static int evdev_fasync(int fd, struct file *file, int on)`
85			`{`
86			`int retval;`
87			`struct evdev_list *list = file->private_data;`
88			`retval = fasync_helper(fd, file, on, &list->fasync);`
89			`return retval < 0 ? retval : 0;`
90			`}`
91
92			`static int evdev_release(struct inode * inode, struct file * file)`
93			`{`
94			`struct evdev_list *list = file->private_data;`
95			`struct evdev_list **listptr;`
96
97			`lock_kernel();`
98			`listptr = &list->evdev->list;`
99			`evdev_fasync(-1, file, 0);`
100
101			`while (listptr && (listptr != list))`
102			`listptr = &((*listptr)->next);`
103			`listptr = (listptr)->next;`
104
105			`if (!--list->evdev->open) {`
106			`if (list->evdev->exist) {`
107			`input_close_device(&list->evdev->handle);`
108			`} else {`
109			`input_unregister_minor(list->evdev->devfs);`
110			`evdev_table[list->evdev->minor] = NULL;`
111			`kfree(list->evdev);`
112			`}`
113			`}`
114
115			`kfree(list);`
116			`unlock_kernel();`
117
118			`return 0;`
119			`}`
120
121			`static int evdev_open(struct inode * inode, struct file * file)`
122			`{`
123			`struct evdev_list *list;`
124			`int i = MINOR(inode->i_rdev) - EVDEV_MINOR_BASE;`
125
126			`if (i >= EVDEV_MINORS \|\| !evdev_table[i])`
127			`return -ENODEV;`
128
129			`if (!(list = kmalloc(sizeof(struct evdev_list), GFP_KERNEL)))`
130			`return -ENOMEM;`
131			`memset(list, 0, sizeof(struct evdev_list));`
132
133			`list->evdev = evdev_table[i];`
134			`list->next = evdev_table[i]->list;`
135			`evdev_table[i]->list = list;`
136
137			`file->private_data = list;`
138
139			`if (!list->evdev->open++)`
140			`if (list->evdev->exist)`
141			`input_open_device(&list->evdev->handle);`
142
143			`return 0;`
144			`}`
145
146			`static ssize_t evdev_write(struct file * file, const char * buffer, size_t count, loff_t *ppos)`
147			`{`
148			`struct evdev_list *list = file->private_data;`
149			`struct input_event event;`
150			`int retval = 0;`
151
152			`while (retval < count) {`
153
154			`if (copy_from_user(&event, buffer + retval, sizeof(struct input_event)))`
155			`return -EFAULT;`
156			`input_event(list->evdev->handle.dev, event.type, event.code, event.value);`
157			`retval += sizeof(struct input_event);`
158			`}`
159
160			`return retval;`
161			`}`
162
163			`static ssize_t evdev_read(struct file * file, char * buffer, size_t count, loff_t *ppos)`
164			`{`
165			`DECLARE_WAITQUEUE(wait, current);`
166			`struct evdev_list *list = file->private_data;`
167			`int retval = 0;`
168
169			`if (list->head == list->tail) {`
170
171			`add_wait_queue(&list->evdev->wait, &wait);`
172			`current->state = TASK_INTERRUPTIBLE;`
173
174			`while (list->head == list->tail) {`
175
176			`if (!list->evdev->exist) {`
177			`retval = -ENODEV;`
178			`break;`
179			`}`
180			`if (file->f_flags & O_NONBLOCK) {`
181			`retval = -EAGAIN;`
182			`break;`
183			`}`
184			`if (signal_pending(current)) {`
185			`retval = -ERESTARTSYS;`
186			`break;`
187			`}`
188
189			`schedule();`
190			`}`
191
192			`current->state = TASK_RUNNING;`
193			`remove_wait_queue(&list->evdev->wait, &wait);`
194			`}`
195
196			`if (retval)`
197			`return retval;`
198
199			`while (list->head != list->tail && retval + sizeof(struct input_event) <= count) {`
200			`if (copy_to_user(buffer + retval, list->buffer + list->tail,`
201			`sizeof(struct input_event))) return -EFAULT;`
202			`list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);`
203			`retval += sizeof(struct input_event);`
204			`}`
205
206			`return retval;`
207			`}`
208
209			`/* No kernel lock - fine */`
210			`static unsigned int evdev_poll(struct file file, poll_table wait)`
211			`{`
212			`struct evdev_list *list = file->private_data;`
213			`poll_wait(file, &list->evdev->wait, wait);`
214			`if (list->head != list->tail)`
215			`return POLLIN \| POLLRDNORM;`
216			`return 0;`
217			`}`
218
219			`static int evdev_ioctl(struct inode inode, struct file file, unsigned int cmd, unsigned long arg)`
220			`{`
221			`struct evdev_list *list = file->private_data;`
222			`struct evdev *evdev = list->evdev;`
223			`struct input_dev *dev = evdev->handle.dev;`
224			`int retval;`
225
226			`if (!evdev->exist)`
227			`return -ENODEV;`
228
229			`switch (cmd) {`
230
231			`case EVIOCGVERSION:`
232			`return put_user(EV_VERSION, (int *) arg);`
233
234			`case EVIOCGID:`
235			`if ((retval = put_user(dev->idbus, ((short *) arg) + 0))) return retval;`
236			`if ((retval = put_user(dev->idvendor, ((short *) arg) + 1))) return retval;`
237			`if ((retval = put_user(dev->idproduct, ((short *) arg) + 2))) return retval;`
238			`if ((retval = put_user(dev->idversion, ((short *) arg) + 3))) return retval;`
239			`return 0;`
240
241			`case EVIOCSFF:`
242			`if (dev->upload_effect) {`
243			`struct ff_effect effect;`
244			`int err;`
245
246			`if (copy_from_user((void)(&effect), (void)arg, sizeof(effect))) {`
247			`return -EINVAL;`
248			`}`
249			`err = dev->upload_effect(dev, &effect);`
250			`if (put_user(effect.id, &(((struct ff_effect*)arg)->id))) {`
251			`return -EINVAL;`
252			`}`
253			`return err;`
254			`}`
255			`else return -ENOSYS;`
256
257			`case EVIOCRMFF:`
258			`if (dev->erase_effect) {`
259			`return dev->erase_effect(dev, (int)arg);`
260			`}`
261			`else return -ENOSYS;`
262
263			`case EVIOCGEFFECTS:`
264			`put_user(dev->ff_effects_max, (int*) arg);`
265			`return 0;`
266
267			`default:`
268
269			`if (_IOC_TYPE(cmd) != 'E' \|\| _IOC_DIR(cmd) != _IOC_READ)`
270			`return -EINVAL;`
271
272			`if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {`
273
274			`long *bits;`
275			`int len;`
276
277			`switch (_IOC_NR(cmd) & EV_MAX) {`
278			`case 0: bits = dev->evbit; len = EV_MAX; break;`
279			`case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;`
280			`case EV_REL: bits = dev->relbit; len = REL_MAX; break;`
281			`case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;`
282			`case EV_LED: bits = dev->ledbit; len = LED_MAX; break;`
283			`case EV_SND: bits = dev->sndbit; len = SND_MAX; break;`
284			`case EV_FF: bits = dev->ffbit; len = FF_MAX; break;`
285			`default: return -EINVAL;`
286			`}`
287			`len = NBITS(len) * sizeof(long);`
288			`if (len > _IOC_SIZE(cmd)) {`
289			`printk(KERN_WARNING "evdev.c: Truncating bitfield length from %d to %d\n",`
290			`len, _IOC_SIZE(cmd));`
291			`len = _IOC_SIZE(cmd);`
292			`}`
293			`return copy_to_user((char *) arg, bits, len) ? -EFAULT : len;`
294			`}`
295
296			`if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {`
297			`int len;`
298			`if (!dev->name) return 0;`
299			`len = strlen(dev->name) + 1;`
300			`if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);`
301			`return copy_to_user((char *) arg, dev->name, len) ? -EFAULT : len;`
302			`}`
303
304			`if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {`
305
306			`int t = _IOC_NR(cmd) & ABS_MAX;`
307
308			`if ((retval = put_user(dev->abs[t], ((int *) arg) + 0))) return retval;`
309			`if ((retval = put_user(dev->absmin[t], ((int *) arg) + 1))) return retval;`
310			`if ((retval = put_user(dev->absmax[t], ((int *) arg) + 2))) return retval;`
311			`if ((retval = put_user(dev->absfuzz[t], ((int *) arg) + 3))) return retval;`
312			`if ((retval = put_user(dev->absflat[t], ((int *) arg) + 4))) return retval;`
313
314			`return 0;`
315			`}`
316			`}`
317			`return -EINVAL;`
318			`}`
319
320			`static struct file_operations evdev_fops = {`
321			`owner: THIS_MODULE,`
322			`read: evdev_read,`
323			`write: evdev_write,`
324			`poll: evdev_poll,`
325			`open: evdev_open,`
326			`release: evdev_release,`
327			`ioctl: evdev_ioctl,`
328			`fasync: evdev_fasync,`
329			`};`
330
331			`static struct input_handle evdev_connect(struct input_handler handler, struct input_dev *dev)`
332			`{`
333			`struct evdev *evdev;`
334			`int minor;`
335
336			`for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);`
337			`if (minor == EVDEV_MINORS) {`
338			`printk(KERN_ERR "evdev: no more free evdev devices\n");`
339			`return NULL;`
340			`}`
341
342			`if (!(evdev = kmalloc(sizeof(struct evdev), GFP_KERNEL)))`
343			`return NULL;`
344			`memset(evdev, 0, sizeof(struct evdev));`
345
346			`init_waitqueue_head(&evdev->wait);`
347
348			`evdev->minor = minor;`
349			`evdev_table[minor] = evdev;`
350
351			`evdev->handle.dev = dev;`
352			`evdev->handle.handler = handler;`
353			`evdev->handle.private = evdev;`
354
355			`evdev->exist = 1;`
356
357			`evdev->devfs = input_register_minor("event%d", minor, EVDEV_MINOR_BASE);`
358
359			`// printk(KERN_INFO "event%d: Event device for input%d\n", minor, dev->number);`
360
361			`return &evdev->handle;`
362			`}`
363
364			`static void evdev_disconnect(struct input_handle *handle)`
365			`{`
366			`struct evdev *evdev = handle->private;`
367
368			`evdev->exist = 0;`
369
370			`if (evdev->open) {`
371			`input_close_device(handle);`
372			`wake_up_interruptible(&evdev->wait);`
373			`} else {`
374			`input_unregister_minor(evdev->devfs);`
375			`evdev_table[evdev->minor] = NULL;`
376			`kfree(evdev);`
377			`}`
378			`}`
379
380			`static struct input_handler evdev_handler = {`
381			`event: evdev_event,`
382			`connect: evdev_connect,`
383			`disconnect: evdev_disconnect,`
384			`fops: &evdev_fops,`
385			`minor: EVDEV_MINOR_BASE,`
386			`};`
387
388			`static int __init evdev_init(void)`
389			`{`
390			`input_register_handler(&evdev_handler);`
391			`return 0;`
392			`}`
393
394			`static void __exit evdev_exit(void)`
395			`{`
396			`input_unregister_handler(&evdev_handler);`
397			`}`
398
399			`module_init(evdev_init);`
400			`module_exit(evdev_exit);`
401
402			`MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");`
403			`MODULE_DESCRIPTION("Event character device driver");`
404			`MODULE_LICENSE("GPL");`
405