2 * Input driver to ExplorerPS/2 device driver module.
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 2004 Dmitry Torokhov
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #define MOUSEDEV_MINOR_BASE 32
15 #define MOUSEDEV_MINORS 32
16 #define MOUSEDEV_MIX 31
18 #include <linux/sched.h>
19 #include <linux/slab.h>
20 #include <linux/poll.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/input.h>
24 #include <linux/random.h>
25 #include <linux/major.h>
26 #include <linux/device.h>
27 #include <linux/kernel.h>
28 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
29 #include <linux/miscdevice.h>
32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
33 MODULE_DESCRIPTION("Mouse (ExplorerPS/2) device interfaces");
34 MODULE_LICENSE("GPL");
36 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_X
37 #define CONFIG_INPUT_MOUSEDEV_SCREEN_X 1024
39 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_Y
40 #define CONFIG_INPUT_MOUSEDEV_SCREEN_Y 768
43 static int xres
= CONFIG_INPUT_MOUSEDEV_SCREEN_X
;
44 module_param(xres
, uint
, 0644);
45 MODULE_PARM_DESC(xres
, "Horizontal screen resolution");
47 static int yres
= CONFIG_INPUT_MOUSEDEV_SCREEN_Y
;
48 module_param(yres
, uint
, 0644);
49 MODULE_PARM_DESC(yres
, "Vertical screen resolution");
51 static unsigned tap_time
= 200;
52 module_param(tap_time
, uint
, 0644);
53 MODULE_PARM_DESC(tap_time
, "Tap time for touchpads in absolute mode (msecs)");
55 struct mousedev_hw_data
{
59 unsigned long buttons
;
65 struct input_handle handle
;
66 wait_queue_head_t wait
;
67 struct list_head client_list
;
68 spinlock_t client_lock
; /* protects client_list */
73 struct list_head mixdev_node
;
76 struct mousedev_hw_data packet
;
77 unsigned int pkt_count
;
78 int old_x
[4], old_y
[4];
89 struct mousedev_motion
{
91 unsigned long buttons
;
94 #define PACKET_QUEUE_LEN 16
95 struct mousedev_client
{
96 struct fasync_struct
*fasync
;
97 struct mousedev
*mousedev
;
98 struct list_head node
;
100 struct mousedev_motion packets
[PACKET_QUEUE_LEN
];
101 unsigned int head
, tail
;
102 spinlock_t packet_lock
;
106 unsigned char ready
, buffer
, bufsiz
;
107 unsigned char imexseq
, impsseq
;
108 enum mousedev_emul mode
;
109 unsigned long last_buttons
;
112 #define MOUSEDEV_SEQ_LEN 6
114 static unsigned char mousedev_imps_seq
[] = { 0xf3, 200, 0xf3, 100, 0xf3, 80 };
115 static unsigned char mousedev_imex_seq
[] = { 0xf3, 200, 0xf3, 200, 0xf3, 80 };
117 static struct input_handler mousedev_handler
;
119 static struct mousedev
*mousedev_table
[MOUSEDEV_MINORS
];
120 static DEFINE_MUTEX(mousedev_table_mutex
);
121 static struct mousedev
*mousedev_mix
;
122 static LIST_HEAD(mousedev_mix_list
);
124 static void mixdev_open_devices(void);
125 static void mixdev_close_devices(void);
127 #define fx(i) (mousedev->old_x[(mousedev->pkt_count - (i)) & 03])
128 #define fy(i) (mousedev->old_y[(mousedev->pkt_count - (i)) & 03])
130 static void mousedev_touchpad_event(struct input_dev
*dev
,
131 struct mousedev
*mousedev
,
132 unsigned int code
, int value
)
135 enum { FRACTION_DENOM
= 128 };
142 if (mousedev
->touch
&& mousedev
->pkt_count
>= 2) {
143 size
= input_abs_get_max(dev
, ABS_X
) -
144 input_abs_get_min(dev
, ABS_X
);
148 tmp
= ((value
- fx(2)) * 256 * FRACTION_DENOM
) / size
;
149 tmp
+= mousedev
->frac_dx
;
150 mousedev
->packet
.dx
= tmp
/ FRACTION_DENOM
;
152 tmp
- mousedev
->packet
.dx
* FRACTION_DENOM
;
158 if (mousedev
->touch
&& mousedev
->pkt_count
>= 2) {
159 /* use X size for ABS_Y to keep the same scale */
160 size
= input_abs_get_max(dev
, ABS_X
) -
161 input_abs_get_min(dev
, ABS_X
);
165 tmp
= -((value
- fy(2)) * 256 * FRACTION_DENOM
) / size
;
166 tmp
+= mousedev
->frac_dy
;
167 mousedev
->packet
.dy
= tmp
/ FRACTION_DENOM
;
168 mousedev
->frac_dy
= tmp
-
169 mousedev
->packet
.dy
* FRACTION_DENOM
;
175 static void mousedev_abs_event(struct input_dev
*dev
, struct mousedev
*mousedev
,
176 unsigned int code
, int value
)
183 min
= input_abs_get_min(dev
, ABS_X
);
184 max
= input_abs_get_max(dev
, ABS_X
);
190 value
= clamp(value
, min
, max
);
192 mousedev
->packet
.x
= ((value
- min
) * xres
) / size
;
193 mousedev
->packet
.abs_event
= 1;
197 min
= input_abs_get_min(dev
, ABS_Y
);
198 max
= input_abs_get_max(dev
, ABS_Y
);
204 value
= clamp(value
, min
, max
);
206 mousedev
->packet
.y
= yres
- ((value
- min
) * yres
) / size
;
207 mousedev
->packet
.abs_event
= 1;
212 static void mousedev_rel_event(struct mousedev
*mousedev
,
213 unsigned int code
, int value
)
217 mousedev
->packet
.dx
+= value
;
221 mousedev
->packet
.dy
-= value
;
225 mousedev
->packet
.dz
-= value
;
230 static void mousedev_key_event(struct mousedev
*mousedev
,
231 unsigned int code
, int value
)
239 case BTN_LEFT
: index
= 0; break;
243 case BTN_RIGHT
: index
= 1; break;
248 case BTN_MIDDLE
: index
= 2; break;
252 case BTN_SIDE
: index
= 3; break;
255 case BTN_EXTRA
: index
= 4; break;
261 set_bit(index
, &mousedev
->packet
.buttons
);
262 set_bit(index
, &mousedev_mix
->packet
.buttons
);
264 clear_bit(index
, &mousedev
->packet
.buttons
);
265 clear_bit(index
, &mousedev_mix
->packet
.buttons
);
269 static void mousedev_notify_readers(struct mousedev
*mousedev
,
270 struct mousedev_hw_data
*packet
)
272 struct mousedev_client
*client
;
273 struct mousedev_motion
*p
;
274 unsigned int new_head
;
275 int wake_readers
= 0;
278 list_for_each_entry_rcu(client
, &mousedev
->client_list
, node
) {
280 /* Just acquire the lock, interrupts already disabled */
281 spin_lock(&client
->packet_lock
);
283 p
= &client
->packets
[client
->head
];
284 if (client
->ready
&& p
->buttons
!= mousedev
->packet
.buttons
) {
285 new_head
= (client
->head
+ 1) % PACKET_QUEUE_LEN
;
286 if (new_head
!= client
->tail
) {
287 p
= &client
->packets
[client
->head
= new_head
];
288 memset(p
, 0, sizeof(struct mousedev_motion
));
292 if (packet
->abs_event
) {
293 p
->dx
+= packet
->x
- client
->pos_x
;
294 p
->dy
+= packet
->y
- client
->pos_y
;
295 client
->pos_x
= packet
->x
;
296 client
->pos_y
= packet
->y
;
299 client
->pos_x
+= packet
->dx
;
300 client
->pos_x
= client
->pos_x
< 0 ?
301 0 : (client
->pos_x
>= xres
? xres
: client
->pos_x
);
302 client
->pos_y
+= packet
->dy
;
303 client
->pos_y
= client
->pos_y
< 0 ?
304 0 : (client
->pos_y
>= yres
? yres
: client
->pos_y
);
309 p
->buttons
= mousedev
->packet
.buttons
;
311 if (p
->dx
|| p
->dy
|| p
->dz
||
312 p
->buttons
!= client
->last_buttons
)
315 spin_unlock(&client
->packet_lock
);
318 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
325 wake_up_interruptible(&mousedev
->wait
);
328 static void mousedev_touchpad_touch(struct mousedev
*mousedev
, int value
)
331 if (mousedev
->touch
&&
333 mousedev
->touch
+ msecs_to_jiffies(tap_time
))) {
335 * Toggle left button to emulate tap.
336 * We rely on the fact that mousedev_mix always has 0
337 * motion packet so we won't mess current position.
339 set_bit(0, &mousedev
->packet
.buttons
);
340 set_bit(0, &mousedev_mix
->packet
.buttons
);
341 mousedev_notify_readers(mousedev
, &mousedev_mix
->packet
);
342 mousedev_notify_readers(mousedev_mix
,
343 &mousedev_mix
->packet
);
344 clear_bit(0, &mousedev
->packet
.buttons
);
345 clear_bit(0, &mousedev_mix
->packet
.buttons
);
347 mousedev
->touch
= mousedev
->pkt_count
= 0;
348 mousedev
->frac_dx
= 0;
349 mousedev
->frac_dy
= 0;
351 } else if (!mousedev
->touch
)
352 mousedev
->touch
= jiffies
;
355 static void mousedev_event(struct input_handle
*handle
,
356 unsigned int type
, unsigned int code
, int value
)
358 struct mousedev
*mousedev
= handle
->private;
363 /* Ignore joysticks */
364 if (test_bit(BTN_TRIGGER
, handle
->dev
->keybit
))
367 if (test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
368 mousedev_touchpad_event(handle
->dev
,
369 mousedev
, code
, value
);
371 mousedev_abs_event(handle
->dev
, mousedev
, code
, value
);
376 mousedev_rel_event(mousedev
, code
, value
);
381 if (code
== BTN_TOUCH
&&
382 test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
383 mousedev_touchpad_touch(mousedev
, value
);
385 mousedev_key_event(mousedev
, code
, value
);
390 if (code
== SYN_REPORT
) {
391 if (mousedev
->touch
) {
392 mousedev
->pkt_count
++;
394 * Input system eats duplicate events,
395 * but we need all of them to do correct
396 * averaging so apply present one forward
402 mousedev_notify_readers(mousedev
, &mousedev
->packet
);
403 mousedev_notify_readers(mousedev_mix
, &mousedev
->packet
);
405 mousedev
->packet
.dx
= mousedev
->packet
.dy
=
406 mousedev
->packet
.dz
= 0;
407 mousedev
->packet
.abs_event
= 0;
413 static int mousedev_fasync(int fd
, struct file
*file
, int on
)
415 struct mousedev_client
*client
= file
->private_data
;
417 return fasync_helper(fd
, file
, on
, &client
->fasync
);
420 static void mousedev_free(struct device
*dev
)
422 struct mousedev
*mousedev
= container_of(dev
, struct mousedev
, dev
);
424 input_put_device(mousedev
->handle
.dev
);
428 static int mousedev_open_device(struct mousedev
*mousedev
)
432 retval
= mutex_lock_interruptible(&mousedev
->mutex
);
436 if (mousedev
->minor
== MOUSEDEV_MIX
)
437 mixdev_open_devices();
438 else if (!mousedev
->exist
)
440 else if (!mousedev
->open
++) {
441 retval
= input_open_device(&mousedev
->handle
);
446 mutex_unlock(&mousedev
->mutex
);
450 static void mousedev_close_device(struct mousedev
*mousedev
)
452 mutex_lock(&mousedev
->mutex
);
454 if (mousedev
->minor
== MOUSEDEV_MIX
)
455 mixdev_close_devices();
456 else if (mousedev
->exist
&& !--mousedev
->open
)
457 input_close_device(&mousedev
->handle
);
459 mutex_unlock(&mousedev
->mutex
);
463 * Open all available devices so they can all be multiplexed in one.
464 * stream. Note that this function is called with mousedev_mix->mutex
467 static void mixdev_open_devices(void)
469 struct mousedev
*mousedev
;
471 if (mousedev_mix
->open
++)
474 list_for_each_entry(mousedev
, &mousedev_mix_list
, mixdev_node
) {
475 if (!mousedev
->mixdev_open
) {
476 if (mousedev_open_device(mousedev
))
479 mousedev
->mixdev_open
= 1;
485 * Close all devices that were opened as part of multiplexed
486 * device. Note that this function is called with mousedev_mix->mutex
489 static void mixdev_close_devices(void)
491 struct mousedev
*mousedev
;
493 if (--mousedev_mix
->open
)
496 list_for_each_entry(mousedev
, &mousedev_mix_list
, mixdev_node
) {
497 if (mousedev
->mixdev_open
) {
498 mousedev
->mixdev_open
= 0;
499 mousedev_close_device(mousedev
);
505 static void mousedev_attach_client(struct mousedev
*mousedev
,
506 struct mousedev_client
*client
)
508 spin_lock(&mousedev
->client_lock
);
509 list_add_tail_rcu(&client
->node
, &mousedev
->client_list
);
510 spin_unlock(&mousedev
->client_lock
);
513 static void mousedev_detach_client(struct mousedev
*mousedev
,
514 struct mousedev_client
*client
)
516 spin_lock(&mousedev
->client_lock
);
517 list_del_rcu(&client
->node
);
518 spin_unlock(&mousedev
->client_lock
);
522 static int mousedev_release(struct inode
*inode
, struct file
*file
)
524 struct mousedev_client
*client
= file
->private_data
;
525 struct mousedev
*mousedev
= client
->mousedev
;
527 mousedev_detach_client(mousedev
, client
);
530 mousedev_close_device(mousedev
);
531 put_device(&mousedev
->dev
);
536 static int mousedev_open(struct inode
*inode
, struct file
*file
)
538 struct mousedev_client
*client
;
539 struct mousedev
*mousedev
;
543 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
544 if (imajor(inode
) == MISC_MAJOR
)
548 i
= iminor(inode
) - MOUSEDEV_MINOR_BASE
;
550 if (i
>= MOUSEDEV_MINORS
)
553 error
= mutex_lock_interruptible(&mousedev_table_mutex
);
557 mousedev
= mousedev_table
[i
];
559 get_device(&mousedev
->dev
);
560 mutex_unlock(&mousedev_table_mutex
);
565 client
= kzalloc(sizeof(struct mousedev_client
), GFP_KERNEL
);
568 goto err_put_mousedev
;
571 spin_lock_init(&client
->packet_lock
);
572 client
->pos_x
= xres
/ 2;
573 client
->pos_y
= yres
/ 2;
574 client
->mousedev
= mousedev
;
575 mousedev_attach_client(mousedev
, client
);
577 error
= mousedev_open_device(mousedev
);
579 goto err_free_client
;
581 file
->private_data
= client
;
585 mousedev_detach_client(mousedev
, client
);
588 put_device(&mousedev
->dev
);
592 static inline int mousedev_limit_delta(int delta
, int limit
)
594 return delta
> limit
? limit
: (delta
< -limit
? -limit
: delta
);
597 static void mousedev_packet(struct mousedev_client
*client
,
598 signed char *ps2_data
)
600 struct mousedev_motion
*p
= &client
->packets
[client
->tail
];
603 ((p
->dx
< 0) << 4) | ((p
->dy
< 0) << 5) | (p
->buttons
& 0x07);
604 ps2_data
[1] = mousedev_limit_delta(p
->dx
, 127);
605 ps2_data
[2] = mousedev_limit_delta(p
->dy
, 127);
606 p
->dx
-= ps2_data
[1];
607 p
->dy
-= ps2_data
[2];
609 switch (client
->mode
) {
610 case MOUSEDEV_EMUL_EXPS
:
611 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 7);
612 p
->dz
-= ps2_data
[3];
613 ps2_data
[3] = (ps2_data
[3] & 0x0f) | ((p
->buttons
& 0x18) << 1);
617 case MOUSEDEV_EMUL_IMPS
:
619 ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
620 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 127);
621 p
->dz
-= ps2_data
[3];
625 case MOUSEDEV_EMUL_PS2
:
628 ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
634 if (!p
->dx
&& !p
->dy
&& !p
->dz
) {
635 if (client
->tail
== client
->head
) {
637 client
->last_buttons
= p
->buttons
;
639 client
->tail
= (client
->tail
+ 1) % PACKET_QUEUE_LEN
;
643 static void mousedev_generate_response(struct mousedev_client
*client
,
646 client
->ps2
[0] = 0xfa; /* ACK */
650 case 0xeb: /* Poll */
651 mousedev_packet(client
, &client
->ps2
[1]);
652 client
->bufsiz
++; /* account for leading ACK */
655 case 0xf2: /* Get ID */
656 switch (client
->mode
) {
657 case MOUSEDEV_EMUL_PS2
:
660 case MOUSEDEV_EMUL_IMPS
:
663 case MOUSEDEV_EMUL_EXPS
:
670 case 0xe9: /* Get info */
671 client
->ps2
[1] = 0x60; client
->ps2
[2] = 3; client
->ps2
[3] = 200;
675 case 0xff: /* Reset */
676 client
->impsseq
= client
->imexseq
= 0;
677 client
->mode
= MOUSEDEV_EMUL_PS2
;
678 client
->ps2
[1] = 0xaa; client
->ps2
[2] = 0x00;
686 client
->buffer
= client
->bufsiz
;
689 static ssize_t
mousedev_write(struct file
*file
, const char __user
*buffer
,
690 size_t count
, loff_t
*ppos
)
692 struct mousedev_client
*client
= file
->private_data
;
696 for (i
= 0; i
< count
; i
++) {
698 if (get_user(c
, buffer
+ i
))
701 spin_lock_irq(&client
->packet_lock
);
703 if (c
== mousedev_imex_seq
[client
->imexseq
]) {
704 if (++client
->imexseq
== MOUSEDEV_SEQ_LEN
) {
706 client
->mode
= MOUSEDEV_EMUL_EXPS
;
711 if (c
== mousedev_imps_seq
[client
->impsseq
]) {
712 if (++client
->impsseq
== MOUSEDEV_SEQ_LEN
) {
714 client
->mode
= MOUSEDEV_EMUL_IMPS
;
719 mousedev_generate_response(client
, c
);
721 spin_unlock_irq(&client
->packet_lock
);
724 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
725 wake_up_interruptible(&client
->mousedev
->wait
);
730 static ssize_t
mousedev_read(struct file
*file
, char __user
*buffer
,
731 size_t count
, loff_t
*ppos
)
733 struct mousedev_client
*client
= file
->private_data
;
734 struct mousedev
*mousedev
= client
->mousedev
;
735 signed char data
[sizeof(client
->ps2
)];
738 if (!client
->ready
&& !client
->buffer
&& mousedev
->exist
&&
739 (file
->f_flags
& O_NONBLOCK
))
742 retval
= wait_event_interruptible(mousedev
->wait
,
743 !mousedev
->exist
|| client
->ready
|| client
->buffer
);
747 if (!mousedev
->exist
)
750 spin_lock_irq(&client
->packet_lock
);
752 if (!client
->buffer
&& client
->ready
) {
753 mousedev_packet(client
, client
->ps2
);
754 client
->buffer
= client
->bufsiz
;
757 if (count
> client
->buffer
)
758 count
= client
->buffer
;
760 memcpy(data
, client
->ps2
+ client
->bufsiz
- client
->buffer
, count
);
761 client
->buffer
-= count
;
763 spin_unlock_irq(&client
->packet_lock
);
765 if (copy_to_user(buffer
, data
, count
))
771 /* No kernel lock - fine */
772 static unsigned int mousedev_poll(struct file
*file
, poll_table
*wait
)
774 struct mousedev_client
*client
= file
->private_data
;
775 struct mousedev
*mousedev
= client
->mousedev
;
778 poll_wait(file
, &mousedev
->wait
, wait
);
780 mask
= mousedev
->exist
? POLLOUT
| POLLWRNORM
: POLLHUP
| POLLERR
;
781 if (client
->ready
|| client
->buffer
)
782 mask
|= POLLIN
| POLLRDNORM
;
787 static const struct file_operations mousedev_fops
= {
788 .owner
= THIS_MODULE
,
789 .read
= mousedev_read
,
790 .write
= mousedev_write
,
791 .poll
= mousedev_poll
,
792 .open
= mousedev_open
,
793 .release
= mousedev_release
,
794 .fasync
= mousedev_fasync
,
795 .llseek
= noop_llseek
,
798 static int mousedev_install_chrdev(struct mousedev
*mousedev
)
800 mousedev_table
[mousedev
->minor
] = mousedev
;
804 static void mousedev_remove_chrdev(struct mousedev
*mousedev
)
806 mutex_lock(&mousedev_table_mutex
);
807 mousedev_table
[mousedev
->minor
] = NULL
;
808 mutex_unlock(&mousedev_table_mutex
);
812 * Mark device non-existent. This disables writes, ioctls and
813 * prevents new users from opening the device. Already posted
814 * blocking reads will stay, however new ones will fail.
816 static void mousedev_mark_dead(struct mousedev
*mousedev
)
818 mutex_lock(&mousedev
->mutex
);
819 mousedev
->exist
= false;
820 mutex_unlock(&mousedev
->mutex
);
824 * Wake up users waiting for IO so they can disconnect from
827 static void mousedev_hangup(struct mousedev
*mousedev
)
829 struct mousedev_client
*client
;
831 spin_lock(&mousedev
->client_lock
);
832 list_for_each_entry(client
, &mousedev
->client_list
, node
)
833 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
834 spin_unlock(&mousedev
->client_lock
);
836 wake_up_interruptible(&mousedev
->wait
);
839 static void mousedev_cleanup(struct mousedev
*mousedev
)
841 struct input_handle
*handle
= &mousedev
->handle
;
843 mousedev_mark_dead(mousedev
);
844 mousedev_hangup(mousedev
);
845 mousedev_remove_chrdev(mousedev
);
847 /* mousedev is marked dead so no one else accesses mousedev->open */
849 input_close_device(handle
);
852 static struct mousedev
*mousedev_create(struct input_dev
*dev
,
853 struct input_handler
*handler
,
856 struct mousedev
*mousedev
;
859 mousedev
= kzalloc(sizeof(struct mousedev
), GFP_KERNEL
);
865 INIT_LIST_HEAD(&mousedev
->client_list
);
866 INIT_LIST_HEAD(&mousedev
->mixdev_node
);
867 spin_lock_init(&mousedev
->client_lock
);
868 mutex_init(&mousedev
->mutex
);
869 lockdep_set_subclass(&mousedev
->mutex
,
870 minor
== MOUSEDEV_MIX
? SINGLE_DEPTH_NESTING
: 0);
871 init_waitqueue_head(&mousedev
->wait
);
873 if (minor
== MOUSEDEV_MIX
)
874 dev_set_name(&mousedev
->dev
, "mice");
876 dev_set_name(&mousedev
->dev
, "mouse%d", minor
);
878 mousedev
->minor
= minor
;
879 mousedev
->exist
= true;
880 mousedev
->handle
.dev
= input_get_device(dev
);
881 mousedev
->handle
.name
= dev_name(&mousedev
->dev
);
882 mousedev
->handle
.handler
= handler
;
883 mousedev
->handle
.private = mousedev
;
885 mousedev
->dev
.class = &input_class
;
887 mousedev
->dev
.parent
= &dev
->dev
;
888 mousedev
->dev
.devt
= MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ minor
);
889 mousedev
->dev
.release
= mousedev_free
;
890 device_initialize(&mousedev
->dev
);
892 if (minor
!= MOUSEDEV_MIX
) {
893 error
= input_register_handle(&mousedev
->handle
);
895 goto err_free_mousedev
;
898 error
= mousedev_install_chrdev(mousedev
);
900 goto err_unregister_handle
;
902 error
= device_add(&mousedev
->dev
);
904 goto err_cleanup_mousedev
;
908 err_cleanup_mousedev
:
909 mousedev_cleanup(mousedev
);
910 err_unregister_handle
:
911 if (minor
!= MOUSEDEV_MIX
)
912 input_unregister_handle(&mousedev
->handle
);
914 put_device(&mousedev
->dev
);
916 return ERR_PTR(error
);
919 static void mousedev_destroy(struct mousedev
*mousedev
)
921 device_del(&mousedev
->dev
);
922 mousedev_cleanup(mousedev
);
923 if (mousedev
->minor
!= MOUSEDEV_MIX
)
924 input_unregister_handle(&mousedev
->handle
);
925 put_device(&mousedev
->dev
);
928 static int mixdev_add_device(struct mousedev
*mousedev
)
932 retval
= mutex_lock_interruptible(&mousedev_mix
->mutex
);
936 if (mousedev_mix
->open
) {
937 retval
= mousedev_open_device(mousedev
);
941 mousedev
->mixdev_open
= 1;
944 get_device(&mousedev
->dev
);
945 list_add_tail(&mousedev
->mixdev_node
, &mousedev_mix_list
);
948 mutex_unlock(&mousedev_mix
->mutex
);
952 static void mixdev_remove_device(struct mousedev
*mousedev
)
954 mutex_lock(&mousedev_mix
->mutex
);
956 if (mousedev
->mixdev_open
) {
957 mousedev
->mixdev_open
= 0;
958 mousedev_close_device(mousedev
);
961 list_del_init(&mousedev
->mixdev_node
);
962 mutex_unlock(&mousedev_mix
->mutex
);
964 put_device(&mousedev
->dev
);
967 static int mousedev_connect(struct input_handler
*handler
,
968 struct input_dev
*dev
,
969 const struct input_device_id
*id
)
971 struct mousedev
*mousedev
;
975 for (minor
= 0; minor
< MOUSEDEV_MINORS
; minor
++)
976 if (!mousedev_table
[minor
])
979 if (minor
== MOUSEDEV_MINORS
) {
980 pr_err("no more free mousedev devices\n");
984 mousedev
= mousedev_create(dev
, handler
, minor
);
985 if (IS_ERR(mousedev
))
986 return PTR_ERR(mousedev
);
988 error
= mixdev_add_device(mousedev
);
990 mousedev_destroy(mousedev
);
997 static void mousedev_disconnect(struct input_handle
*handle
)
999 struct mousedev
*mousedev
= handle
->private;
1001 mixdev_remove_device(mousedev
);
1002 mousedev_destroy(mousedev
);
1005 static const struct input_device_id mousedev_ids
[] = {
1007 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1008 INPUT_DEVICE_ID_MATCH_KEYBIT
|
1009 INPUT_DEVICE_ID_MATCH_RELBIT
,
1010 .evbit
= { BIT_MASK(EV_KEY
) | BIT_MASK(EV_REL
) },
1011 .keybit
= { [BIT_WORD(BTN_LEFT
)] = BIT_MASK(BTN_LEFT
) },
1012 .relbit
= { BIT_MASK(REL_X
) | BIT_MASK(REL_Y
) },
1013 }, /* A mouse like device, at least one button,
1014 two relative axes */
1016 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1017 INPUT_DEVICE_ID_MATCH_RELBIT
,
1018 .evbit
= { BIT_MASK(EV_KEY
) | BIT_MASK(EV_REL
) },
1019 .relbit
= { BIT_MASK(REL_WHEEL
) },
1020 }, /* A separate scrollwheel */
1022 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1023 INPUT_DEVICE_ID_MATCH_KEYBIT
|
1024 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1025 .evbit
= { BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
) },
1026 .keybit
= { [BIT_WORD(BTN_TOUCH
)] = BIT_MASK(BTN_TOUCH
) },
1027 .absbit
= { BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) },
1028 }, /* A tablet like device, at least touch detection,
1029 two absolute axes */
1031 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1032 INPUT_DEVICE_ID_MATCH_KEYBIT
|
1033 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1034 .evbit
= { BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
) },
1035 .keybit
= { [BIT_WORD(BTN_TOOL_FINGER
)] =
1036 BIT_MASK(BTN_TOOL_FINGER
) },
1037 .absbit
= { BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) |
1038 BIT_MASK(ABS_PRESSURE
) |
1039 BIT_MASK(ABS_TOOL_WIDTH
) },
1042 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1043 INPUT_DEVICE_ID_MATCH_KEYBIT
|
1044 INPUT_DEVICE_ID_MATCH_ABSBIT
,
1045 .evbit
= { BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
) },
1046 .keybit
= { [BIT_WORD(BTN_LEFT
)] = BIT_MASK(BTN_LEFT
) },
1047 .absbit
= { BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) },
1048 }, /* Mouse-like device with absolute X and Y but ordinary
1049 clicks, like hp ILO2 High Performance mouse */
1051 { }, /* Terminating entry */
1054 MODULE_DEVICE_TABLE(input
, mousedev_ids
);
1056 static struct input_handler mousedev_handler
= {
1057 .event
= mousedev_event
,
1058 .connect
= mousedev_connect
,
1059 .disconnect
= mousedev_disconnect
,
1060 .fops
= &mousedev_fops
,
1061 .minor
= MOUSEDEV_MINOR_BASE
,
1063 .id_table
= mousedev_ids
,
1066 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1067 static struct miscdevice psaux_mouse
= {
1068 PSMOUSE_MINOR
, "psaux", &mousedev_fops
1070 static int psaux_registered
;
1073 static int __init
mousedev_init(void)
1077 mousedev_mix
= mousedev_create(NULL
, &mousedev_handler
, MOUSEDEV_MIX
);
1078 if (IS_ERR(mousedev_mix
))
1079 return PTR_ERR(mousedev_mix
);
1081 error
= input_register_handler(&mousedev_handler
);
1083 mousedev_destroy(mousedev_mix
);
1087 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1088 error
= misc_register(&psaux_mouse
);
1090 pr_warn("could not register psaux device, error: %d\n",
1093 psaux_registered
= 1;
1096 pr_info("PS/2 mouse device common for all mice\n");
1101 static void __exit
mousedev_exit(void)
1103 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1104 if (psaux_registered
)
1105 misc_deregister(&psaux_mouse
);
1107 input_unregister_handler(&mousedev_handler
);
1108 mousedev_destroy(mousedev_mix
);
1111 module_init(mousedev_init
);
1112 module_exit(mousedev_exit
);