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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [serio/] [serio_raw.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * Raw serio device providing access to a raw byte stream from underlying
 * serio port. Closely emulates behavior of pre-2.6 /dev/psaux device
 *
 * Copyright (c) 2004 Dmitry Torokhov
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
 
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/module.h>
#include <linux/serio.h>
#include <linux/init.h>
#include <linux/major.h>
#include <linux/device.h>
#include <linux/miscdevice.h>
#include <linux/wait.h>
#include <linux/mutex.h>
 
#define DRIVER_DESC     "Raw serio driver"
 
MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
 
#define SERIO_RAW_QUEUE_LEN     64
struct serio_raw {
        unsigned char queue[SERIO_RAW_QUEUE_LEN];
        unsigned int tail, head;
 
        char name[16];
        unsigned int refcnt;
        struct serio *serio;
        struct miscdevice dev;
        wait_queue_head_t wait;
        struct list_head list;
        struct list_head node;
};
 
struct serio_raw_list {
        struct fasync_struct *fasync;
        struct serio_raw *serio_raw;
        struct list_head node;
};
 
static DEFINE_MUTEX(serio_raw_mutex);
static LIST_HEAD(serio_raw_list);
static unsigned int serio_raw_no;
 
/*********************************************************************
 *             Interface with userspace (file operations)            *
 *********************************************************************/
 
static int serio_raw_fasync(int fd, struct file *file, int on)
{
        struct serio_raw_list *list = file->private_data;
        int retval;
 
        retval = fasync_helper(fd, file, on, &list->fasync);
        return retval < 0 ? retval : 0;
}
 
static struct serio_raw *serio_raw_locate(int minor)
{
        struct serio_raw *serio_raw;
 
        list_for_each_entry(serio_raw, &serio_raw_list, node) {
                if (serio_raw->dev.minor == minor)
                        return serio_raw;
        }
 
        return NULL;
}
 
static int serio_raw_open(struct inode *inode, struct file *file)
{
        struct serio_raw *serio_raw;
        struct serio_raw_list *list;
        int retval = 0;
 
        retval = mutex_lock_interruptible(&serio_raw_mutex);
        if (retval)
                return retval;
 
        if (!(serio_raw = serio_raw_locate(iminor(inode)))) {
                retval = -ENODEV;
                goto out;
        }
 
        if (!serio_raw->serio) {
                retval = -ENODEV;
                goto out;
        }
 
        if (!(list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {
                retval = -ENOMEM;
                goto out;
        }
 
        list->serio_raw = serio_raw;
        file->private_data = list;
 
        serio_raw->refcnt++;
        list_add_tail(&list->node, &serio_raw->list);
 
out:
        mutex_unlock(&serio_raw_mutex);
        return retval;
}
 
static int serio_raw_cleanup(struct serio_raw *serio_raw)
{
        if (--serio_raw->refcnt == 0) {
                misc_deregister(&serio_raw->dev);
                list_del_init(&serio_raw->node);
                kfree(serio_raw);
 
                return 1;
        }
 
        return 0;
}
 
static int serio_raw_release(struct inode *inode, struct file *file)
{
        struct serio_raw_list *list = file->private_data;
        struct serio_raw *serio_raw = list->serio_raw;
 
        mutex_lock(&serio_raw_mutex);
 
        serio_raw_fasync(-1, file, 0);
        serio_raw_cleanup(serio_raw);
 
        mutex_unlock(&serio_raw_mutex);
        return 0;
}
 
static int serio_raw_fetch_byte(struct serio_raw *serio_raw, char *c)
{
        unsigned long flags;
        int empty;
 
        spin_lock_irqsave(&serio_raw->serio->lock, flags);
 
        empty = serio_raw->head == serio_raw->tail;
        if (!empty) {
                *c = serio_raw->queue[serio_raw->tail];
                serio_raw->tail = (serio_raw->tail + 1) % SERIO_RAW_QUEUE_LEN;
        }
 
        spin_unlock_irqrestore(&serio_raw->serio->lock, flags);
 
        return !empty;
}
 
static ssize_t serio_raw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
        struct serio_raw_list *list = file->private_data;
        struct serio_raw *serio_raw = list->serio_raw;
        char uninitialized_var(c);
        ssize_t retval = 0;
 
        if (!serio_raw->serio)
                return -ENODEV;
 
        if (serio_raw->head == serio_raw->tail && (file->f_flags & O_NONBLOCK))
                return -EAGAIN;
 
        retval = wait_event_interruptible(list->serio_raw->wait,
                                          serio_raw->head != serio_raw->tail || !serio_raw->serio);
        if (retval)
                return retval;
 
        if (!serio_raw->serio)
                return -ENODEV;
 
        while (retval < count && serio_raw_fetch_byte(serio_raw, &c)) {
                if (put_user(c, buffer++))
                        return -EFAULT;
                retval++;
        }
 
        return retval;
}
 
static ssize_t serio_raw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
        struct serio_raw_list *list = file->private_data;
        ssize_t written = 0;
        int retval;
        unsigned char c;
 
        retval = mutex_lock_interruptible(&serio_raw_mutex);
        if (retval)
                return retval;
 
        if (!list->serio_raw->serio) {
                retval = -ENODEV;
                goto out;
        }
 
        if (count > 32)
                count = 32;
 
        while (count--) {
                if (get_user(c, buffer++)) {
                        retval = -EFAULT;
                        goto out;
                }
                if (serio_write(list->serio_raw->serio, c)) {
                        retval = -EIO;
                        goto out;
                }
                written++;
        };
 
out:
        mutex_unlock(&serio_raw_mutex);
        return written;
}
 
static unsigned int serio_raw_poll(struct file *file, poll_table *wait)
{
        struct serio_raw_list *list = file->private_data;
 
        poll_wait(file, &list->serio_raw->wait, wait);
 
        if (list->serio_raw->head != list->serio_raw->tail)
                return POLLIN | POLLRDNORM;
 
        return 0;
}
 
static const struct file_operations serio_raw_fops = {
        .owner =        THIS_MODULE,
        .open =         serio_raw_open,
        .release =      serio_raw_release,
        .read =         serio_raw_read,
        .write =        serio_raw_write,
        .poll =         serio_raw_poll,
        .fasync =       serio_raw_fasync,
};
 
 
/*********************************************************************
 *                   Interface with serio port                       *
 *********************************************************************/
 
static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data,
                                        unsigned int dfl)
{
        struct serio_raw *serio_raw = serio_get_drvdata(serio);
        struct serio_raw_list *list;
        unsigned int head = serio_raw->head;
 
        /* we are holding serio->lock here so we are prootected */
        serio_raw->queue[head] = data;
        head = (head + 1) % SERIO_RAW_QUEUE_LEN;
        if (likely(head != serio_raw->tail)) {
                serio_raw->head = head;
                list_for_each_entry(list, &serio_raw->list, node)
                        kill_fasync(&list->fasync, SIGIO, POLL_IN);
                wake_up_interruptible(&serio_raw->wait);
        }
 
        return IRQ_HANDLED;
}
 
