1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Joystick device driver for the input driver suite.
5 * Copyright (c) 1999-2002 Vojtech Pavlik
6 * Copyright (c) 1999 Colin Van Dyke
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/delay.h>
13 #include <linux/errno.h>
14 #include <linux/joystick.h>
15 #include <linux/input.h>
16 #include <linux/kernel.h>
17 #include <linux/major.h>
18 #include <linux/sched.h>
19 #include <linux/slab.h>
21 #include <linux/module.h>
22 #include <linux/poll.h>
23 #include <linux/init.h>
24 #include <linux/device.h>
25 #include <linux/cdev.h>
27 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
28 MODULE_DESCRIPTION("Joystick device interfaces");
29 MODULE_LICENSE("GPL");
31 #define JOYDEV_MINOR_BASE 0
32 #define JOYDEV_MINORS 16
33 #define JOYDEV_BUFFER_SIZE 64
37 struct input_handle handle
;
38 wait_queue_head_t wait
;
39 struct list_head client_list
;
40 spinlock_t client_lock
; /* protects client_list */
46 struct js_corr corr
[ABS_CNT
];
47 struct JS_DATA_SAVE_TYPE glue
;
50 __u16 keymap
[KEY_MAX
- BTN_MISC
+ 1];
51 __u16 keypam
[KEY_MAX
- BTN_MISC
+ 1];
57 struct joydev_client
{
58 struct js_event buffer
[JOYDEV_BUFFER_SIZE
];
62 spinlock_t buffer_lock
; /* protects access to buffer, head and tail */
63 struct fasync_struct
*fasync
;
64 struct joydev
*joydev
;
65 struct list_head node
;
68 static int joydev_correct(int value
, struct js_corr
*corr
)
76 value
= value
> corr
->coef
[0] ? (value
< corr
->coef
[1] ? 0 :
77 ((corr
->coef
[3] * (value
- corr
->coef
[1])) >> 14)) :
78 ((corr
->coef
[2] * (value
- corr
->coef
[0])) >> 14);
85 return clamp(value
, -32767, 32767);
88 static void joydev_pass_event(struct joydev_client
*client
,
89 struct js_event
*event
)
91 struct joydev
*joydev
= client
->joydev
;
94 * IRQs already disabled, just acquire the lock
96 spin_lock(&client
->buffer_lock
);
98 client
->buffer
[client
->head
] = *event
;
100 if (client
->startup
== joydev
->nabs
+ joydev
->nkey
) {
102 client
->head
&= JOYDEV_BUFFER_SIZE
- 1;
103 if (client
->tail
== client
->head
)
107 spin_unlock(&client
->buffer_lock
);
109 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
112 static void joydev_event(struct input_handle
*handle
,
113 unsigned int type
, unsigned int code
, int value
)
115 struct joydev
*joydev
= handle
->private;
116 struct joydev_client
*client
;
117 struct js_event event
;
122 if (code
< BTN_MISC
|| value
== 2)
124 event
.type
= JS_EVENT_BUTTON
;
125 event
.number
= joydev
->keymap
[code
- BTN_MISC
];
130 event
.type
= JS_EVENT_AXIS
;
131 event
.number
= joydev
->absmap
[code
];
132 event
.value
= joydev_correct(value
,
133 &joydev
->corr
[event
.number
]);
134 if (event
.value
== joydev
->abs
[event
.number
])
136 joydev
->abs
[event
.number
] = event
.value
;
143 event
.time
= jiffies_to_msecs(jiffies
);
146 list_for_each_entry_rcu(client
, &joydev
->client_list
, node
)
147 joydev_pass_event(client
, &event
);
150 wake_up_interruptible(&joydev
->wait
);
153 static int joydev_fasync(int fd
, struct file
*file
, int on
)
155 struct joydev_client
*client
= file
->private_data
;
157 return fasync_helper(fd
, file
, on
, &client
->fasync
);
160 static void joydev_free(struct device
*dev
)
162 struct joydev
*joydev
= container_of(dev
, struct joydev
, dev
);
164 input_put_device(joydev
->handle
.dev
);
168 static void joydev_attach_client(struct joydev
*joydev
,
169 struct joydev_client
*client
)
171 spin_lock(&joydev
->client_lock
);
172 list_add_tail_rcu(&client
->node
, &joydev
->client_list
);
173 spin_unlock(&joydev
->client_lock
);
176 static void joydev_detach_client(struct joydev
*joydev
,
177 struct joydev_client
*client
)
179 spin_lock(&joydev
->client_lock
);
180 list_del_rcu(&client
->node
);
181 spin_unlock(&joydev
->client_lock
);
185 static void joydev_refresh_state(struct joydev
*joydev
)
187 struct input_dev
*dev
= joydev
->handle
.dev
;
190 for (i
= 0; i
< joydev
->nabs
; i
++) {
191 val
= input_abs_get_val(dev
, joydev
->abspam
[i
]);
192 joydev
->abs
[i
] = joydev_correct(val
, &joydev
->corr
[i
]);
196 static int joydev_open_device(struct joydev
*joydev
)
200 retval
= mutex_lock_interruptible(&joydev
->mutex
);
206 else if (!joydev
->open
++) {
207 retval
= input_open_device(&joydev
->handle
);
211 joydev_refresh_state(joydev
);
214 mutex_unlock(&joydev
->mutex
);
218 static void joydev_close_device(struct joydev
*joydev
)
220 mutex_lock(&joydev
->mutex
);
222 if (joydev
->exist
&& !--joydev
->open
)
223 input_close_device(&joydev
->handle
);
225 mutex_unlock(&joydev
->mutex
);
229 * Wake up users waiting for IO so they can disconnect from
232 static void joydev_hangup(struct joydev
*joydev
)
234 struct joydev_client
*client
;
236 spin_lock(&joydev
->client_lock
);
237 list_for_each_entry(client
, &joydev
->client_list
, node
)
238 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
239 spin_unlock(&joydev
->client_lock
);
241 wake_up_interruptible(&joydev
->wait
);
244 static int joydev_release(struct inode
*inode
, struct file
*file
)
246 struct joydev_client
*client
= file
->private_data
;
247 struct joydev
*joydev
= client
->joydev
;
249 joydev_detach_client(joydev
, client
);
252 joydev_close_device(joydev
);
257 static int joydev_open(struct inode
*inode
, struct file
*file
)
259 struct joydev
*joydev
=
260 container_of(inode
->i_cdev
, struct joydev
, cdev
);
261 struct joydev_client
*client
;
264 client
= kzalloc(sizeof(struct joydev_client
), GFP_KERNEL
);
268 spin_lock_init(&client
->buffer_lock
);
269 client
->joydev
= joydev
;
270 joydev_attach_client(joydev
, client
);
272 error
= joydev_open_device(joydev
);
274 goto err_free_client
;
276 file
->private_data
= client
;
277 stream_open(inode
, file
);
282 joydev_detach_client(joydev
, client
);
287 static int joydev_generate_startup_event(struct joydev_client
*client
,
288 struct input_dev
*input
,
289 struct js_event
*event
)
291 struct joydev
*joydev
= client
->joydev
;
294 spin_lock_irq(&client
->buffer_lock
);
296 have_event
= client
->startup
< joydev
->nabs
+ joydev
->nkey
;
300 event
->time
= jiffies_to_msecs(jiffies
);
301 if (client
->startup
< joydev
->nkey
) {
302 event
->type
= JS_EVENT_BUTTON
| JS_EVENT_INIT
;
303 event
->number
= client
->startup
;
304 event
->value
= !!test_bit(joydev
->keypam
[event
->number
],
307 event
->type
= JS_EVENT_AXIS
| JS_EVENT_INIT
;
308 event
->number
= client
->startup
- joydev
->nkey
;
309 event
->value
= joydev
->abs
[event
->number
];
314 spin_unlock_irq(&client
->buffer_lock
);
319 static int joydev_fetch_next_event(struct joydev_client
*client
,
320 struct js_event
*event
)
324 spin_lock_irq(&client
->buffer_lock
);
326 have_event
= client
->head
!= client
->tail
;
328 *event
= client
->buffer
[client
->tail
++];
329 client
->tail
&= JOYDEV_BUFFER_SIZE
- 1;
332 spin_unlock_irq(&client
->buffer_lock
);
338 * Old joystick interface
340 static ssize_t
joydev_0x_read(struct joydev_client
*client
,
341 struct input_dev
*input
,
344 struct joydev
*joydev
= client
->joydev
;
345 struct JS_DATA_TYPE data
;
348 spin_lock_irq(&input
->event_lock
);
353 for (data
.buttons
= i
= 0; i
< 32 && i
< joydev
->nkey
; i
++)
355 test_bit(joydev
->keypam
[i
], input
->key
) ? (1 << i
) : 0;
356 data
.x
= (joydev
->abs
[0] / 256 + 128) >> joydev
->glue
.JS_CORR
.x
;
357 data
.y
= (joydev
->abs
[1] / 256 + 128) >> joydev
->glue
.JS_CORR
.y
;
360 * Reset reader's event queue
362 spin_lock(&client
->buffer_lock
);
364 client
->tail
= client
->head
;
365 spin_unlock(&client
->buffer_lock
);
367 spin_unlock_irq(&input
->event_lock
);
369 if (copy_to_user(buf
, &data
, sizeof(struct JS_DATA_TYPE
)))
372 return sizeof(struct JS_DATA_TYPE
);
375 static inline int joydev_data_pending(struct joydev_client
*client
)
377 struct joydev
*joydev
= client
->joydev
;
379 return client
->startup
< joydev
->nabs
+ joydev
->nkey
||
380 client
->head
!= client
->tail
;
383 static ssize_t
joydev_read(struct file
*file
, char __user
*buf
,
384 size_t count
, loff_t
*ppos
)
386 struct joydev_client
*client
= file
->private_data
;
387 struct joydev
*joydev
= client
->joydev
;
388 struct input_dev
*input
= joydev
->handle
.dev
;
389 struct js_event event
;
395 if (count
< sizeof(struct js_event
))
398 if (count
== sizeof(struct JS_DATA_TYPE
))
399 return joydev_0x_read(client
, input
, buf
);
401 if (!joydev_data_pending(client
) && (file
->f_flags
& O_NONBLOCK
))
404 retval
= wait_event_interruptible(joydev
->wait
,
405 !joydev
->exist
|| joydev_data_pending(client
));
412 while (retval
+ sizeof(struct js_event
) <= count
&&
413 joydev_generate_startup_event(client
, input
, &event
)) {
415 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
418 retval
+= sizeof(struct js_event
);
421 while (retval
+ sizeof(struct js_event
) <= count
&&
422 joydev_fetch_next_event(client
, &event
)) {
424 if (copy_to_user(buf
+ retval
, &event
, sizeof(struct js_event
)))
427 retval
+= sizeof(struct js_event
);
433 /* No kernel lock - fine */
434 static __poll_t
joydev_poll(struct file
*file
, poll_table
*wait
)
436 struct joydev_client
*client
= file
->private_data
;
437 struct joydev
*joydev
= client
->joydev
;
439 poll_wait(file
, &joydev
->wait
, wait
);
440 return (joydev_data_pending(client
) ? (EPOLLIN
| EPOLLRDNORM
) : 0) |
441 (joydev
->exist
? 0 : (EPOLLHUP
| EPOLLERR
));
444 static int joydev_handle_JSIOCSAXMAP(struct joydev
*joydev
,
445 void __user
*argp
, size_t len
)
451 len
= min(len
, sizeof(joydev
->abspam
));
453 /* Validate the map. */
454 abspam
= memdup_user(argp
, len
);
456 return PTR_ERR(abspam
);
458 for (i
= 0; i
< len
&& i
< joydev
->nabs
; i
++) {
459 if (abspam
[i
] > ABS_MAX
) {
465 memcpy(joydev
->abspam
, abspam
, len
);
467 for (i
= 0; i
< joydev
->nabs
; i
++)
468 joydev
->absmap
[joydev
->abspam
[i
]] = i
;
475 static int joydev_handle_JSIOCSBTNMAP(struct joydev
*joydev
,
476 void __user
*argp
, size_t len
)
482 if (len
% sizeof(*keypam
))
485 len
= min(len
, sizeof(joydev
->keypam
));
487 /* Validate the map. */
488 keypam
= memdup_user(argp
, len
);
490 return PTR_ERR(keypam
);
492 for (i
= 0; i
< (len
/ 2) && 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
[joydev
->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 /* joydev is marked dead so no one else accesses joydev->open */
745 input_close_device(handle
);
749 * These codes are copied from from hid-ids.h, unfortunately there is no common
750 * usb_ids/bt_ids.h header.
752 #define USB_VENDOR_ID_SONY 0x054c
753 #define USB_DEVICE_ID_SONY_PS3_CONTROLLER 0x0268
754 #define USB_DEVICE_ID_SONY_PS4_CONTROLLER 0x05c4
755 #define USB_DEVICE_ID_SONY_PS4_CONTROLLER_2 0x09cc
756 #define USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE 0x0ba0
758 #define USB_VENDOR_ID_THQ 0x20d6
759 #define USB_DEVICE_ID_THQ_PS3_UDRAW 0xcb17
761 #define ACCEL_DEV(vnd, prd) \
763 .flags = INPUT_DEVICE_ID_MATCH_VENDOR | \
764 INPUT_DEVICE_ID_MATCH_PRODUCT | \
765 INPUT_DEVICE_ID_MATCH_PROPBIT, \
768 .propbit = { BIT_MASK(INPUT_PROP_ACCELEROMETER) }, \
771 static const struct input_device_id joydev_blacklist
[] = {
772 /* Avoid touchpads and touchscreens */
774 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
775 INPUT_DEVICE_ID_MATCH_KEYBIT
,
776 .evbit
= { BIT_MASK(EV_KEY
) },
777 .keybit
= { [BIT_WORD(BTN_TOUCH
)] = BIT_MASK(BTN_TOUCH
) },
779 /* Avoid tablets, digitisers and similar devices */
781 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
782 INPUT_DEVICE_ID_MATCH_KEYBIT
,
783 .evbit
= { BIT_MASK(EV_KEY
) },
784 .keybit
= { [BIT_WORD(BTN_DIGI
)] = BIT_MASK(BTN_DIGI
) },
786 /* Disable accelerometers on composite devices */
787 ACCEL_DEV(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS3_CONTROLLER
),
788 ACCEL_DEV(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER
),
789 ACCEL_DEV(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2
),
790 ACCEL_DEV(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE
),
791 ACCEL_DEV(USB_VENDOR_ID_THQ
, USB_DEVICE_ID_THQ_PS3_UDRAW
),
795 static bool joydev_dev_is_blacklisted(struct input_dev
*dev
)
797 const struct input_device_id
*id
;
799 for (id
= joydev_blacklist
; id
->flags
; id
++) {
800 if (input_match_device_id(dev
, id
)) {
802 "joydev: blacklisting '%s'\n", dev
->name
);
810 static bool joydev_dev_is_absolute_mouse(struct input_dev
*dev
)
812 DECLARE_BITMAP(jd_scratch
, KEY_CNT
);
813 bool ev_match
= false;
815 BUILD_BUG_ON(ABS_CNT
> KEY_CNT
|| EV_CNT
> KEY_CNT
);
818 * Virtualization (VMware, etc) and remote management (HP
819 * ILO2) solutions use absolute coordinates for their virtual
820 * pointing devices so that there is one-to-one relationship
821 * between pointer position on the host screen and virtual
822 * guest screen, and so their mice use ABS_X, ABS_Y and 3
823 * primary button events. This clashes with what joydev
824 * considers to be joysticks (a device with at minimum ABS_X
827 * Here we are trying to separate absolute mice from
828 * joysticks. A device is, for joystick detection purposes,
829 * considered to be an absolute mouse if the following is
832 * 1) Event types are exactly
833 * EV_ABS, EV_KEY and EV_SYN
835 * EV_ABS, EV_KEY, EV_SYN and EV_MSC
837 * EV_ABS, EV_KEY, EV_SYN, EV_MSC and EV_REL.
838 * 2) Absolute events are exactly ABS_X and ABS_Y.
839 * 3) Keys are exactly BTN_LEFT, BTN_RIGHT and BTN_MIDDLE.
840 * 4) Device is not on "Amiga" bus.
843 bitmap_zero(jd_scratch
, EV_CNT
);
844 /* VMware VMMouse, HP ILO2 */
845 __set_bit(EV_ABS
, jd_scratch
);
846 __set_bit(EV_KEY
, jd_scratch
);
847 __set_bit(EV_SYN
, jd_scratch
);
848 if (bitmap_equal(jd_scratch
, dev
->evbit
, EV_CNT
))
851 /* HP ILO2, AMI BMC firmware */
852 __set_bit(EV_MSC
, jd_scratch
);
853 if (bitmap_equal(jd_scratch
, dev
->evbit
, EV_CNT
))
856 /* VMware Virtual USB Mouse, QEMU USB Tablet, ATEN BMC firmware */
857 __set_bit(EV_REL
, jd_scratch
);
858 if (bitmap_equal(jd_scratch
, dev
->evbit
, EV_CNT
))
864 bitmap_zero(jd_scratch
, ABS_CNT
);
865 __set_bit(ABS_X
, jd_scratch
);
866 __set_bit(ABS_Y
, jd_scratch
);
867 if (!bitmap_equal(dev
->absbit
, jd_scratch
, ABS_CNT
))
870 bitmap_zero(jd_scratch
, KEY_CNT
);
871 __set_bit(BTN_LEFT
, jd_scratch
);
872 __set_bit(BTN_RIGHT
, jd_scratch
);
873 __set_bit(BTN_MIDDLE
, jd_scratch
);
875 if (!bitmap_equal(dev
->keybit
, jd_scratch
, KEY_CNT
))
879 * Amiga joystick (amijoy) historically uses left/middle/right
882 if (dev
->id
.bustype
== BUS_AMIGA
)
888 static bool joydev_match(struct input_handler
*handler
, struct input_dev
*dev
)
890 /* Disable blacklisted devices */
891 if (joydev_dev_is_blacklisted(dev
))
894 /* Avoid absolute mice */
895 if (joydev_dev_is_absolute_mouse(dev
))
901 static int joydev_connect(struct input_handler
*handler
, struct input_dev
*dev
,
902 const struct input_device_id
*id
)
904 struct joydev
*joydev
;
905 int i
, j
, t
, minor
, dev_no
;
908 minor
= input_get_new_minor(JOYDEV_MINOR_BASE
, JOYDEV_MINORS
, true);
911 pr_err("failed to reserve new minor: %d\n", error
);
915 joydev
= kzalloc(sizeof(struct joydev
), GFP_KERNEL
);
921 INIT_LIST_HEAD(&joydev
->client_list
);
922 spin_lock_init(&joydev
->client_lock
);
923 mutex_init(&joydev
->mutex
);
924 init_waitqueue_head(&joydev
->wait
);
925 joydev
->exist
= true;
928 /* Normalize device number if it falls into legacy range */
929 if (dev_no
< JOYDEV_MINOR_BASE
+ JOYDEV_MINORS
)
930 dev_no
-= JOYDEV_MINOR_BASE
;
931 dev_set_name(&joydev
->dev
, "js%d", dev_no
);
933 joydev
->handle
.dev
= input_get_device(dev
);
934 joydev
->handle
.name
= dev_name(&joydev
->dev
);
935 joydev
->handle
.handler
= handler
;
936 joydev
->handle
.private = joydev
;
938 for_each_set_bit(i
, dev
->absbit
, ABS_CNT
) {
939 joydev
->absmap
[i
] = joydev
->nabs
;
940 joydev
->abspam
[joydev
->nabs
] = i
;
944 for (i
= BTN_JOYSTICK
- BTN_MISC
; i
< KEY_MAX
- BTN_MISC
+ 1; i
++)
945 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
946 joydev
->keymap
[i
] = joydev
->nkey
;
947 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
951 for (i
= 0; i
< BTN_JOYSTICK
- BTN_MISC
; i
++)
952 if (test_bit(i
+ BTN_MISC
, dev
->keybit
)) {
953 joydev
->keymap
[i
] = joydev
->nkey
;
954 joydev
->keypam
[joydev
->nkey
] = i
+ BTN_MISC
;
958 for (i
= 0; i
< joydev
->nabs
; i
++) {
959 j
= joydev
->abspam
[i
];
960 if (input_abs_get_max(dev
, j
) == input_abs_get_min(dev
, j
)) {
961 joydev
->corr
[i
].type
= JS_CORR_NONE
;
964 joydev
->corr
[i
].type
= JS_CORR_BROKEN
;
965 joydev
->corr
[i
].prec
= input_abs_get_fuzz(dev
, j
);
967 t
= (input_abs_get_max(dev
, j
) + input_abs_get_min(dev
, j
)) / 2;
968 joydev
->corr
[i
].coef
[0] = t
- input_abs_get_flat(dev
, j
);
969 joydev
->corr
[i
].coef
[1] = t
+ input_abs_get_flat(dev
, j
);
971 t
= (input_abs_get_max(dev
, j
) - input_abs_get_min(dev
, j
)) / 2
972 - 2 * input_abs_get_flat(dev
, j
);
974 joydev
->corr
[i
].coef
[2] = (1 << 29) / t
;
975 joydev
->corr
[i
].coef
[3] = (1 << 29) / t
;
979 joydev
->dev
.devt
= MKDEV(INPUT_MAJOR
, minor
);
980 joydev
->dev
.class = &input_class
;
981 joydev
->dev
.parent
= &dev
->dev
;
982 joydev
->dev
.release
= joydev_free
;
983 device_initialize(&joydev
->dev
);
985 error
= input_register_handle(&joydev
->handle
);
987 goto err_free_joydev
;
989 cdev_init(&joydev
->cdev
, &joydev_fops
);
991 error
= cdev_device_add(&joydev
->cdev
, &joydev
->dev
);
993 goto err_cleanup_joydev
;
998 joydev_cleanup(joydev
);
999 input_unregister_handle(&joydev
->handle
);
1001 put_device(&joydev
->dev
);
1003 input_free_minor(minor
);
1007 static void joydev_disconnect(struct input_handle
*handle
)
1009 struct joydev
*joydev
= handle
->private;
1011 cdev_device_del(&joydev
->cdev
, &joydev
->dev
);
1012 joydev_cleanup(joydev
);
1013 input_free_minor(MINOR(joydev
->dev
.devt
));
1014 input_unregister_handle(handle
);
1015 put_device(&joydev
->dev
);
1018 static const struct input_device_id joydev_ids
[] = {
1020 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1021 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1022 .evbit
= { BIT_MASK(EV_ABS
) },
1023 .absbit
= { BIT_MASK(ABS_X
) },
1026 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1027 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1028 .evbit
= { BIT_MASK(EV_ABS
) },
1029 .absbit
= { BIT_MASK(ABS_Z
) },
1032 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1033 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1034 .evbit
= { BIT_MASK(EV_ABS
) },
1035 .absbit
= { BIT_MASK(ABS_WHEEL
) },
1038 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1039 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1040 .evbit
= { BIT_MASK(EV_ABS
) },
1041 .absbit
= { BIT_MASK(ABS_THROTTLE
) },
1044 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1045 INPUT_DEVICE_ID_MATCH_KEYBIT
,
1046 .evbit
= { BIT_MASK(EV_KEY
) },
1047 .keybit
= {[BIT_WORD(BTN_JOYSTICK
)] = BIT_MASK(BTN_JOYSTICK
) },
1050 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1051 INPUT_DEVICE_ID_MATCH_KEYBIT
,
1052 .evbit
= { BIT_MASK(EV_KEY
) },
1053 .keybit
= { [BIT_WORD(BTN_GAMEPAD
)] = BIT_MASK(BTN_GAMEPAD
) },
1056 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1057 INPUT_DEVICE_ID_MATCH_KEYBIT
,
1058 .evbit
= { BIT_MASK(EV_KEY
) },
1059 .keybit
= { [BIT_WORD(BTN_TRIGGER_HAPPY
)] = BIT_MASK(BTN_TRIGGER_HAPPY
) },
1061 { } /* Terminating entry */
1064 MODULE_DEVICE_TABLE(input
, joydev_ids
);
1066 static struct input_handler joydev_handler
= {
1067 .event
= joydev_event
,
1068 .match
= joydev_match
,
1069 .connect
= joydev_connect
,
1070 .disconnect
= joydev_disconnect
,
1071 .legacy_minors
= true,
1072 .minor
= JOYDEV_MINOR_BASE
,
1074 .id_table
= joydev_ids
,
1077 static int __init
joydev_init(void)
1079 return input_register_handler(&joydev_handler
);
1082 static void __exit
joydev_exit(void)
1084 input_unregister_handler(&joydev_handler
);
1087 module_init(joydev_init
);
1088 module_exit(joydev_exit
);