2 * Joystick device driver for the input driver suite.
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 1999 Colin Van Dyke
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
14 #include <asm/system.h>
15 #include <linux/delay.h>
16 #include <linux/errno.h>
17 #include <linux/joystick.h>
18 #include <linux/input.h>
19 #include <linux/kernel.h>
20 #include <linux/major.h>
21 #include <linux/slab.h>
23 #include <linux/miscdevice.h>
24 #include <linux/module.h>
25 #include <linux/poll.h>
26 #include <linux/init.h>
27 #include <linux/device.h>
29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
30 MODULE_DESCRIPTION("Joystick device interfaces");
31 MODULE_SUPPORTED_DEVICE("input/js");
32 MODULE_LICENSE("GPL");
34 #define JOYDEV_MINOR_BASE 0
35 #define JOYDEV_MINORS 16
36 #define JOYDEV_BUFFER_SIZE 64
43 struct input_handle handle
;
44 wait_queue_head_t wait
;
45 struct list_head client_list
;
46 spinlock_t client_lock
; /* protects client_list */
50 struct js_corr corr
[ABS_MAX
+ 1];
51 struct JS_DATA_SAVE_TYPE glue
;
54 __u16 keymap
[KEY_MAX
- BTN_MISC
+ 1];
55 __u16 keypam
[KEY_MAX
- BTN_MISC
+ 1];
56 __u8 absmap
[ABS_MAX
+ 1];
57 __u8 abspam
[ABS_MAX
+ 1];
58 __s16 abs
[ABS_MAX
+ 1];
61 struct joydev_client
{
62 struct js_event buffer
[JOYDEV_BUFFER_SIZE
];
66 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
67 struct fasync_struct
*fasync
;
68 struct joydev
*joydev
;
69 struct list_head node
;
72 static struct joydev
*joydev_table
[JOYDEV_MINORS
];
73 static DEFINE_MUTEX(joydev_table_mutex
);
75 static int joydev_correct(int value
, struct js_corr
*corr
)
83 value
= value
> corr
->coef
[0] ? (value
< corr
->coef
[1] ? 0 :
84 ((corr
->coef
[3] * (value
- corr
->coef
[1])) >> 14)) :
85 ((corr
->coef
[2] * (value
- corr
->coef
[0])) >> 14);
92 return value
< -32767 ? -32767 : (value
> 32767 ? 32767 : value
);
95 static void joydev_pass_event(struct joydev_client
*client
,
96 struct js_event
*event
)
98 struct joydev
*joydev
= client
->joydev
;
101 * IRQs already disabled, just acquire the lock
103 spin_lock(&client
->buffer_lock
);
105 client
->buffer
[client
->head
] = *event
;
107 if (client
->startup
== joydev
->nabs
+ joydev
->nkey
) {
109 client
->head
&= JOYDEV_BUFFER_SIZE
- 1;
110 if (client
->tail
== client
->head
)
114 spin_unlock(&client
->buffer_lock
);
116 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
119 static void joydev_event(struct input_handle
*handle
,
120 unsigned int type
, unsigned int code
, int value
)
122 struct joydev
*joydev
= handle
->private;
123 struct joydev_client
*client
;
124 struct js_event event
;
129 if (code
< BTN_MISC
|| value
== 2)
131 event
.type
= JS_EVENT_BUTTON
;
132 event
.number
= joydev
->keymap
[code
- BTN_MISC
];
137 event
.type
= JS_EVENT_AXIS
;
138 event
.number
= joydev
->absmap
[code
];
139 event
.value
= joydev_correct(value
,
140 &joydev
->corr
[event
.number
]);
141 if (event
.value
== joydev
->abs
[event
.number
])
143 joydev
->abs
[event
.number
] = event
.value
;
150 event
.time
= jiffies_to_msecs(jiffies
);
153 list_for_each_entry_rcu(client
, &joydev
->client_list
, node
)
154 joydev_pass_event(client
, &event
);
157 wake_up_interruptible(&joydev
->wait
);
160 static int joydev_fasync(int fd
, struct file
*file
, int on
)
162 struct joydev_client
*client
= file
->private_data
;
164 return fasync_helper(fd
, file
, on
, &client
->fasync
);
167 static void joydev_free(struct device
*dev
)
169 struct joydev
*joydev
= container_of(dev
, struct joydev
, dev
);
171 input_put_device(joydev
->handle
.dev
);
175 static void joydev_attach_client(struct joydev
*joydev
,
176 struct joydev_client
*client
)
178 spin_lock(&joydev
->client_lock
);
179 list_add_tail_rcu(&client
->node
, &joydev
->client_list
);
180 spin_unlock(&joydev
->client_lock
);
184 static void joydev_detach_client(struct joydev
*joydev
,
185 struct joydev_client
*client
)
187 spin_lock(&joydev
->client_lock
);
188 list_del_rcu(&client
->node
);
189 spin_unlock(&joydev
->client_lock
);
193 static int joydev_open_device(struct joydev
*joydev
)
197 retval
= mutex_lock_interruptible(&joydev
->mutex
);
203 else if (!joydev
->open
++) {
204 retval
= input_open_device(&joydev
->handle
);
209 mutex_unlock(&joydev
->mutex
);
213 static void joydev_close_device(struct joydev
*joydev
)
215 mutex_lock(&joydev
->mutex
);
217 if (joydev
->exist
&& !--joydev
->open
)
218 input_close_device(&joydev
->handle
);
220 mutex_unlock(&joydev
->mutex
);
224 * Wake up users waiting for IO so they can disconnect from
227 static void joydev_hangup(struct joydev
*joydev
)
229 struct joydev_client
*client
;
231 spin_lock(&joydev
->client_lock
);
232 list_for_each_entry(client
, &joydev
->client_list
, node
)
233 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
234 spin_unlock(&joydev
->client_lock
);
236 wake_up_interruptible(&joydev
->wait
);
239 static int joydev_release(struct inode
*inode
, struct file
*file
)
241 struct joydev_client
*client
= file
->private_data
;
242 struct joydev
*joydev
= client
->joydev
;
244 joydev_detach_client(joydev
, client
);
247 joydev_close_device(joydev
);
248 put_device(&joydev
->dev
);
253 static int joydev_open(struct inode
*inode
, struct file
*file
)
255 struct joydev_client
*client
;
256 struct joydev
*joydev
;
257 int i
= iminor(inode
) - JOYDEV_MINOR_BASE
;
260 if (i
>= JOYDEV_MINORS
)
263 error
= mutex_lock_interruptible(&joydev_table_mutex
);
266 joydev
= joydev_table
[i
];
268 get_device(&joydev
->dev
);
269 mutex_unlock(&joydev_table_mutex
);
274 client
= kzalloc(sizeof(struct joydev_client
), GFP_KERNEL
);
280 spin_lock_init(&client
->buffer_lock
);
281 client
->joydev
= joydev
;
282 joydev_attach_client(joydev
, client
);
284 error
= joydev_open_device(joydev
);
286 goto err_free_client
;
288 file
->private_data
= client
;
292 joydev_detach_client(joydev
, client
);
295 put_device(&joydev
->dev
);
299 static int joydev_generate_startup_event(struct joydev_client
*client
,
300 struct input_dev
*input
,
301 struct js_event
*event
)
303 struct joydev
*joydev
= client
->joydev
;
306 spin_lock_irq(&client
->buffer_lock
);
308 have_event
= client
->startup
< joydev
->nabs
+ joydev
->nkey
;
312 event
->time
= jiffies_to_msecs(jiffies
);
313 if (client
->startup
< joydev
->nkey
) {
314 event
->type
= JS_EVENT_BUTTON
| JS_EVENT_INIT
;
315 event
->number
= client
->startup
;
316 event
->value
= !!test_bit(joydev
->keypam
[event
->number
],
319 event
->type
= JS_EVENT_AXIS
| JS_EVENT_INIT
;
320 event
->number
= client
->startup
- joydev
->nkey
;
321 event
->value
= joydev
->abs
[event
->number
];
326 spin_unlock_irq(&client
->buffer_lock
);
331 static int joydev_fetch_next_event(struct joydev_client
*client
,
332 struct js_event
*event
)
336 spin_lock_irq(&client
->buffer_lock
);
338 have_event
= client
->head
!= client
->tail
;
340 *event
= client
->buffer
[client
->tail
++];
341 client
->tail
&= JOYDEV_BUFFER_SIZE
- 1;
344 spin_unlock_irq(&client
->buffer_lock
);
350 * Old joystick interface
352 static ssize_t
joydev_0x_read(struct joydev_client
*client
,
353 struct input_dev
*input
,
356 struct joydev
*joydev
= client
->joydev
;
357 struct JS_DATA_TYPE data
;
360 spin_lock_irq(&input
->event_lock
);
365 for (data
.buttons
= i
= 0; i
< 32 && i
< joydev
->nkey
; i
++)
367 test_bit(joydev
->keypam
[i
], input
->key
) ? (1 << i
) : 0;
368 data
.x
= (joydev
->abs
[0] / 256 + 128) >> joydev
->glue
.JS_CORR
.x
;
369 data
.y
= (joydev
->abs
[1] / 256 + 128) >> joydev
->glue
.JS_CORR
.y
;
372 * Reset reader's event queue
374 spin_lock(&client
->buffer_lock
);
376 client
->tail
= client
->head
;
377 spin_unlock(&client
->buffer_lock
);
379 spin_unlock_irq(&input
->event_lock
);
381 if (copy_to_user(buf
, &data
, sizeof(struct JS_DATA_TYPE
)))
384 return sizeof(struct JS_DATA_TYPE
);
387 static inline int joydev_data_pending(struct joydev_client
*client
)
389 struct joydev
*joydev
= client
->joydev
;
391 return client
->startup
< joydev
->nabs
+ joydev
->nkey
||
392 client
->head
!= client
->tail
;
395 static ssize_t
joydev_read(struct file
*file
, char __user
*buf
,
396 size_t count
, loff_t
*ppos
)
398 struct joydev_client
*client
= file
->private_data
;
399 struct joydev
*joydev
= client
->joydev
;
400 struct input_dev
*input
= joydev
->handle
.dev
;
401 struct js_event event
;
407 if (count
< sizeof(struct js_event
))
410 if (count
== sizeof(struct JS_DATA_TYPE
))
411 return joydev_0x_read(client
, input
, buf
);
413 if (!joydev_data_pending(client
) && (file
->f_flags
& O_NONBLOCK
))
416 retval
= wait_event_interruptible(joydev
->wait
,
417 !joydev
->exist
|| joydev_data_pending(client
));
424 while (retval
+ sizeof(struct js_event
) <= count
&&
425 joydev_generate_startup_event(client
, input
, &event
)) {
427 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
430 retval
+= sizeof(struct js_event
);
433 while (retval
+ sizeof(struct js_event
) <= count
&&
434 joydev_fetch_next_event(client
, &event
)) {
436 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
439 retval
+= sizeof(struct js_event
);
445 /* No kernel lock - fine */
446 static unsigned int joydev_poll(struct file
*file
, poll_table
*wait
)
448 struct joydev_client
*client
= file
->private_data
;
449 struct joydev
*joydev
= client
->joydev
;
451 poll_wait(file
, &joydev
->wait
, wait
);
452 return (joydev_data_pending(client
) ? (POLLIN
| POLLRDNORM
) : 0) |
453 (joydev
->exist
? 0 : (POLLHUP
| POLLERR
));
456 static int joydev_ioctl_common(struct joydev
*joydev
,
457 unsigned int cmd
, void __user
*argp
)
459 struct input_dev
*dev
= joydev
->handle
.dev
;
464 /* Process fixed-sized commands. */
468 return copy_from_user(&joydev
->glue
.JS_CORR
, argp
,
469 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
472 return copy_to_user(argp
, &joydev
->glue
.JS_CORR
,
473 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
476 return get_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
479 return put_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
482 return put_user(JS_VERSION
, (__u32 __user
*) argp
);
485 return put_user(joydev
->nabs
, (__u8 __user
*) argp
);
488 return put_user(joydev
->nkey
, (__u8 __user
*) argp
);
491 if (copy_from_user(joydev
->corr
, argp
,
492 sizeof(joydev
->corr
[0]) * joydev
->nabs
))
495 for (i
= 0; i
< joydev
->nabs
; i
++) {
496 j
= joydev
->abspam
[i
];
497 joydev
->abs
[i
] = joydev_correct(dev
->abs
[j
],
503 return copy_to_user(argp
, joydev
->corr
,
504 sizeof(joydev
->corr
[0]) * joydev
->nabs
) ? -EFAULT
: 0;
509 * Process variable-sized commands (the axis and button map commands
510 * are considered variable-sized to decouple them from the values of
511 * ABS_MAX and KEY_MAX).
513 switch (cmd
& ~IOCSIZE_MASK
) {
515 case (JSIOCSAXMAP
& ~IOCSIZE_MASK
):
516 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->abspam
));
518 * FIXME: we should not copy into our axis map before
519 * validating the data.
521 if (copy_from_user(joydev
->abspam
, argp
, len
))
524 for (i
= 0; i
< joydev
->nabs
; i
++) {
525 if (joydev
->abspam
[i
] > ABS_MAX
)
527 joydev
->absmap
[joydev
->abspam
[i
]] = i
;
531 case (JSIOCGAXMAP
& ~IOCSIZE_MASK
):
532 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->abspam
));
533 return copy_to_user(argp
, joydev
->abspam
, len
) ? -EFAULT
: 0;
535 case (JSIOCSBTNMAP
& ~IOCSIZE_MASK
):
536 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->keypam
));
538 * FIXME: we should not copy into our keymap before
539 * validating the data.
541 if (copy_from_user(joydev
->keypam
, argp
, len
))
544 for (i
= 0; i
< joydev
->nkey
; i
++) {
545 if (joydev
->keypam
[i
] > KEY_MAX
||
546 joydev
->keypam
[i
] < BTN_MISC
)
548 joydev
->keymap
[joydev
->keypam
[i
] - BTN_MISC
] = i
;
553 case (JSIOCGBTNMAP
& ~IOCSIZE_MASK
):
554 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->keypam
));
555 return copy_to_user(argp
, joydev
->keypam
, len
) ? -EFAULT
: 0;
562 len
= min_t(size_t, _IOC_SIZE(cmd
), strlen(name
) + 1);
563 return copy_to_user(argp
, name
, len
) ? -EFAULT
: len
;
570 static long joydev_compat_ioctl(struct file
*file
,
571 unsigned int cmd
, unsigned long arg
)
573 struct joydev_client
*client
= file
->private_data
;
574 struct joydev
*joydev
= client
->joydev
;
575 void __user
*argp
= (void __user
*)arg
;
577 struct JS_DATA_SAVE_TYPE_32 ds32
;
580 retval
= mutex_lock_interruptible(&joydev
->mutex
);
584 if (!joydev
->exist
) {
591 case JS_SET_TIMELIMIT
:
592 retval
= get_user(tmp32
, (s32 __user
*) arg
);
594 joydev
->glue
.JS_TIMELIMIT
= tmp32
;
597 case JS_GET_TIMELIMIT
:
598 tmp32
= joydev
->glue
.JS_TIMELIMIT
;
599 retval
= put_user(tmp32
, (s32 __user
*) arg
);
603 retval
= copy_from_user(&ds32
, argp
,
604 sizeof(ds32
)) ? -EFAULT
: 0;
606 joydev
->glue
.JS_TIMEOUT
= ds32
.JS_TIMEOUT
;
607 joydev
->glue
.BUSY
= ds32
.BUSY
;
608 joydev
->glue
.JS_EXPIRETIME
= ds32
.JS_EXPIRETIME
;
609 joydev
->glue
.JS_TIMELIMIT
= ds32
.JS_TIMELIMIT
;
610 joydev
->glue
.JS_SAVE
= ds32
.JS_SAVE
;
611 joydev
->glue
.JS_CORR
= ds32
.JS_CORR
;
616 ds32
.JS_TIMEOUT
= joydev
->glue
.JS_TIMEOUT
;
617 ds32
.BUSY
= joydev
->glue
.BUSY
;
618 ds32
.JS_EXPIRETIME
= joydev
->glue
.JS_EXPIRETIME
;
619 ds32
.JS_TIMELIMIT
= joydev
->glue
.JS_TIMELIMIT
;
620 ds32
.JS_SAVE
= joydev
->glue
.JS_SAVE
;
621 ds32
.JS_CORR
= joydev
->glue
.JS_CORR
;
623 retval
= copy_to_user(argp
, &ds32
, sizeof(ds32
)) ? -EFAULT
: 0;
627 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
632 mutex_unlock(&joydev
->mutex
);
635 #endif /* CONFIG_COMPAT */
637 static long joydev_ioctl(struct file
*file
,
638 unsigned int cmd
, unsigned long arg
)
640 struct joydev_client
*client
= file
->private_data
;
641 struct joydev
*joydev
= client
->joydev
;
642 void __user
*argp
= (void __user
*)arg
;
645 retval
= mutex_lock_interruptible(&joydev
->mutex
);
649 if (!joydev
->exist
) {
656 case JS_SET_TIMELIMIT
:
657 retval
= get_user(joydev
->glue
.JS_TIMELIMIT
,
658 (long __user
*) arg
);
661 case JS_GET_TIMELIMIT
:
662 retval
= put_user(joydev
->glue
.JS_TIMELIMIT
,
663 (long __user
*) arg
);
667 retval
= copy_from_user(&joydev
->glue
, argp
,
668 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
672 retval
= copy_to_user(argp
, &joydev
->glue
,
673 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
677 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
681 mutex_unlock(&joydev
->mutex
);
685 static const struct file_operations joydev_fops
= {
686 .owner
= THIS_MODULE
,
690 .release
= joydev_release
,
691 .unlocked_ioctl
= joydev_ioctl
,
693 .compat_ioctl
= joydev_compat_ioctl
,
695 .fasync
= joydev_fasync
,
698 static int joydev_install_chrdev(struct joydev
*joydev
)
700 joydev_table
[joydev
->minor
] = joydev
;
704 static void joydev_remove_chrdev(struct joydev
*joydev
)
706 mutex_lock(&joydev_table_mutex
);
707 joydev_table
[joydev
->minor
] = NULL
;
708 mutex_unlock(&joydev_table_mutex
);
712 * Mark device non-existant. This disables writes, ioctls and
713 * prevents new users from opening the device. Already posted
714 * blocking reads will stay, however new ones will fail.
716 static void joydev_mark_dead(struct joydev
*joydev
)
718 mutex_lock(&joydev
->mutex
);
720 mutex_unlock(&joydev
->mutex
);
723 static void joydev_cleanup(struct joydev
*joydev
)
725 struct input_handle
*handle
= &joydev
->handle
;
727 joydev_mark_dead(joydev
);
728 joydev_hangup(joydev
);
729 joydev_remove_chrdev(joydev
);
731 /* joydev is marked dead so noone else accesses joydev->open */
733 input_close_device(handle
);
736 static int joydev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
737 const struct input_device_id
*id
)
739 struct joydev
*joydev
;
743 for (minor
= 0; minor
< JOYDEV_MINORS
; minor
++)
744 if (!joydev_table
[minor
])
747 if (minor
== JOYDEV_MINORS
) {
748 printk(KERN_ERR
"joydev: no more free joydev devices\n");
752 joydev
= kzalloc(sizeof(struct joydev
), GFP_KERNEL
);
756 INIT_LIST_HEAD(&joydev
->client_list
);
757 spin_lock_init(&joydev
->client_lock
);
758 mutex_init(&joydev
->mutex
);
759 init_waitqueue_head(&joydev
->wait
);
761 snprintf(joydev
->name
, sizeof(joydev
->name
), "js%d", minor
);
763 joydev
->minor
= minor
;
766 joydev
->handle
.dev
= input_get_device(dev
);
767 joydev
->handle
.name
= joydev
->name
;
768 joydev
->handle
.handler
= handler
;
769 joydev
->handle
.private = joydev
;
771 for (i
= 0; i
< ABS_MAX
+ 1; i
++)
772 if (test_bit(i
, dev
->absbit
)) {
773 joydev
->absmap
[i
] = joydev
->nabs
;
774 joydev
->abspam
[joydev
->nabs
] = i
;
778 for (i
= BTN_JOYSTICK
- BTN_MISC
; i
< KEY_MAX
- BTN_MISC
+ 1; i
++)
779 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
780 joydev
->keymap
[i
] = joydev
->nkey
;
781 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
785 for (i
= 0; i
< BTN_JOYSTICK
- BTN_MISC
; i
++)
786 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
787 joydev
->keymap
[i
] = joydev
->nkey
;
788 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
792 for (i
= 0; i
< joydev
->nabs
; i
++) {
793 j
= joydev
->abspam
[i
];
794 if (dev
->absmax
[j
] == dev
->absmin
[j
]) {
795 joydev
->corr
[i
].type
= JS_CORR_NONE
;
796 joydev
->abs
[i
] = dev
->abs
[j
];
799 joydev
->corr
[i
].type
= JS_CORR_BROKEN
;
800 joydev
->corr
[i
].prec
= dev
->absfuzz
[j
];
801 joydev
->corr
[i
].coef
[0] =
802 (dev
->absmax
[j
] + dev
->absmin
[j
]) / 2 - dev
->absflat
[j
];
803 joydev
->corr
[i
].coef
[1] =
804 (dev
->absmax
[j
] + dev
->absmin
[j
]) / 2 + dev
->absflat
[j
];
806 t
= (dev
->absmax
[j
] - dev
->absmin
[j
]) / 2 - 2 * dev
->absflat
[j
];
808 joydev
->corr
[i
].coef
[2] = (1 << 29) / t
;
809 joydev
->corr
[i
].coef
[3] = (1 << 29) / t
;
811 joydev
->abs
[i
] = joydev_correct(dev
->abs
[j
],
816 dev_set_name(&joydev
->dev
, joydev
->name
);
817 joydev
->dev
.devt
= MKDEV(INPUT_MAJOR
, JOYDEV_MINOR_BASE
+ minor
);
818 joydev
->dev
.class = &input_class
;
819 joydev
->dev
.parent
= &dev
->dev
;
820 joydev
->dev
.release
= joydev_free
;
821 device_initialize(&joydev
->dev
);
823 error
= input_register_handle(&joydev
->handle
);
825 goto err_free_joydev
;
827 error
= joydev_install_chrdev(joydev
);
829 goto err_unregister_handle
;
831 error
= device_add(&joydev
->dev
);
833 goto err_cleanup_joydev
;
838 joydev_cleanup(joydev
);
839 err_unregister_handle
:
840 input_unregister_handle(&joydev
->handle
);
842 put_device(&joydev
->dev
);
846 static void joydev_disconnect(struct input_handle
*handle
)
848 struct joydev
*joydev
= handle
->private;
850 device_del(&joydev
->dev
);
851 joydev_cleanup(joydev
);
852 input_unregister_handle(handle
);
853 put_device(&joydev
->dev
);
856 static const struct input_device_id joydev_blacklist
[] = {
858 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
859 INPUT_DEVICE_ID_MATCH_KEYBIT
,
860 .evbit
= { BIT_MASK(EV_KEY
) },
861 .keybit
= { [BIT_WORD(BTN_TOUCH
)] = BIT_MASK(BTN_TOUCH
) },
862 }, /* Avoid itouchpads and touchscreens */
864 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
865 INPUT_DEVICE_ID_MATCH_KEYBIT
,
866 .evbit
= { BIT_MASK(EV_KEY
) },
867 .keybit
= { [BIT_WORD(BTN_DIGI
)] = BIT_MASK(BTN_DIGI
) },
868 }, /* Avoid tablets, digitisers and similar devices */
869 { } /* Terminating entry */
872 static const struct input_device_id joydev_ids
[] = {
874 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
875 INPUT_DEVICE_ID_MATCH_ABSBIT
,
876 .evbit
= { BIT_MASK(EV_ABS
) },
877 .absbit
= { BIT_MASK(ABS_X
) },
880 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
881 INPUT_DEVICE_ID_MATCH_ABSBIT
,
882 .evbit
= { BIT_MASK(EV_ABS
) },
883 .absbit
= { BIT_MASK(ABS_WHEEL
) },
886 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
887 INPUT_DEVICE_ID_MATCH_ABSBIT
,
888 .evbit
= { BIT_MASK(EV_ABS
) },
889 .absbit
= { BIT_MASK(ABS_THROTTLE
) },
891 { } /* Terminating entry */
894 MODULE_DEVICE_TABLE(input
, joydev_ids
);
896 static struct input_handler joydev_handler
= {
897 .event
= joydev_event
,
898 .connect
= joydev_connect
,
899 .disconnect
= joydev_disconnect
,
900 .fops
= &joydev_fops
,
901 .minor
= JOYDEV_MINOR_BASE
,
903 .id_table
= joydev_ids
,
904 .blacklist
= joydev_blacklist
,
907 static int __init
joydev_init(void)
909 return input_register_handler(&joydev_handler
);
912 static void __exit
joydev_exit(void)
914 input_unregister_handler(&joydev_handler
);
917 module_init(joydev_init
);
918 module_exit(joydev_exit
);