static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
{
        struct serio_raw *serio_raw;
        int err;
 
        if (!(serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL))) {
                printk(KERN_ERR "serio_raw.c: can't allocate memory for a device\n");
                return -ENOMEM;
        }
 
        mutex_lock(&serio_raw_mutex);
 
        snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);
        serio_raw->refcnt = 1;
        serio_raw->serio = serio;
        INIT_LIST_HEAD(&serio_raw->list);
        init_waitqueue_head(&serio_raw->wait);
 
        serio_set_drvdata(serio, serio_raw);
 
        err = serio_open(serio, drv);
        if (err)
                goto out_free;
 
        list_add_tail(&serio_raw->node, &serio_raw_list);
 
        serio_raw->dev.minor = PSMOUSE_MINOR;
        serio_raw->dev.name = serio_raw->name;
        serio_raw->dev.parent = &serio->dev;
        serio_raw->dev.fops = &serio_raw_fops;
 
        err = misc_register(&serio_raw->dev);
        if (err) {
                serio_raw->dev.minor = MISC_DYNAMIC_MINOR;
                err = misc_register(&serio_raw->dev);
        }
 
        if (err) {
                printk(KERN_INFO "serio_raw: failed to register raw access device for %s\n",
                        serio->phys);
                goto out_close;
        }
 
        printk(KERN_INFO "serio_raw: raw access enabled on %s (%s, minor %d)\n",
                serio->phys, serio_raw->name, serio_raw->dev.minor);
        goto out;
 
