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.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/delay.h>
17 #include <linux/errno.h>
18 #include <linux/joystick.h>
19 #include <linux/input.h>
20 #include <linux/kernel.h>
21 #include <linux/major.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
25 #include <linux/miscdevice.h>
26 #include <linux/module.h>
27 #include <linux/poll.h>
28 #include <linux/init.h>
29 #include <linux/device.h>
30 #include <linux/cdev.h>
32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
33 MODULE_DESCRIPTION("Joystick device interfaces");
34 MODULE_SUPPORTED_DEVICE("input/js");
35 MODULE_LICENSE("GPL");
37 #define JOYDEV_MINOR_BASE 0
38 #define JOYDEV_MINORS 16
39 #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 */
52 struct js_corr corr
[ABS_CNT
];
53 struct JS_DATA_SAVE_TYPE glue
;
56 __u16 keymap
[KEY_MAX
- BTN_MISC
+ 1];
57 __u16 keypam
[KEY_MAX
- BTN_MISC
+ 1];
63 struct joydev_client
{
64 struct js_event buffer
[JOYDEV_BUFFER_SIZE
];
68 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
69 struct fasync_struct
*fasync
;
70 struct joydev
*joydev
;
71 struct list_head node
;
74 static int joydev_correct(int value
, struct js_corr
*corr
)
82 value
= value
> corr
->coef
[0] ? (value
< corr
->coef
[1] ? 0 :
83 ((corr
->coef
[3] * (value
- corr
->coef
[1])) >> 14)) :
84 ((corr
->coef
[2] * (value
- corr
->coef
[0])) >> 14);
91 return value
< -32767 ? -32767 : (value
> 32767 ? 32767 : value
);
94 static void joydev_pass_event(struct joydev_client
*client
,
95 struct js_event
*event
)
97 struct joydev
*joydev
= client
->joydev
;
100 * IRQs already disabled, just acquire the lock
102 spin_lock(&client
->buffer_lock
);
104 client
->buffer
[client
->head
] = *event
;
106 if (client
->startup
== joydev
->nabs
+ joydev
->nkey
) {
108 client
->head
&= JOYDEV_BUFFER_SIZE
- 1;
109 if (client
->tail
== client
->head
)
113 spin_unlock(&client
->buffer_lock
);
115 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
118 static void joydev_event(struct input_handle
*handle
,
119 unsigned int type
, unsigned int code
, int value
)
121 struct joydev
*joydev
= handle
->private;
122 struct joydev_client
*client
;
123 struct js_event event
;
128 if (code
< BTN_MISC
|| value
== 2)
130 event
.type
= JS_EVENT_BUTTON
;
131 event
.number
= joydev
->keymap
[code
- BTN_MISC
];
136 event
.type
= JS_EVENT_AXIS
;
137 event
.number
= joydev
->absmap
[code
];
138 event
.value
= joydev_correct(value
,
139 &joydev
->corr
[event
.number
]);
140 if (event
.value
== joydev
->abs
[event
.number
])
142 joydev
->abs
[event
.number
] = event
.value
;
149 event
.time
= jiffies_to_msecs(jiffies
);
152 list_for_each_entry_rcu(client
, &joydev
->client_list
, node
)
153 joydev_pass_event(client
, &event
);
156 wake_up_interruptible(&joydev
->wait
);
159 static int joydev_fasync(int fd
, struct file
*file
, int on
)
161 struct joydev_client
*client
= file
->private_data
;
163 return fasync_helper(fd
, file
, on
, &client
->fasync
);
166 static void joydev_free(struct device
*dev
)
168 struct joydev
*joydev
= container_of(dev
, struct joydev
, dev
);
170 input_put_device(joydev
->handle
.dev
);
174 static void joydev_attach_client(struct joydev
*joydev
,
175 struct joydev_client
*client
)
177 spin_lock(&joydev
->client_lock
);
178 list_add_tail_rcu(&client
->node
, &joydev
->client_list
);
179 spin_unlock(&joydev
->client_lock
);
182 static void joydev_detach_client(struct joydev
*joydev
,
183 struct joydev_client
*client
)
185 spin_lock(&joydev
->client_lock
);
186 list_del_rcu(&client
->node
);
187 spin_unlock(&joydev
->client_lock
);
191 static int joydev_open_device(struct joydev
*joydev
)
195 retval
= mutex_lock_interruptible(&joydev
->mutex
);
201 else if (!joydev
->open
++) {
202 retval
= input_open_device(&joydev
->handle
);
207 mutex_unlock(&joydev
->mutex
);
211 static void joydev_close_device(struct joydev
*joydev
)
213 mutex_lock(&joydev
->mutex
);
215 if (joydev
->exist
&& !--joydev
->open
)
216 input_close_device(&joydev
->handle
);
218 mutex_unlock(&joydev
->mutex
);
222 * Wake up users waiting for IO so they can disconnect from
225 static void joydev_hangup(struct joydev
*joydev
)
227 struct joydev_client
*client
;
229 spin_lock(&joydev
->client_lock
);
230 list_for_each_entry(client
, &joydev
->client_list
, node
)
231 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
232 spin_unlock(&joydev
->client_lock
);
234 wake_up_interruptible(&joydev
->wait
);
237 static int joydev_release(struct inode
*inode
, struct file
*file
)
239 struct joydev_client
*client
= file
->private_data
;
240 struct joydev
*joydev
= client
->joydev
;
242 joydev_detach_client(joydev
, client
);
245 joydev_close_device(joydev
);
250 static int joydev_open(struct inode
*inode
, struct file
*file
)
252 struct joydev
*joydev
=
253 container_of(inode
->i_cdev
, struct joydev
, cdev
);
254 struct joydev_client
*client
;
257 client
= kzalloc(sizeof(struct joydev_client
), GFP_KERNEL
);
261 spin_lock_init(&client
->buffer_lock
);
262 client
->joydev
= joydev
;
263 joydev_attach_client(joydev
, client
);
265 error
= joydev_open_device(joydev
);
267 goto err_free_client
;
269 file
->private_data
= client
;
270 nonseekable_open(inode
, file
);
275 joydev_detach_client(joydev
, client
);
280 static int joydev_generate_startup_event(struct joydev_client
*client
,
281 struct input_dev
*input
,
282 struct js_event
*event
)
284 struct joydev
*joydev
= client
->joydev
;
287 spin_lock_irq(&client
->buffer_lock
);
289 have_event
= client
->startup
< joydev
->nabs
+ joydev
->nkey
;
293 event
->time
= jiffies_to_msecs(jiffies
);
294 if (client
->startup
< joydev
->nkey
) {
295 event
->type
= JS_EVENT_BUTTON
| JS_EVENT_INIT
;
296 event
->number
= client
->startup
;
297 event
->value
= !!test_bit(joydev
->keypam
[event
->number
],
300 event
->type
= JS_EVENT_AXIS
| JS_EVENT_INIT
;
301 event
->number
= client
->startup
- joydev
->nkey
;
302 event
->value
= joydev
->abs
[event
->number
];
307 spin_unlock_irq(&client
->buffer_lock
);
312 static int joydev_fetch_next_event(struct joydev_client
*client
,
313 struct js_event
*event
)
317 spin_lock_irq(&client
->buffer_lock
);
319 have_event
= client
->head
!= client
->tail
;
321 *event
= client
->buffer
[client
->tail
++];
322 client
->tail
&= JOYDEV_BUFFER_SIZE
- 1;
325 spin_unlock_irq(&client
->buffer_lock
);
331 * Old joystick interface
333 static ssize_t
joydev_0x_read(struct joydev_client
*client
,
334 struct input_dev
*input
,
337 struct joydev
*joydev
= client
->joydev
;
338 struct JS_DATA_TYPE data
;
341 spin_lock_irq(&input
->event_lock
);
346 for (data
.buttons
= i
= 0; i
< 32 && i
< joydev
->nkey
; i
++)
348 test_bit(joydev
->keypam
[i
], input
->key
) ? (1 << i
) : 0;
349 data
.x
= (joydev
->abs
[0] / 256 + 128) >> joydev
->glue
.JS_CORR
.x
;
350 data
.y
= (joydev
->abs
[1] / 256 + 128) >> joydev
->glue
.JS_CORR
.y
;
353 * Reset reader's event queue
355 spin_lock(&client
->buffer_lock
);
357 client
->tail
= client
->head
;
358 spin_unlock(&client
->buffer_lock
);
360 spin_unlock_irq(&input
->event_lock
);
362 if (copy_to_user(buf
, &data
, sizeof(struct JS_DATA_TYPE
)))
365 return sizeof(struct JS_DATA_TYPE
);
368 static inline int joydev_data_pending(struct joydev_client
*client
)
370 struct joydev
*joydev
= client
->joydev
;
372 return client
->startup
< joydev
->nabs
+ joydev
->nkey
||
373 client
->head
!= client
->tail
;
376 static ssize_t
joydev_read(struct file
*file
, char __user
*buf
,
377 size_t count
, loff_t
*ppos
)
379 struct joydev_client
*client
= file
->private_data
;
380 struct joydev
*joydev
= client
->joydev
;
381 struct input_dev
*input
= joydev
->handle
.dev
;
382 struct js_event event
;
388 if (count
< sizeof(struct js_event
))
391 if (count
== sizeof(struct JS_DATA_TYPE
))
392 return joydev_0x_read(client
, input
, buf
);
394 if (!joydev_data_pending(client
) && (file
->f_flags
& O_NONBLOCK
))
397 retval
= wait_event_interruptible(joydev
->wait
,
398 !joydev
->exist
|| joydev_data_pending(client
));
405 while (retval
+ sizeof(struct js_event
) <= count
&&
406 joydev_generate_startup_event(client
, input
, &event
)) {
408 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
411 retval
+= sizeof(struct js_event
);
414 while (retval
+ sizeof(struct js_event
) <= count
&&
415 joydev_fetch_next_event(client
, &event
)) {
417 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
420 retval
+= sizeof(struct js_event
);
426 /* No kernel lock - fine */
427 static unsigned int joydev_poll(struct file
*file
, poll_table
*wait
)
429 struct joydev_client
*client
= file
->private_data
;
430 struct joydev
*joydev
= client
->joydev
;
432 poll_wait(file
, &joydev
->wait
, wait
);
433 return (joydev_data_pending(client
) ? (POLLIN
| POLLRDNORM
) : 0) |
434 (joydev
->exist
? 0 : (POLLHUP
| POLLERR
));
437 static int joydev_handle_JSIOCSAXMAP(struct joydev
*joydev
,
438 void __user
*argp
, size_t len
)
444 len
= min(len
, sizeof(joydev
->abspam
));
446 /* Validate the map. */
447 abspam
= kmalloc(len
, GFP_KERNEL
);
451 if (copy_from_user(abspam
, argp
, len
)) {
456 for (i
= 0; i
< joydev
->nabs
; i
++) {
457 if (abspam
[i
] > ABS_MAX
) {
463 memcpy(joydev
->abspam
, abspam
, len
);
465 for (i
= 0; i
< joydev
->nabs
; i
++)
466 joydev
->absmap
[joydev
->abspam
[i
]] = i
;
473 static int joydev_handle_JSIOCSBTNMAP(struct joydev
*joydev
,
474 void __user
*argp
, size_t len
)
480 len
= min(len
, sizeof(joydev
->keypam
));
482 /* Validate the map. */
483 keypam
= kmalloc(len
, GFP_KERNEL
);
487 if (copy_from_user(keypam
, argp
, len
)) {
492 for (i
= 0; i
< joydev
->nkey
; i
++) {
493 if (keypam
[i
] > KEY_MAX
|| keypam
[i
] < BTN_MISC
) {
499 memcpy(joydev
->keypam
, keypam
, len
);
501 for (i
= 0; i
< joydev
->nkey
; i
++)
502 joydev
->keymap
[keypam
[i
] - BTN_MISC
] = i
;
510 static int joydev_ioctl_common(struct joydev
*joydev
,
511 unsigned int cmd
, void __user
*argp
)
513 struct input_dev
*dev
= joydev
->handle
.dev
;
518 /* Process fixed-sized commands. */
522 return copy_from_user(&joydev
->glue
.JS_CORR
, argp
,
523 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
526 return copy_to_user(argp
, &joydev
->glue
.JS_CORR
,
527 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
530 return get_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
533 return put_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
536 return put_user(JS_VERSION
, (__u32 __user
*) argp
);
539 return put_user(joydev
->nabs
, (__u8 __user
*) argp
);
542 return put_user(joydev
->nkey
, (__u8 __user
*) argp
);
545 if (copy_from_user(joydev
->corr
, argp
,
546 sizeof(joydev
->corr
[0]) * joydev
->nabs
))
549 for (i
= 0; i
< joydev
->nabs
; i
++) {
550 int val
= input_abs_get_val(dev
, joydev
->abspam
[i
]);
551 joydev
->abs
[i
] = joydev_correct(val
, &joydev
->corr
[i
]);
556 return copy_to_user(argp
, joydev
->corr
,
557 sizeof(joydev
->corr
[0]) * joydev
->nabs
) ? -EFAULT
: 0;
562 * Process variable-sized commands (the axis and button map commands
563 * are considered variable-sized to decouple them from the values of
564 * ABS_MAX and KEY_MAX).
566 switch (cmd
& ~IOCSIZE_MASK
) {
568 case (JSIOCSAXMAP
& ~IOCSIZE_MASK
):
569 return joydev_handle_JSIOCSAXMAP(joydev
, argp
, _IOC_SIZE(cmd
));
571 case (JSIOCGAXMAP
& ~IOCSIZE_MASK
):
572 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->abspam
));
573 return copy_to_user(argp
, joydev
->abspam
, len
) ? -EFAULT
: len
;
575 case (JSIOCSBTNMAP
& ~IOCSIZE_MASK
):
576 return joydev_handle_JSIOCSBTNMAP(joydev
, argp
, _IOC_SIZE(cmd
));
578 case (JSIOCGBTNMAP
& ~IOCSIZE_MASK
):
579 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->keypam
));
580 return copy_to_user(argp
, joydev
->keypam
, len
) ? -EFAULT
: len
;
587 len
= min_t(size_t, _IOC_SIZE(cmd
), strlen(name
) + 1);
588 return copy_to_user(argp
, name
, len
) ? -EFAULT
: len
;
595 static long joydev_compat_ioctl(struct file
*file
,
596 unsigned int cmd
, unsigned long arg
)
598 struct joydev_client
*client
= file
->private_data
;
599 struct joydev
*joydev
= client
->joydev
;
600 void __user
*argp
= (void __user
*)arg
;
602 struct JS_DATA_SAVE_TYPE_32 ds32
;
605 retval
= mutex_lock_interruptible(&joydev
->mutex
);
609 if (!joydev
->exist
) {
616 case JS_SET_TIMELIMIT
:
617 retval
= get_user(tmp32
, (s32 __user
*) arg
);
619 joydev
->glue
.JS_TIMELIMIT
= tmp32
;
622 case JS_GET_TIMELIMIT
:
623 tmp32
= joydev
->glue
.JS_TIMELIMIT
;
624 retval
= put_user(tmp32
, (s32 __user
*) arg
);
628 retval
= copy_from_user(&ds32
, argp
,
629 sizeof(ds32
)) ? -EFAULT
: 0;
631 joydev
->glue
.JS_TIMEOUT
= ds32
.JS_TIMEOUT
;
632 joydev
->glue
.BUSY
= ds32
.BUSY
;
633 joydev
->glue
.JS_EXPIRETIME
= ds32
.JS_EXPIRETIME
;
634 joydev
->glue
.JS_TIMELIMIT
= ds32
.JS_TIMELIMIT
;
635 joydev
->glue
.JS_SAVE
= ds32
.JS_SAVE
;
636 joydev
->glue
.JS_CORR
= ds32
.JS_CORR
;
641 ds32
.JS_TIMEOUT
= joydev
->glue
.JS_TIMEOUT
;
642 ds32
.BUSY
= joydev
->glue
.BUSY
;
643 ds32
.JS_EXPIRETIME
= joydev
->glue
.JS_EXPIRETIME
;
644 ds32
.JS_TIMELIMIT
= joydev
->glue
.JS_TIMELIMIT
;
645 ds32
.JS_SAVE
= joydev
->glue
.JS_SAVE
;
646 ds32
.JS_CORR
= joydev
->glue
.JS_CORR
;
648 retval
= copy_to_user(argp
, &ds32
, sizeof(ds32
)) ? -EFAULT
: 0;
652 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
657 mutex_unlock(&joydev
->mutex
);
660 #endif /* CONFIG_COMPAT */
662 static long joydev_ioctl(struct file
*file
,
663 unsigned int cmd
, unsigned long arg
)
665 struct joydev_client
*client
= file
->private_data
;
666 struct joydev
*joydev
= client
->joydev
;
667 void __user
*argp
= (void __user
*)arg
;
670 retval
= mutex_lock_interruptible(&joydev
->mutex
);
674 if (!joydev
->exist
) {
681 case JS_SET_TIMELIMIT
:
682 retval
= get_user(joydev
->glue
.JS_TIMELIMIT
,
683 (long __user
*) arg
);
686 case JS_GET_TIMELIMIT
:
687 retval
= put_user(joydev
->glue
.JS_TIMELIMIT
,
688 (long __user
*) arg
);
692 retval
= copy_from_user(&joydev
->glue
, argp
,
693 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
697 retval
= copy_to_user(argp
, &joydev
->glue
,
698 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
702 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
706 mutex_unlock(&joydev
->mutex
);
710 static const struct file_operations joydev_fops
= {
711 .owner
= THIS_MODULE
,
715 .release
= joydev_release
,
716 .unlocked_ioctl
= joydev_ioctl
,
718 .compat_ioctl
= joydev_compat_ioctl
,
720 .fasync
= joydev_fasync
,
725 * Mark device non-existent. This disables writes, ioctls and
726 * prevents new users from opening the device. Already posted
727 * blocking reads will stay, however new ones will fail.
729 static void joydev_mark_dead(struct joydev
*joydev
)
731 mutex_lock(&joydev
->mutex
);
732 joydev
->exist
= false;
733 mutex_unlock(&joydev
->mutex
);
736 static void joydev_cleanup(struct joydev
*joydev
)
738 struct input_handle
*handle
= &joydev
->handle
;
740 joydev_mark_dead(joydev
);
741 joydev_hangup(joydev
);
743 cdev_del(&joydev
->cdev
);
745 /* joydev is marked dead so no one else accesses joydev->open */
747 input_close_device(handle
);
750 static bool joydev_dev_is_absolute_mouse(struct input_dev
*dev
)
752 DECLARE_BITMAP(jd_scratch
, KEY_CNT
);
754 BUILD_BUG_ON(ABS_CNT
> KEY_CNT
|| EV_CNT
> KEY_CNT
);
757 * Virtualization (VMware, etc) and remote management (HP
758 * ILO2) solutions use absolute coordinates for their virtual
759 * pointing devices so that there is one-to-one relationship
760 * between pointer position on the host screen and virtual
761 * guest screen, and so their mice use ABS_X, ABS_Y and 3
762 * primary button events. This clashes with what joydev
763 * considers to be joysticks (a device with at minimum ABS_X
766 * Here we are trying to separate absolute mice from
767 * joysticks. A device is, for joystick detection purposes,
768 * considered to be an absolute mouse if the following is
771 * 1) Event types are exactly EV_ABS, EV_KEY and EV_SYN.
772 * 2) Absolute events are exactly ABS_X and ABS_Y.
773 * 3) Keys are exactly BTN_LEFT, BTN_RIGHT and BTN_MIDDLE.
774 * 4) Device is not on "Amiga" bus.
777 bitmap_zero(jd_scratch
, EV_CNT
);
778 __set_bit(EV_ABS
, jd_scratch
);
779 __set_bit(EV_KEY
, jd_scratch
);
780 __set_bit(EV_SYN
, jd_scratch
);
781 if (!bitmap_equal(jd_scratch
, dev
->evbit
, EV_CNT
))
784 bitmap_zero(jd_scratch
, ABS_CNT
);
785 __set_bit(ABS_X
, jd_scratch
);
786 __set_bit(ABS_Y
, jd_scratch
);
787 if (!bitmap_equal(dev
->absbit
, jd_scratch
, ABS_CNT
))
790 bitmap_zero(jd_scratch
, KEY_CNT
);
791 __set_bit(BTN_LEFT
, jd_scratch
);
792 __set_bit(BTN_RIGHT
, jd_scratch
);
793 __set_bit(BTN_MIDDLE
, jd_scratch
);
795 if (!bitmap_equal(dev
->keybit
, jd_scratch
, KEY_CNT
))
799 * Amiga joystick (amijoy) historically uses left/middle/right
802 if (dev
->id
.bustype
== BUS_AMIGA
)
808 static bool joydev_match(struct input_handler
*handler
, struct input_dev
*dev
)
810 /* Avoid touchpads and touchscreens */
811 if (test_bit(EV_KEY
, dev
->evbit
) && test_bit(BTN_TOUCH
, dev
->keybit
))
814 /* Avoid tablets, digitisers and similar devices */
815 if (test_bit(EV_KEY
, dev
->evbit
) && test_bit(BTN_DIGI
, dev
->keybit
))
818 /* Avoid absolute mice */
819 if (joydev_dev_is_absolute_mouse(dev
))
825 static int joydev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
826 const struct input_device_id
*id
)
828 struct joydev
*joydev
;
829 int i
, j
, t
, minor
, dev_no
;
832 minor
= input_get_new_minor(JOYDEV_MINOR_BASE
, JOYDEV_MINORS
, true);
835 pr_err("failed to reserve new minor: %d\n", error
);
839 joydev
= kzalloc(sizeof(struct joydev
), GFP_KERNEL
);
845 INIT_LIST_HEAD(&joydev
->client_list
);
846 spin_lock_init(&joydev
->client_lock
);
847 mutex_init(&joydev
->mutex
);
848 init_waitqueue_head(&joydev
->wait
);
849 joydev
->exist
= true;
852 /* Normalize device number if it falls into legacy range */
853 if (dev_no
< JOYDEV_MINOR_BASE
+ JOYDEV_MINORS
)
854 dev_no
-= JOYDEV_MINOR_BASE
;
855 dev_set_name(&joydev
->dev
, "js%d", dev_no
);
857 joydev
->handle
.dev
= input_get_device(dev
);
858 joydev
->handle
.name
= dev_name(&joydev
->dev
);
859 joydev
->handle
.handler
= handler
;
860 joydev
->handle
.private = joydev
;
862 for (i
= 0; i
< ABS_CNT
; i
++)
863 if (test_bit(i
, dev
->absbit
)) {
864 joydev
->absmap
[i
] = joydev
->nabs
;
865 joydev
->abspam
[joydev
->nabs
] = i
;
869 for (i
= BTN_JOYSTICK
- BTN_MISC
; i
< KEY_MAX
- BTN_MISC
+ 1; i
++)
870 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
871 joydev
->keymap
[i
] = joydev
->nkey
;
872 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
876 for (i
= 0; i
< BTN_JOYSTICK
- BTN_MISC
; i
++)
877 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
878 joydev
->keymap
[i
] = joydev
->nkey
;
879 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
883 for (i
= 0; i
< joydev
->nabs
; i
++) {
884 j
= joydev
->abspam
[i
];
885 if (input_abs_get_max(dev
, j
) == input_abs_get_min(dev
, j
)) {
886 joydev
->corr
[i
].type
= JS_CORR_NONE
;
887 joydev
->abs
[i
] = input_abs_get_val(dev
, j
);
890 joydev
->corr
[i
].type
= JS_CORR_BROKEN
;
891 joydev
->corr
[i
].prec
= input_abs_get_fuzz(dev
, j
);
893 t
= (input_abs_get_max(dev
, j
) + input_abs_get_min(dev
, j
)) / 2;
894 joydev
->corr
[i
].coef
[0] = t
- input_abs_get_flat(dev
, j
);
895 joydev
->corr
[i
].coef
[1] = t
+ input_abs_get_flat(dev
, j
);
897 t
= (input_abs_get_max(dev
, j
) - input_abs_get_min(dev
, j
)) / 2
898 - 2 * input_abs_get_flat(dev
, j
);
900 joydev
->corr
[i
].coef
[2] = (1 << 29) / t
;
901 joydev
->corr
[i
].coef
[3] = (1 << 29) / t
;
904 joydev_correct(input_abs_get_val(dev
, j
),
909 joydev
->dev
.devt
= MKDEV(INPUT_MAJOR
, minor
);
910 joydev
->dev
.class = &input_class
;
911 joydev
->dev
.parent
= &dev
->dev
;
912 joydev
->dev
.release
= joydev_free
;
913 device_initialize(&joydev
->dev
);
915 error
= input_register_handle(&joydev
->handle
);
917 goto err_free_joydev
;
919 cdev_init(&joydev
->cdev
, &joydev_fops
);
920 joydev
->cdev
.kobj
.parent
= &joydev
->dev
.kobj
;
921 error
= cdev_add(&joydev
->cdev
, joydev
->dev
.devt
, 1);
923 goto err_unregister_handle
;
925 error
= device_add(&joydev
->dev
);
927 goto err_cleanup_joydev
;
932 joydev_cleanup(joydev
);
933 err_unregister_handle
:
934 input_unregister_handle(&joydev
->handle
);
936 put_device(&joydev
->dev
);
938 input_free_minor(minor
);
942 static void joydev_disconnect(struct input_handle
*handle
)
944 struct joydev
*joydev
= handle
->private;
946 device_del(&joydev
->dev
);
947 joydev_cleanup(joydev
);
948 input_free_minor(MINOR(joydev
->dev
.devt
));
949 input_unregister_handle(handle
);
950 put_device(&joydev
->dev
);
953 static const struct input_device_id joydev_ids
[] = {
955 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
956 INPUT_DEVICE_ID_MATCH_ABSBIT
,
957 .evbit
= { BIT_MASK(EV_ABS
) },
958 .absbit
= { BIT_MASK(ABS_X
) },
961 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
962 INPUT_DEVICE_ID_MATCH_ABSBIT
,
963 .evbit
= { BIT_MASK(EV_ABS
) },
964 .absbit
= { BIT_MASK(ABS_WHEEL
) },
967 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
968 INPUT_DEVICE_ID_MATCH_ABSBIT
,
969 .evbit
= { BIT_MASK(EV_ABS
) },
970 .absbit
= { BIT_MASK(ABS_THROTTLE
) },
973 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
974 INPUT_DEVICE_ID_MATCH_KEYBIT
,
975 .evbit
= { BIT_MASK(EV_KEY
) },
976 .keybit
= {[BIT_WORD(BTN_JOYSTICK
)] = BIT_MASK(BTN_JOYSTICK
) },
979 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
980 INPUT_DEVICE_ID_MATCH_KEYBIT
,
981 .evbit
= { BIT_MASK(EV_KEY
) },
982 .keybit
= { [BIT_WORD(BTN_GAMEPAD
)] = BIT_MASK(BTN_GAMEPAD
) },
985 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
986 INPUT_DEVICE_ID_MATCH_KEYBIT
,
987 .evbit
= { BIT_MASK(EV_KEY
) },
988 .keybit
= { [BIT_WORD(BTN_TRIGGER_HAPPY
)] = BIT_MASK(BTN_TRIGGER_HAPPY
) },
990 { } /* Terminating entry */
993 MODULE_DEVICE_TABLE(input
, joydev_ids
);
995 static struct input_handler joydev_handler
= {
996 .event
= joydev_event
,
997 .match
= joydev_match
,
998 .connect
= joydev_connect
,
999 .disconnect
= joydev_disconnect
,
1000 .legacy_minors
= true,
1001 .minor
= JOYDEV_MINOR_BASE
,
1003 .id_table
= joydev_ids
,
1006 static int __init
joydev_init(void)
1008 return input_register_handler(&joydev_handler
);
1011 static void __exit
joydev_exit(void)
1013 input_unregister_handler(&joydev_handler
);
1016 module_init(joydev_init
);
1017 module_exit(joydev_exit
);