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/module.h>
26 #include <linux/poll.h>
27 #include <linux/init.h>
28 #include <linux/device.h>
29 #include <linux/cdev.h>
31 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
32 MODULE_DESCRIPTION("Joystick device interfaces");
33 MODULE_SUPPORTED_DEVICE("input/js");
34 MODULE_LICENSE("GPL");
36 #define JOYDEV_MINOR_BASE 0
37 #define JOYDEV_MINORS 16
38 #define JOYDEV_BUFFER_SIZE 64
42 struct input_handle handle
;
43 wait_queue_head_t wait
;
44 struct list_head client_list
;
45 spinlock_t client_lock
; /* protects client_list */
51 struct js_corr corr
[ABS_CNT
];
52 struct JS_DATA_SAVE_TYPE glue
;
55 __u16 keymap
[KEY_MAX
- BTN_MISC
+ 1];
56 __u16 keypam
[KEY_MAX
- BTN_MISC
+ 1];
62 struct joydev_client
{
63 struct js_event buffer
[JOYDEV_BUFFER_SIZE
];
67 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
68 struct fasync_struct
*fasync
;
69 struct joydev
*joydev
;
70 struct list_head node
;
73 static int joydev_correct(int value
, struct js_corr
*corr
)
81 value
= value
> corr
->coef
[0] ? (value
< corr
->coef
[1] ? 0 :
82 ((corr
->coef
[3] * (value
- corr
->coef
[1])) >> 14)) :
83 ((corr
->coef
[2] * (value
- corr
->coef
[0])) >> 14);
90 return value
< -32767 ? -32767 : (value
> 32767 ? 32767 : value
);
93 static void joydev_pass_event(struct joydev_client
*client
,
94 struct js_event
*event
)
96 struct joydev
*joydev
= client
->joydev
;
99 * IRQs already disabled, just acquire the lock
101 spin_lock(&client
->buffer_lock
);
103 client
->buffer
[client
->head
] = *event
;
105 if (client
->startup
== joydev
->nabs
+ joydev
->nkey
) {
107 client
->head
&= JOYDEV_BUFFER_SIZE
- 1;
108 if (client
->tail
== client
->head
)
112 spin_unlock(&client
->buffer_lock
);
114 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
117 static void joydev_event(struct input_handle
*handle
,
118 unsigned int type
, unsigned int code
, int value
)
120 struct joydev
*joydev
= handle
->private;
121 struct joydev_client
*client
;
122 struct js_event event
;
127 if (code
< BTN_MISC
|| value
== 2)
129 event
.type
= JS_EVENT_BUTTON
;
130 event
.number
= joydev
->keymap
[code
- BTN_MISC
];
135 event
.type
= JS_EVENT_AXIS
;
136 event
.number
= joydev
->absmap
[code
];
137 event
.value
= joydev_correct(value
,
138 &joydev
->corr
[event
.number
]);
139 if (event
.value
== joydev
->abs
[event
.number
])
141 joydev
->abs
[event
.number
] = event
.value
;
148 event
.time
= jiffies_to_msecs(jiffies
);
151 list_for_each_entry_rcu(client
, &joydev
->client_list
, node
)
152 joydev_pass_event(client
, &event
);
155 wake_up_interruptible(&joydev
->wait
);
158 static int joydev_fasync(int fd
, struct file
*file
, int on
)
160 struct joydev_client
*client
= file
->private_data
;
162 return fasync_helper(fd
, file
, on
, &client
->fasync
);
165 static void joydev_free(struct device
*dev
)
167 struct joydev
*joydev
= container_of(dev
, struct joydev
, dev
);
169 input_put_device(joydev
->handle
.dev
);
173 static void joydev_attach_client(struct joydev
*joydev
,
174 struct joydev_client
*client
)
176 spin_lock(&joydev
->client_lock
);
177 list_add_tail_rcu(&client
->node
, &joydev
->client_list
);
178 spin_unlock(&joydev
->client_lock
);
181 static void joydev_detach_client(struct joydev
*joydev
,
182 struct joydev_client
*client
)
184 spin_lock(&joydev
->client_lock
);
185 list_del_rcu(&client
->node
);
186 spin_unlock(&joydev
->client_lock
);
190 static int joydev_open_device(struct joydev
*joydev
)
194 retval
= mutex_lock_interruptible(&joydev
->mutex
);
200 else if (!joydev
->open
++) {
201 retval
= input_open_device(&joydev
->handle
);
206 mutex_unlock(&joydev
->mutex
);
210 static void joydev_close_device(struct joydev
*joydev
)
212 mutex_lock(&joydev
->mutex
);
214 if (joydev
->exist
&& !--joydev
->open
)
215 input_close_device(&joydev
->handle
);
217 mutex_unlock(&joydev
->mutex
);
221 * Wake up users waiting for IO so they can disconnect from
224 static void joydev_hangup(struct joydev
*joydev
)
226 struct joydev_client
*client
;
228 spin_lock(&joydev
->client_lock
);
229 list_for_each_entry(client
, &joydev
->client_list
, node
)
230 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
231 spin_unlock(&joydev
->client_lock
);
233 wake_up_interruptible(&joydev
->wait
);
236 static int joydev_release(struct inode
*inode
, struct file
*file
)
238 struct joydev_client
*client
= file
->private_data
;
239 struct joydev
*joydev
= client
->joydev
;
241 joydev_detach_client(joydev
, client
);
244 joydev_close_device(joydev
);
249 static int joydev_open(struct inode
*inode
, struct file
*file
)
251 struct joydev
*joydev
=
252 container_of(inode
->i_cdev
, struct joydev
, cdev
);
253 struct joydev_client
*client
;
256 client
= kzalloc(sizeof(struct joydev_client
), GFP_KERNEL
);
260 spin_lock_init(&client
->buffer_lock
);
261 client
->joydev
= joydev
;
262 joydev_attach_client(joydev
, client
);
264 error
= joydev_open_device(joydev
);
266 goto err_free_client
;
268 file
->private_data
= client
;
269 nonseekable_open(inode
, file
);
274 joydev_detach_client(joydev
, client
);
279 static int joydev_generate_startup_event(struct joydev_client
*client
,
280 struct input_dev
*input
,
281 struct js_event
*event
)
283 struct joydev
*joydev
= client
->joydev
;
286 spin_lock_irq(&client
->buffer_lock
);
288 have_event
= client
->startup
< joydev
->nabs
+ joydev
->nkey
;
292 event
->time
= jiffies_to_msecs(jiffies
);
293 if (client
->startup
< joydev
->nkey
) {
294 event
->type
= JS_EVENT_BUTTON
| JS_EVENT_INIT
;
295 event
->number
= client
->startup
;
296 event
->value
= !!test_bit(joydev
->keypam
[event
->number
],
299 event
->type
= JS_EVENT_AXIS
| JS_EVENT_INIT
;
300 event
->number
= client
->startup
- joydev
->nkey
;
301 event
->value
= joydev
->abs
[event
->number
];
306 spin_unlock_irq(&client
->buffer_lock
);
311 static int joydev_fetch_next_event(struct joydev_client
*client
,
312 struct js_event
*event
)
316 spin_lock_irq(&client
->buffer_lock
);
318 have_event
= client
->head
!= client
->tail
;
320 *event
= client
->buffer
[client
->tail
++];
321 client
->tail
&= JOYDEV_BUFFER_SIZE
- 1;
324 spin_unlock_irq(&client
->buffer_lock
);
330 * Old joystick interface
332 static ssize_t
joydev_0x_read(struct joydev_client
*client
,
333 struct input_dev
*input
,
336 struct joydev
*joydev
= client
->joydev
;
337 struct JS_DATA_TYPE data
;
340 spin_lock_irq(&input
->event_lock
);
345 for (data
.buttons
= i
= 0; i
< 32 && i
< joydev
->nkey
; i
++)
347 test_bit(joydev
->keypam
[i
], input
->key
) ? (1 << i
) : 0;
348 data
.x
= (joydev
->abs
[0] / 256 + 128) >> joydev
->glue
.JS_CORR
.x
;
349 data
.y
= (joydev
->abs
[1] / 256 + 128) >> joydev
->glue
.JS_CORR
.y
;
352 * Reset reader's event queue
354 spin_lock(&client
->buffer_lock
);
356 client
->tail
= client
->head
;
357 spin_unlock(&client
->buffer_lock
);
359 spin_unlock_irq(&input
->event_lock
);
361 if (copy_to_user(buf
, &data
, sizeof(struct JS_DATA_TYPE
)))
364 return sizeof(struct JS_DATA_TYPE
);
367 static inline int joydev_data_pending(struct joydev_client
*client
)
369 struct joydev
*joydev
= client
->joydev
;
371 return client
->startup
< joydev
->nabs
+ joydev
->nkey
||
372 client
->head
!= client
->tail
;
375 static ssize_t
joydev_read(struct file
*file
, char __user
*buf
,
376 size_t count
, loff_t
*ppos
)
378 struct joydev_client
*client
= file
->private_data
;
379 struct joydev
*joydev
= client
->joydev
;
380 struct input_dev
*input
= joydev
->handle
.dev
;
381 struct js_event event
;
387 if (count
< sizeof(struct js_event
))
390 if (count
== sizeof(struct JS_DATA_TYPE
))
391 return joydev_0x_read(client
, input
, buf
);
393 if (!joydev_data_pending(client
) && (file
->f_flags
& O_NONBLOCK
))
396 retval
= wait_event_interruptible(joydev
->wait
,
397 !joydev
->exist
|| joydev_data_pending(client
));
404 while (retval
+ sizeof(struct js_event
) <= count
&&
405 joydev_generate_startup_event(client
, input
, &event
)) {
407 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
410 retval
+= sizeof(struct js_event
);
413 while (retval
+ sizeof(struct js_event
) <= count
&&
414 joydev_fetch_next_event(client
, &event
)) {
416 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
419 retval
+= sizeof(struct js_event
);
425 /* No kernel lock - fine */
426 static unsigned int joydev_poll(struct file
*file
, poll_table
*wait
)
428 struct joydev_client
*client
= file
->private_data
;
429 struct joydev
*joydev
= client
->joydev
;
431 poll_wait(file
, &joydev
->wait
, wait
);
432 return (joydev_data_pending(client
) ? (POLLIN
| POLLRDNORM
) : 0) |
433 (joydev
->exist
? 0 : (POLLHUP
| POLLERR
));
436 static int joydev_handle_JSIOCSAXMAP(struct joydev
*joydev
,
437 void __user
*argp
, size_t len
)
443 len
= min(len
, sizeof(joydev
->abspam
));
445 /* Validate the map. */
446 abspam
= memdup_user(argp
, len
);
448 return PTR_ERR(abspam
);
450 for (i
= 0; i
< joydev
->nabs
; i
++) {
451 if (abspam
[i
] > ABS_MAX
) {
457 memcpy(joydev
->abspam
, abspam
, len
);
459 for (i
= 0; i
< joydev
->nabs
; i
++)
460 joydev
->absmap
[joydev
->abspam
[i
]] = i
;
467 static int joydev_handle_JSIOCSBTNMAP(struct joydev
*joydev
,
468 void __user
*argp
, size_t len
)
474 len
= min(len
, sizeof(joydev
->keypam
));
476 /* Validate the map. */
477 keypam
= memdup_user(argp
, len
);
479 return PTR_ERR(keypam
);
481 for (i
= 0; i
< joydev
->nkey
; i
++) {
482 if (keypam
[i
] > KEY_MAX
|| keypam
[i
] < BTN_MISC
) {
488 memcpy(joydev
->keypam
, keypam
, len
);
490 for (i
= 0; i
< joydev
->nkey
; i
++)
491 joydev
->keymap
[keypam
[i
] - BTN_MISC
] = i
;
499 static int joydev_ioctl_common(struct joydev
*joydev
,
500 unsigned int cmd
, void __user
*argp
)
502 struct input_dev
*dev
= joydev
->handle
.dev
;
507 /* Process fixed-sized commands. */
511 return copy_from_user(&joydev
->glue
.JS_CORR
, argp
,
512 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
515 return copy_to_user(argp
, &joydev
->glue
.JS_CORR
,
516 sizeof(joydev
->glue
.JS_CORR
)) ? -EFAULT
: 0;
519 return get_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
522 return put_user(joydev
->glue
.JS_TIMEOUT
, (s32 __user
*) argp
);
525 return put_user(JS_VERSION
, (__u32 __user
*) argp
);
528 return put_user(joydev
->nabs
, (__u8 __user
*) argp
);
531 return put_user(joydev
->nkey
, (__u8 __user
*) argp
);
534 if (copy_from_user(joydev
->corr
, argp
,
535 sizeof(joydev
->corr
[0]) * joydev
->nabs
))
538 for (i
= 0; i
< joydev
->nabs
; i
++) {
539 int val
= input_abs_get_val(dev
, joydev
->abspam
[i
]);
540 joydev
->abs
[i
] = joydev_correct(val
, &joydev
->corr
[i
]);
545 return copy_to_user(argp
, joydev
->corr
,
546 sizeof(joydev
->corr
[0]) * joydev
->nabs
) ? -EFAULT
: 0;
551 * Process variable-sized commands (the axis and button map commands
552 * are considered variable-sized to decouple them from the values of
553 * ABS_MAX and KEY_MAX).
555 switch (cmd
& ~IOCSIZE_MASK
) {
557 case (JSIOCSAXMAP
& ~IOCSIZE_MASK
):
558 return joydev_handle_JSIOCSAXMAP(joydev
, argp
, _IOC_SIZE(cmd
));
560 case (JSIOCGAXMAP
& ~IOCSIZE_MASK
):
561 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->abspam
));
562 return copy_to_user(argp
, joydev
->abspam
, len
) ? -EFAULT
: len
;
564 case (JSIOCSBTNMAP
& ~IOCSIZE_MASK
):
565 return joydev_handle_JSIOCSBTNMAP(joydev
, argp
, _IOC_SIZE(cmd
));
567 case (JSIOCGBTNMAP
& ~IOCSIZE_MASK
):
568 len
= min_t(size_t, _IOC_SIZE(cmd
), sizeof(joydev
->keypam
));
569 return copy_to_user(argp
, joydev
->keypam
, len
) ? -EFAULT
: len
;
576 len
= min_t(size_t, _IOC_SIZE(cmd
), strlen(name
) + 1);
577 return copy_to_user(argp
, name
, len
) ? -EFAULT
: len
;
584 static long joydev_compat_ioctl(struct file
*file
,
585 unsigned int cmd
, unsigned long arg
)
587 struct joydev_client
*client
= file
->private_data
;
588 struct joydev
*joydev
= client
->joydev
;
589 void __user
*argp
= (void __user
*)arg
;
591 struct JS_DATA_SAVE_TYPE_32 ds32
;
594 retval
= mutex_lock_interruptible(&joydev
->mutex
);
598 if (!joydev
->exist
) {
605 case JS_SET_TIMELIMIT
:
606 retval
= get_user(tmp32
, (s32 __user
*) arg
);
608 joydev
->glue
.JS_TIMELIMIT
= tmp32
;
611 case JS_GET_TIMELIMIT
:
612 tmp32
= joydev
->glue
.JS_TIMELIMIT
;
613 retval
= put_user(tmp32
, (s32 __user
*) arg
);
617 retval
= copy_from_user(&ds32
, argp
,
618 sizeof(ds32
)) ? -EFAULT
: 0;
620 joydev
->glue
.JS_TIMEOUT
= ds32
.JS_TIMEOUT
;
621 joydev
->glue
.BUSY
= ds32
.BUSY
;
622 joydev
->glue
.JS_EXPIRETIME
= ds32
.JS_EXPIRETIME
;
623 joydev
->glue
.JS_TIMELIMIT
= ds32
.JS_TIMELIMIT
;
624 joydev
->glue
.JS_SAVE
= ds32
.JS_SAVE
;
625 joydev
->glue
.JS_CORR
= ds32
.JS_CORR
;
630 ds32
.JS_TIMEOUT
= joydev
->glue
.JS_TIMEOUT
;
631 ds32
.BUSY
= joydev
->glue
.BUSY
;
632 ds32
.JS_EXPIRETIME
= joydev
->glue
.JS_EXPIRETIME
;
633 ds32
.JS_TIMELIMIT
= joydev
->glue
.JS_TIMELIMIT
;
634 ds32
.JS_SAVE
= joydev
->glue
.JS_SAVE
;
635 ds32
.JS_CORR
= joydev
->glue
.JS_CORR
;
637 retval
= copy_to_user(argp
, &ds32
, sizeof(ds32
)) ? -EFAULT
: 0;
641 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
646 mutex_unlock(&joydev
->mutex
);
649 #endif /* CONFIG_COMPAT */
651 static long joydev_ioctl(struct file
*file
,
652 unsigned int cmd
, unsigned long arg
)
654 struct joydev_client
*client
= file
->private_data
;
655 struct joydev
*joydev
= client
->joydev
;
656 void __user
*argp
= (void __user
*)arg
;
659 retval
= mutex_lock_interruptible(&joydev
->mutex
);
663 if (!joydev
->exist
) {
670 case JS_SET_TIMELIMIT
:
671 retval
= get_user(joydev
->glue
.JS_TIMELIMIT
,
672 (long __user
*) arg
);
675 case JS_GET_TIMELIMIT
:
676 retval
= put_user(joydev
->glue
.JS_TIMELIMIT
,
677 (long __user
*) arg
);
681 retval
= copy_from_user(&joydev
->glue
, argp
,
682 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
686 retval
= copy_to_user(argp
, &joydev
->glue
,
687 sizeof(joydev
->glue
)) ? -EFAULT
: 0;
691 retval
= joydev_ioctl_common(joydev
, cmd
, argp
);
695 mutex_unlock(&joydev
->mutex
);
699 static const struct file_operations joydev_fops
= {
700 .owner
= THIS_MODULE
,
704 .release
= joydev_release
,
705 .unlocked_ioctl
= joydev_ioctl
,
707 .compat_ioctl
= joydev_compat_ioctl
,
709 .fasync
= joydev_fasync
,
714 * Mark device non-existent. This disables writes, ioctls and
715 * prevents new users from opening the device. Already posted
716 * blocking reads will stay, however new ones will fail.
718 static void joydev_mark_dead(struct joydev
*joydev
)
720 mutex_lock(&joydev
->mutex
);
721 joydev
->exist
= false;
722 mutex_unlock(&joydev
->mutex
);
725 static void joydev_cleanup(struct joydev
*joydev
)
727 struct input_handle
*handle
= &joydev
->handle
;
729 joydev_mark_dead(joydev
);
730 joydev_hangup(joydev
);
732 cdev_del(&joydev
->cdev
);
734 /* joydev is marked dead so no one else accesses joydev->open */
736 input_close_device(handle
);
739 static bool joydev_dev_is_absolute_mouse(struct input_dev
*dev
)
741 DECLARE_BITMAP(jd_scratch
, KEY_CNT
);
743 BUILD_BUG_ON(ABS_CNT
> KEY_CNT
|| EV_CNT
> KEY_CNT
);
746 * Virtualization (VMware, etc) and remote management (HP
747 * ILO2) solutions use absolute coordinates for their virtual
748 * pointing devices so that there is one-to-one relationship
749 * between pointer position on the host screen and virtual
750 * guest screen, and so their mice use ABS_X, ABS_Y and 3
751 * primary button events. This clashes with what joydev
752 * considers to be joysticks (a device with at minimum ABS_X
755 * Here we are trying to separate absolute mice from
756 * joysticks. A device is, for joystick detection purposes,
757 * considered to be an absolute mouse if the following is
760 * 1) Event types are exactly EV_ABS, EV_KEY and EV_SYN.
761 * 2) Absolute events are exactly ABS_X and ABS_Y.
762 * 3) Keys are exactly BTN_LEFT, BTN_RIGHT and BTN_MIDDLE.
763 * 4) Device is not on "Amiga" bus.
766 bitmap_zero(jd_scratch
, EV_CNT
);
767 __set_bit(EV_ABS
, jd_scratch
);
768 __set_bit(EV_KEY
, jd_scratch
);
769 __set_bit(EV_SYN
, jd_scratch
);
770 if (!bitmap_equal(jd_scratch
, dev
->evbit
, EV_CNT
))
773 bitmap_zero(jd_scratch
, ABS_CNT
);
774 __set_bit(ABS_X
, jd_scratch
);
775 __set_bit(ABS_Y
, jd_scratch
);
776 if (!bitmap_equal(dev
->absbit
, jd_scratch
, ABS_CNT
))
779 bitmap_zero(jd_scratch
, KEY_CNT
);
780 __set_bit(BTN_LEFT
, jd_scratch
);
781 __set_bit(BTN_RIGHT
, jd_scratch
);
782 __set_bit(BTN_MIDDLE
, jd_scratch
);
784 if (!bitmap_equal(dev
->keybit
, jd_scratch
, KEY_CNT
))
788 * Amiga joystick (amijoy) historically uses left/middle/right
791 if (dev
->id
.bustype
== BUS_AMIGA
)
797 static bool joydev_match(struct input_handler
*handler
, struct input_dev
*dev
)
799 /* Avoid touchpads and touchscreens */
800 if (test_bit(EV_KEY
, dev
->evbit
) && test_bit(BTN_TOUCH
, dev
->keybit
))
803 /* Avoid tablets, digitisers and similar devices */
804 if (test_bit(EV_KEY
, dev
->evbit
) && test_bit(BTN_DIGI
, dev
->keybit
))
807 /* Avoid absolute mice */
808 if (joydev_dev_is_absolute_mouse(dev
))
814 static int joydev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
815 const struct input_device_id
*id
)
817 struct joydev
*joydev
;
818 int i
, j
, t
, minor
, dev_no
;
821 minor
= input_get_new_minor(JOYDEV_MINOR_BASE
, JOYDEV_MINORS
, true);
824 pr_err("failed to reserve new minor: %d\n", error
);
828 joydev
= kzalloc(sizeof(struct joydev
), GFP_KERNEL
);
834 INIT_LIST_HEAD(&joydev
->client_list
);
835 spin_lock_init(&joydev
->client_lock
);
836 mutex_init(&joydev
->mutex
);
837 init_waitqueue_head(&joydev
->wait
);
838 joydev
->exist
= true;
841 /* Normalize device number if it falls into legacy range */
842 if (dev_no
< JOYDEV_MINOR_BASE
+ JOYDEV_MINORS
)
843 dev_no
-= JOYDEV_MINOR_BASE
;
844 dev_set_name(&joydev
->dev
, "js%d", dev_no
);
846 joydev
->handle
.dev
= input_get_device(dev
);
847 joydev
->handle
.name
= dev_name(&joydev
->dev
);
848 joydev
->handle
.handler
= handler
;
849 joydev
->handle
.private = joydev
;
851 for_each_set_bit(i
, dev
->absbit
, ABS_CNT
) {
852 joydev
->absmap
[i
] = joydev
->nabs
;
853 joydev
->abspam
[joydev
->nabs
] = i
;
857 for (i
= BTN_JOYSTICK
- BTN_MISC
; i
< KEY_MAX
- BTN_MISC
+ 1; i
++)
858 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
859 joydev
->keymap
[i
] = joydev
->nkey
;
860 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
864 for (i
= 0; i
< BTN_JOYSTICK
- BTN_MISC
; i
++)
865 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
866 joydev
->keymap
[i
] = joydev
->nkey
;
867 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
871 for (i
= 0; i
< joydev
->nabs
; i
++) {
872 j
= joydev
->abspam
[i
];
873 if (input_abs_get_max(dev
, j
) == input_abs_get_min(dev
, j
)) {
874 joydev
->corr
[i
].type
= JS_CORR_NONE
;
875 joydev
->abs
[i
] = input_abs_get_val(dev
, j
);
878 joydev
->corr
[i
].type
= JS_CORR_BROKEN
;
879 joydev
->corr
[i
].prec
= input_abs_get_fuzz(dev
, j
);
881 t
= (input_abs_get_max(dev
, j
) + input_abs_get_min(dev
, j
)) / 2;
882 joydev
->corr
[i
].coef
[0] = t
- input_abs_get_flat(dev
, j
);
883 joydev
->corr
[i
].coef
[1] = t
+ input_abs_get_flat(dev
, j
);
885 t
= (input_abs_get_max(dev
, j
) - input_abs_get_min(dev
, j
)) / 2
886 - 2 * input_abs_get_flat(dev
, j
);
888 joydev
->corr
[i
].coef
[2] = (1 << 29) / t
;
889 joydev
->corr
[i
].coef
[3] = (1 << 29) / t
;
892 joydev_correct(input_abs_get_val(dev
, j
),
897 joydev
->dev
.devt
= MKDEV(INPUT_MAJOR
, minor
);
898 joydev
->dev
.class = &input_class
;
899 joydev
->dev
.parent
= &dev
->dev
;
900 joydev
->dev
.release
= joydev_free
;
901 device_initialize(&joydev
->dev
);
903 error
= input_register_handle(&joydev
->handle
);
905 goto err_free_joydev
;
907 cdev_init(&joydev
->cdev
, &joydev_fops
);
908 joydev
->cdev
.kobj
.parent
= &joydev
->dev
.kobj
;
909 error
= cdev_add(&joydev
->cdev
, joydev
->dev
.devt
, 1);
911 goto err_unregister_handle
;
913 error
= device_add(&joydev
->dev
);
915 goto err_cleanup_joydev
;
920 joydev_cleanup(joydev
);
921 err_unregister_handle
:
922 input_unregister_handle(&joydev
->handle
);
924 put_device(&joydev
->dev
);
926 input_free_minor(minor
);
930 static void joydev_disconnect(struct input_handle
*handle
)
932 struct joydev
*joydev
= handle
->private;
934 device_del(&joydev
->dev
);
935 joydev_cleanup(joydev
);
936 input_free_minor(MINOR(joydev
->dev
.devt
));
937 input_unregister_handle(handle
);
938 put_device(&joydev
->dev
);
941 static const struct input_device_id joydev_ids
[] = {
943 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
944 INPUT_DEVICE_ID_MATCH_ABSBIT
,
945 .evbit
= { BIT_MASK(EV_ABS
) },
946 .absbit
= { BIT_MASK(ABS_X
) },
949 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
950 INPUT_DEVICE_ID_MATCH_ABSBIT
,
951 .evbit
= { BIT_MASK(EV_ABS
) },
952 .absbit
= { BIT_MASK(ABS_Z
) },
955 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
956 INPUT_DEVICE_ID_MATCH_ABSBIT
,
957 .evbit
= { BIT_MASK(EV_ABS
) },
958 .absbit
= { BIT_MASK(ABS_WHEEL
) },
961 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
962 INPUT_DEVICE_ID_MATCH_ABSBIT
,
963 .evbit
= { BIT_MASK(EV_ABS
) },
964 .absbit
= { BIT_MASK(ABS_THROTTLE
) },
967 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
968 INPUT_DEVICE_ID_MATCH_KEYBIT
,
969 .evbit
= { BIT_MASK(EV_KEY
) },
970 .keybit
= {[BIT_WORD(BTN_JOYSTICK
)] = BIT_MASK(BTN_JOYSTICK
) },
973 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
974 INPUT_DEVICE_ID_MATCH_KEYBIT
,
975 .evbit
= { BIT_MASK(EV_KEY
) },
976 .keybit
= { [BIT_WORD(BTN_GAMEPAD
)] = BIT_MASK(BTN_GAMEPAD
) },
979 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
980 INPUT_DEVICE_ID_MATCH_KEYBIT
,
981 .evbit
= { BIT_MASK(EV_KEY
) },
982 .keybit
= { [BIT_WORD(BTN_TRIGGER_HAPPY
)] = BIT_MASK(BTN_TRIGGER_HAPPY
) },
984 { } /* Terminating entry */
987 MODULE_DEVICE_TABLE(input
, joydev_ids
);
989 static struct input_handler joydev_handler
= {
990 .event
= joydev_event
,
991 .match
= joydev_match
,
992 .connect
= joydev_connect
,
993 .disconnect
= joydev_disconnect
,
994 .legacy_minors
= true,
995 .minor
= JOYDEV_MINOR_BASE
,
997 .id_table
= joydev_ids
,
1000 static int __init
joydev_init(void)
1002 return input_register_handler(&joydev_handler
);
1005 static void __exit
joydev_exit(void)
1007 input_unregister_handler(&joydev_handler
);
1010 module_init(joydev_init
);
1011 module_exit(joydev_exit
);