out_close:
        serio_close(serio);
        list_del_init(&serio_raw->node);
out_free:
        serio_set_drvdata(serio, NULL);
        kfree(serio_raw);
out:
        mutex_unlock(&serio_raw_mutex);
        return err;
}
 
static int serio_raw_reconnect(struct serio *serio)
{
        struct serio_raw *serio_raw = serio_get_drvdata(serio);
        struct serio_driver *drv = serio->drv;
 
        if (!drv || !serio_raw) {
                printk(KERN_DEBUG "serio_raw: reconnect request, but serio is disconnected, ignoring...\n");
                return -1;
        }
 
        /*
         * Nothing needs to be done here, we just need this method to
         * keep the same device.
         */
        return 0;
}
 
static void serio_raw_disconnect(struct serio *serio)
{
        struct serio_raw *serio_raw;
 
        mutex_lock(&serio_raw_mutex);
 
        serio_raw = serio_get_drvdata(serio);
 
        serio_close(serio);
        serio_set_drvdata(serio, NULL);
 
        serio_raw->serio = NULL;
        if (!serio_raw_cleanup(serio_raw))
                wake_up_interruptible(&serio_raw->wait);
 
        mutex_unlock(&serio_raw_mutex);
}
 
static struct serio_device_id serio_raw_serio_ids[] = {
        {
                .type   = SERIO_8042,
                .proto  = SERIO_ANY,
                .id     = SERIO_ANY,
                .extra  = SERIO_ANY,
        },
        { 0 }
};
 
MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids);
 
static struct serio_driver serio_raw_drv = {
        .driver         = {
                .name   = "serio_raw",
        },
        .description    = DRIVER_DESC,
        .id_table       = serio_raw_serio_ids,
        .interrupt      = serio_raw_interrupt,
        .connect        = serio_raw_connect,
        .reconnect      = serio_raw_reconnect,
        .disconnect     = serio_raw_disconnect,
        .manual_bind    = 1,
};
 
static int __init serio_raw_init(void)
{
        return serio_register_driver(&serio_raw_drv);
}
 
static void __exit serio_raw_exit(void)
{
        serio_unregister_driver(&serio_raw_drv);
}
 
module_init(serio_raw_init);
module_exit(serio_raw_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [serio/] [serio_raw.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Raw serio device providing access to a raw byte stream from underlying`
3			`* serio port. Closely emulates behavior of pre-2.6 /dev/psaux device`
4			`*`
5			`* Copyright (c) 2004 Dmitry Torokhov`
6			`*`
7			`* This program is free software; you can redistribute it and/or modify it`
8			`* under the terms of the GNU General Public License version 2 as published by`
9			`* the Free Software Foundation.`
10			`*/`
11
12			`#include <linux/slab.h>`
13			`#include <linux/poll.h>`
14			`#include <linux/module.h>`
15			`#include <linux/serio.h>`
16			`#include <linux/init.h>`
17			`#include <linux/major.h>`
18			`#include <linux/device.h>`
19			`#include <linux/miscdevice.h>`
20			`#include <linux/wait.h>`
21			`#include <linux/mutex.h>`
22
23			`#define DRIVER_DESC "Raw serio driver"`
24
25			`MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");`
26			`MODULE_DESCRIPTION(DRIVER_DESC);`
27			`MODULE_LICENSE("GPL");`
28
29			`#define SERIO_RAW_QUEUE_LEN 64`
30			`struct serio_raw {`
31			`unsigned char queue[SERIO_RAW_QUEUE_LEN];`
32			`unsigned int tail, head;`
33
34			`char name[16];`
35			`unsigned int refcnt;`
36			`struct serio *serio;`
37			`struct miscdevice dev;`
38			`wait_queue_head_t wait;`
39			`struct list_head list;`
40			`struct list_head node;`
41			`};`
42
43			`struct serio_raw_list {`
44			`struct fasync_struct *fasync;`
45			`struct serio_raw *serio_raw;`
46			`struct list_head node;`
47			`};`
48
49			`static DEFINE_MUTEX(serio_raw_mutex);`
50			`static LIST_HEAD(serio_raw_list);`
51			`static unsigned int serio_raw_no;`
52
53			`/*********************************************************************`
54			`* Interface with userspace (file operations) *`
55			`*********************************************************************/`
56
57			`static int serio_raw_fasync(int fd, struct file *file, int on)`
58			`{`
59			`struct serio_raw_list *list = file->private_data;`
60			`int retval;`
61
62			`retval = fasync_helper(fd, file, on, &list->fasync);`
63			`return retval < 0 ? retval : 0;`
64			`}`
65
66			`static struct serio_raw *serio_raw_locate(int minor)`
67			`{`
68			`struct serio_raw *serio_raw;`
69
70			`list_for_each_entry(serio_raw, &serio_raw_list, node) {`
71			`if (serio_raw->dev.minor == minor)`
72			`return serio_raw;`
73			`}`
74
75			`return NULL;`
76			`}`
77
78			`static int serio_raw_open(struct inode inode, struct file file)`
79			`{`
80			`struct serio_raw *serio_raw;`
81			`struct serio_raw_list *list;`
82			`int retval = 0;`
83
84			`retval = mutex_lock_interruptible(&serio_raw_mutex);`
85			`if (retval)`
86			`return retval;`
87
88			`if (!(serio_raw = serio_raw_locate(iminor(inode)))) {`
89			`retval = -ENODEV;`
90			`goto out;`
91			`}`
92
93			`if (!serio_raw->serio) {`
94			`retval = -ENODEV;`
95			`goto out;`
96			`}`
97
98			`if (!(list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {`
99			`retval = -ENOMEM;`
100			`goto out;`
101			`}`
102
103			`list->serio_raw = serio_raw;`
104			`file->private_data = list;`
105
106			`serio_raw->refcnt++;`
107			`list_add_tail(&list->node, &serio_raw->list);`
108
109			`out:`
110			`mutex_unlock(&serio_raw_mutex);`
111			`return retval;`
112			`}`
113
114			`static int serio_raw_cleanup(struct serio_raw *serio_raw)`
115			`{`
116			`if (--serio_raw->refcnt == 0) {`
117			`misc_deregister(&serio_raw->dev);`
118			`list_del_init(&serio_raw->node);`
119			`kfree(serio_raw);`
120
121			`return 1;`
122			`}`
123
124			`return 0;`
125			`}`
126
127			`static int serio_raw_release(struct inode inode, struct file file)`
128			`{`
129			`struct serio_raw_list *list = file->private_data;`
130			`struct serio_raw *serio_raw = list->serio_raw;`
131
132			`mutex_lock(&serio_raw_mutex);`
133
134			`serio_raw_fasync(-1, file, 0);`
135			`serio_raw_cleanup(serio_raw);`
136
137			`mutex_unlock(&serio_raw_mutex);`
138			`return 0;`
139			`}`
140
141			`static int serio_raw_fetch_byte(struct serio_raw serio_raw, char c)`
142			`{`
143			`unsigned long flags;`
144			`int empty;`
145
146			`spin_lock_irqsave(&serio_raw->serio->lock, flags);`
147
148			`empty = serio_raw->head == serio_raw->tail;`
149			`if (!empty) {`
150			`*c = serio_raw->queue[serio_raw->tail];`
151			`serio_raw->tail = (serio_raw->tail + 1) % SERIO_RAW_QUEUE_LEN;`
152			`}`
153
154			`spin_unlock_irqrestore(&serio_raw->serio->lock, flags);`
155
156			`return !empty;`
157			`}`
158
159			`static ssize_t serio_raw_read(struct file file, char __user buffer, size_t count, loff_t *ppos)`
160			`{`
161			`struct serio_raw_list *list = file->private_data;`
162			`struct serio_raw *serio_raw = list->serio_raw;`
163			`char uninitialized_var(c);`
164			`ssize_t retval = 0;`
165
166			`if (!serio_raw->serio)`
167			`return -ENODEV;`
168
169			`if (serio_raw->head == serio_raw->tail && (file->f_flags & O_NONBLOCK))`
170			`return -EAGAIN;`
171
172			`retval = wait_event_interruptible(list->serio_raw->wait,`
173			`serio_raw->head != serio_raw->tail \|\| !serio_raw->serio);`
174			`if (retval)`
175			`return retval;`
176
177			`if (!serio_raw->serio)`
178			`return -ENODEV;`
179
180			`while (retval < count && serio_raw_fetch_byte(serio_raw, &c)) {`
181			`if (put_user(c, buffer++))`
182			`return -EFAULT;`
183			`retval++;`
184			`}`
185
186			`return retval;`
187			`}`
188
189			`static ssize_t serio_raw_write(struct file file, const char __user buffer, size_t count, loff_t *ppos)`
190			`{`
191			`struct serio_raw_list *list = file->private_data;`
192			`ssize_t written = 0;`
193			`int retval;`
194			`unsigned char c;`
195
196			`retval = mutex_lock_interruptible(&serio_raw_mutex);`
197			`if (retval)`
198			`return retval;`
199
200			`if (!list->serio_raw->serio) {`
201			`retval = -ENODEV;`
202			`goto out;`
203			`}`
204
205			`if (count > 32)`
206			`count = 32;`
207
208			`while (count--) {`
209			`if (get_user(c, buffer++)) {`
210			`retval = -EFAULT;`
211			`goto out;`
212			`}`
213			`if (serio_write(list->serio_raw->serio, c)) {`
214			`retval = -EIO;`
215			`goto out;`
216			`}`
217			`written++;`
218			`};`
219
220			`out:`
221			`mutex_unlock(&serio_raw_mutex);`
222			`return written;`
223			`}`
224
225			`static unsigned int serio_raw_poll(struct file file, poll_table wait)`
226			`{`
227			`struct serio_raw_list *list = file->private_data;`
228
229			`poll_wait(file, &list->serio_raw->wait, wait);`
230
231			`if (list->serio_raw->head != list->serio_raw->tail)`
232			`return POLLIN \| POLLRDNORM;`
233
234			`return 0;`
235			`}`
236
237			`static const struct file_operations serio_raw_fops = {`
238			`.owner = THIS_MODULE,`
239			`.open = serio_raw_open,`
240			`.release = serio_raw_release,`
241			`.read = serio_raw_read,`
242			`.write = serio_raw_write,`
243			`.poll = serio_raw_poll,`
244			`.fasync = serio_raw_fasync,`
245			`};`
246
247
248			`/*********************************************************************`
249			`* Interface with serio port *`
250			`*********************************************************************/`
251
252			`static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data,`
253			`unsigned int dfl)`
254			`{`
255			`struct serio_raw *serio_raw = serio_get_drvdata(serio);`
256			`struct serio_raw_list *list;`
257			`unsigned int head = serio_raw->head;`
258
259			`/* we are holding serio->lock here so we are prootected */`
260			`serio_raw->queue[head] = data;`
261			`head = (head + 1) % SERIO_RAW_QUEUE_LEN;`
262			`if (likely(head != serio_raw->tail)) {`
263			`serio_raw->head = head;`
264			`list_for_each_entry(list, &serio_raw->list, node)`
265			`kill_fasync(&list->fasync, SIGIO, POLL_IN);`
266			`wake_up_interruptible(&serio_raw->wait);`
267			`}`
268
269			`return IRQ_HANDLED;`
270			`}`
271
272			`static int serio_raw_connect(struct serio serio, struct serio_driver drv)`
273			`{`
274			`struct serio_raw *serio_raw;`
275			`int err;`
276
277			`if (!(serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL))) {`
278			`printk(KERN_ERR "serio_raw.c: can't allocate memory for a device\n");`
279			`return -ENOMEM;`
280			`}`
281
282			`mutex_lock(&serio_raw_mutex);`
283
284			`snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);`
285			`serio_raw->refcnt = 1;`
286			`serio_raw->serio = serio;`
287			`INIT_LIST_HEAD(&serio_raw->list);`
288			`init_waitqueue_head(&serio_raw->wait);`
289
290			`serio_set_drvdata(serio, serio_raw);`
291
292			`err = serio_open(serio, drv);`
293			`if (err)`
294			`goto out_free;`
295
296			`list_add_tail(&serio_raw->node, &serio_raw_list);`
297
298			`serio_raw->dev.minor = PSMOUSE_MINOR;`
299			`serio_raw->dev.name = serio_raw->name;`
300			`serio_raw->dev.parent = &serio->dev;`
301			`serio_raw->dev.fops = &serio_raw_fops;`
302
303			`err = misc_register(&serio_raw->dev);`
304			`if (err) {`
305			`serio_raw->dev.minor = MISC_DYNAMIC_MINOR;`
306			`err = misc_register(&serio_raw->dev);`
307			`}`
308
309			`if (err) {`
310			`printk(KERN_INFO "serio_raw: failed to register raw access device for %s\n",`
311			`serio->phys);`
312			`goto out_close;`
313			`}`
314
315			`printk(KERN_INFO "serio_raw: raw access enabled on %s (%s, minor %d)\n",`
316			`serio->phys, serio_raw->name, serio_raw->dev.minor);`
317			`goto out;`
318
319			`out_close:`
320			`serio_close(serio);`
321			`list_del_init(&serio_raw->node);`
322			`out_free:`
323			`serio_set_drvdata(serio, NULL);`
324			`kfree(serio_raw);`
325			`out:`
326			`mutex_unlock(&serio_raw_mutex);`
327			`return err;`
328			`}`
329
330			`static int serio_raw_reconnect(struct serio *serio)`
331			`{`
332			`struct serio_raw *serio_raw = serio_get_drvdata(serio);`
333			`struct serio_driver *drv = serio->drv;`
334
335			`if (!drv \|\| !serio_raw) {`
336			`printk(KERN_DEBUG "serio_raw: reconnect request, but serio is disconnected, ignoring...\n");`
337			`return -1;`
338			`}`
339
340			`/*`
341			`* Nothing needs to be done here, we just need this method to`
342			`* keep the same device.`
343			`*/`
344			`return 0;`
345			`}`
346
347			`static void serio_raw_disconnect(struct serio *serio)`
348			`{`
349			`struct serio_raw *serio_raw;`
350
351			`mutex_lock(&serio_raw_mutex);`
352
353			`serio_raw = serio_get_drvdata(serio);`
354
355			`serio_close(serio);`
356			`serio_set_drvdata(serio, NULL);`
357
358			`serio_raw->serio = NULL;`
359			`if (!serio_raw_cleanup(serio_raw))`
360			`wake_up_interruptible(&serio_raw->wait);`
361
362			`mutex_unlock(&serio_raw_mutex);`
363			`}`
364
365			`static struct serio_device_id serio_raw_serio_ids[] = {`
366			`{`
367			`.type = SERIO_8042,`
368			`.proto = SERIO_ANY,`
369			`.id = SERIO_ANY,`
370			`.extra = SERIO_ANY,`
371			`},`
372			`{ 0 }`
373			`};`
374
375			`MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids);`
376
377			`static struct serio_driver serio_raw_drv = {`
378			`.driver = {`
379			`.name = "serio_raw",`
380			`},`
381			`.description = DRIVER_DESC,`
382			`.id_table = serio_raw_serio_ids,`
383			`.interrupt = serio_raw_interrupt,`
384			`.connect = serio_raw_connect,`
385			`.reconnect = serio_raw_reconnect,`
386			`.disconnect = serio_raw_disconnect,`
387			`.manual_bind = 1,`
388			`};`
389
390			`static int __init serio_raw_init(void)`
391			`{`
392			`return serio_register_driver(&serio_raw_drv);`
393			`}`
394
395			`static void __exit serio_raw_exit(void)`
396			`{`
397			`serio_unregister_driver(&serio_raw_drv);`
398			`}`
399
400			`module_init(serio_raw_init);`
401			`module_exit(serio_raw_exit);`