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 MOUSEDEV_MINOR_BASE 32
13 #define MOUSEDEV_MINORS 32
14 #define MOUSEDEV_MIX 31
16 #include <linux/slab.h>
17 #include <linux/poll.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/init.h>
21 #include <linux/input.h>
22 #include <linux/config.h>
23 #include <linux/smp_lock.h>
24 #include <linux/random.h>
25 #include <linux/major.h>
26 #include <linux/device.h>
27 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
28 #include <linux/miscdevice.h>
31 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
32 MODULE_DESCRIPTION("Mouse (ExplorerPS/2) device interfaces");
33 MODULE_LICENSE("GPL");
35 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_X
36 #define CONFIG_INPUT_MOUSEDEV_SCREEN_X 1024
38 #ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_Y
39 #define CONFIG_INPUT_MOUSEDEV_SCREEN_Y 768
42 static int xres
= CONFIG_INPUT_MOUSEDEV_SCREEN_X
;
43 module_param(xres
, uint
, 0644);
44 MODULE_PARM_DESC(xres
, "Horizontal screen resolution");
46 static int yres
= CONFIG_INPUT_MOUSEDEV_SCREEN_Y
;
47 module_param(yres
, uint
, 0644);
48 MODULE_PARM_DESC(yres
, "Vertical screen resolution");
50 static unsigned tap_time
= 200;
51 module_param(tap_time
, uint
, 0644);
52 MODULE_PARM_DESC(tap_time
, "Tap time for touchpads in absolute mode (msecs)");
54 struct mousedev_hw_data
{
58 unsigned long buttons
;
66 wait_queue_head_t wait
;
67 struct list_head list
;
68 struct input_handle handle
;
70 struct mousedev_hw_data packet
;
71 unsigned int pkt_count
;
72 int old_x
[4], old_y
[4];
83 struct mousedev_motion
{
85 unsigned long buttons
;
88 #define PACKET_QUEUE_LEN 16
89 struct mousedev_list
{
90 struct fasync_struct
*fasync
;
91 struct mousedev
*mousedev
;
92 struct list_head node
;
94 struct mousedev_motion packets
[PACKET_QUEUE_LEN
];
95 unsigned int head
, tail
;
96 spinlock_t packet_lock
;
100 unsigned char ready
, buffer
, bufsiz
;
101 unsigned char imexseq
, impsseq
;
102 enum mousedev_emul mode
;
103 unsigned long last_buttons
;
106 #define MOUSEDEV_SEQ_LEN 6
108 static unsigned char mousedev_imps_seq
[] = { 0xf3, 200, 0xf3, 100, 0xf3, 80 };
109 static unsigned char mousedev_imex_seq
[] = { 0xf3, 200, 0xf3, 200, 0xf3, 80 };
111 static struct input_handler mousedev_handler
;
113 static struct mousedev
*mousedev_table
[MOUSEDEV_MINORS
];
114 static struct mousedev mousedev_mix
;
116 #define fx(i) (mousedev->old_x[(mousedev->pkt_count - (i)) & 03])
117 #define fy(i) (mousedev->old_y[(mousedev->pkt_count - (i)) & 03])
119 static void mousedev_touchpad_event(struct input_dev
*dev
, struct mousedev
*mousedev
, unsigned int code
, int value
)
122 enum { FRACTION_DENOM
= 128 };
124 if (mousedev
->touch
) {
125 size
= dev
->absmax
[ABS_X
] - dev
->absmin
[ABS_X
];
126 if (size
== 0) size
= 256 * 2;
130 if (mousedev
->pkt_count
>= 2) {
131 tmp
= ((value
- fx(2)) * (256 * FRACTION_DENOM
)) / size
;
132 tmp
+= mousedev
->frac_dx
;
133 mousedev
->packet
.dx
= tmp
/ FRACTION_DENOM
;
134 mousedev
->frac_dx
= tmp
- mousedev
->packet
.dx
* FRACTION_DENOM
;
140 if (mousedev
->pkt_count
>= 2) {
141 tmp
= -((value
- fy(2)) * (256 * FRACTION_DENOM
)) / size
;
142 tmp
+= mousedev
->frac_dy
;
143 mousedev
->packet
.dy
= tmp
/ FRACTION_DENOM
;
144 mousedev
->frac_dy
= tmp
- mousedev
->packet
.dy
* FRACTION_DENOM
;
151 static void mousedev_abs_event(struct input_dev
*dev
, struct mousedev
*mousedev
, unsigned int code
, int value
)
157 size
= dev
->absmax
[ABS_X
] - dev
->absmin
[ABS_X
];
158 if (size
== 0) size
= xres
? : 1;
159 if (value
> dev
->absmax
[ABS_X
]) value
= dev
->absmax
[ABS_X
];
160 if (value
< dev
->absmin
[ABS_X
]) value
= dev
->absmin
[ABS_X
];
161 mousedev
->packet
.x
= ((value
- dev
->absmin
[ABS_X
]) * xres
) / size
;
162 mousedev
->packet
.abs_event
= 1;
166 size
= dev
->absmax
[ABS_Y
] - dev
->absmin
[ABS_Y
];
167 if (size
== 0) size
= yres
? : 1;
168 if (value
> dev
->absmax
[ABS_Y
]) value
= dev
->absmax
[ABS_Y
];
169 if (value
< dev
->absmin
[ABS_Y
]) value
= dev
->absmin
[ABS_Y
];
170 mousedev
->packet
.y
= yres
- ((value
- dev
->absmin
[ABS_Y
]) * yres
) / size
;
171 mousedev
->packet
.abs_event
= 1;
176 static void mousedev_rel_event(struct mousedev
*mousedev
, unsigned int code
, int value
)
179 case REL_X
: mousedev
->packet
.dx
+= value
; break;
180 case REL_Y
: mousedev
->packet
.dy
-= value
; break;
181 case REL_WHEEL
: mousedev
->packet
.dz
-= value
; break;
185 static void mousedev_key_event(struct mousedev
*mousedev
, unsigned int code
, int value
)
193 case BTN_LEFT
: index
= 0; break;
196 case BTN_RIGHT
: index
= 1; break;
199 case BTN_MIDDLE
: index
= 2; break;
202 case BTN_SIDE
: index
= 3; break;
204 case BTN_EXTRA
: index
= 4; break;
209 set_bit(index
, &mousedev
->packet
.buttons
);
210 set_bit(index
, &mousedev_mix
.packet
.buttons
);
212 clear_bit(index
, &mousedev
->packet
.buttons
);
213 clear_bit(index
, &mousedev_mix
.packet
.buttons
);
217 static void mousedev_notify_readers(struct mousedev
*mousedev
, struct mousedev_hw_data
*packet
)
219 struct mousedev_list
*list
;
220 struct mousedev_motion
*p
;
222 int wake_readers
= 0;
224 list_for_each_entry(list
, &mousedev
->list
, node
) {
225 spin_lock_irqsave(&list
->packet_lock
, flags
);
227 p
= &list
->packets
[list
->head
];
228 if (list
->ready
&& p
->buttons
!= mousedev
->packet
.buttons
) {
229 unsigned int new_head
= (list
->head
+ 1) % PACKET_QUEUE_LEN
;
230 if (new_head
!= list
->tail
) {
231 p
= &list
->packets
[list
->head
= new_head
];
232 memset(p
, 0, sizeof(struct mousedev_motion
));
236 if (packet
->abs_event
) {
237 p
->dx
+= packet
->x
- list
->pos_x
;
238 p
->dy
+= packet
->y
- list
->pos_y
;
239 list
->pos_x
= packet
->x
;
240 list
->pos_y
= packet
->y
;
243 list
->pos_x
+= packet
->dx
;
244 list
->pos_x
= list
->pos_x
< 0 ? 0 : (list
->pos_x
>= xres
? xres
: list
->pos_x
);
245 list
->pos_y
+= packet
->dy
;
246 list
->pos_y
= list
->pos_y
< 0 ? 0 : (list
->pos_y
>= yres
? yres
: list
->pos_y
);
251 p
->buttons
= mousedev
->packet
.buttons
;
253 if (p
->dx
|| p
->dy
|| p
->dz
|| p
->buttons
!= list
->last_buttons
)
256 spin_unlock_irqrestore(&list
->packet_lock
, flags
);
259 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
265 wake_up_interruptible(&mousedev
->wait
);
268 static void mousedev_touchpad_touch(struct mousedev
*mousedev
, int value
)
271 if (mousedev
->touch
&&
272 time_before(jiffies
, mousedev
->touch
+ msecs_to_jiffies(tap_time
))) {
274 * Toggle left button to emulate tap.
275 * We rely on the fact that mousedev_mix always has 0
276 * motion packet so we won't mess current position.
278 set_bit(0, &mousedev
->packet
.buttons
);
279 set_bit(0, &mousedev_mix
.packet
.buttons
);
280 mousedev_notify_readers(mousedev
, &mousedev_mix
.packet
);
281 mousedev_notify_readers(&mousedev_mix
, &mousedev_mix
.packet
);
282 clear_bit(0, &mousedev
->packet
.buttons
);
283 clear_bit(0, &mousedev_mix
.packet
.buttons
);
285 mousedev
->touch
= mousedev
->pkt_count
= 0;
286 mousedev
->frac_dx
= 0;
287 mousedev
->frac_dy
= 0;
290 if (!mousedev
->touch
)
291 mousedev
->touch
= jiffies
;
294 static void mousedev_event(struct input_handle
*handle
, unsigned int type
, unsigned int code
, int value
)
296 struct mousedev
*mousedev
= handle
->private;
300 /* Ignore joysticks */
301 if (test_bit(BTN_TRIGGER
, handle
->dev
->keybit
))
304 if (test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
305 mousedev_touchpad_event(handle
->dev
, mousedev
, code
, value
);
307 mousedev_abs_event(handle
->dev
, mousedev
, code
, value
);
312 mousedev_rel_event(mousedev
, code
, value
);
317 if (code
== BTN_TOUCH
&& test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
318 mousedev_touchpad_touch(mousedev
, value
);
320 mousedev_key_event(mousedev
, code
, value
);
325 if (code
== SYN_REPORT
) {
326 if (mousedev
->touch
) {
327 mousedev
->pkt_count
++;
328 /* Input system eats duplicate events, but we need all of them
329 * to do correct averaging so apply present one forward
335 mousedev_notify_readers(mousedev
, &mousedev
->packet
);
336 mousedev_notify_readers(&mousedev_mix
, &mousedev
->packet
);
338 mousedev
->packet
.dx
= mousedev
->packet
.dy
= mousedev
->packet
.dz
= 0;
339 mousedev
->packet
.abs_event
= 0;
345 static int mousedev_fasync(int fd
, struct file
*file
, int on
)
348 struct mousedev_list
*list
= file
->private_data
;
349 retval
= fasync_helper(fd
, file
, on
, &list
->fasync
);
350 return retval
< 0 ? retval
: 0;
353 static void mousedev_free(struct mousedev
*mousedev
)
355 mousedev_table
[mousedev
->minor
] = NULL
;
359 static void mixdev_release(void)
361 struct input_handle
*handle
;
363 list_for_each_entry(handle
, &mousedev_handler
.h_list
, h_node
) {
364 struct mousedev
*mousedev
= handle
->private;
366 if (!mousedev
->open
) {
368 input_close_device(&mousedev
->handle
);
370 mousedev_free(mousedev
);
375 static int mousedev_release(struct inode
* inode
, struct file
* file
)
377 struct mousedev_list
*list
= file
->private_data
;
379 mousedev_fasync(-1, file
, 0);
381 list_del(&list
->node
);
383 if (!--list
->mousedev
->open
) {
384 if (list
->mousedev
->minor
== MOUSEDEV_MIX
)
386 else if (!mousedev_mix
.open
) {
387 if (list
->mousedev
->exist
)
388 input_close_device(&list
->mousedev
->handle
);
390 mousedev_free(list
->mousedev
);
398 static int mousedev_open(struct inode
* inode
, struct file
* file
)
400 struct mousedev_list
*list
;
401 struct input_handle
*handle
;
402 struct mousedev
*mousedev
;
405 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
406 if (imajor(inode
) == MISC_MAJOR
)
410 i
= iminor(inode
) - MOUSEDEV_MINOR_BASE
;
412 if (i
>= MOUSEDEV_MINORS
|| !mousedev_table
[i
])
415 if (!(list
= kmalloc(sizeof(struct mousedev_list
), GFP_KERNEL
)))
417 memset(list
, 0, sizeof(struct mousedev_list
));
419 spin_lock_init(&list
->packet_lock
);
420 list
->pos_x
= xres
/ 2;
421 list
->pos_y
= yres
/ 2;
422 list
->mousedev
= mousedev_table
[i
];
423 list_add_tail(&list
->node
, &mousedev_table
[i
]->list
);
424 file
->private_data
= list
;
426 if (!list
->mousedev
->open
++) {
427 if (list
->mousedev
->minor
== MOUSEDEV_MIX
) {
428 list_for_each_entry(handle
, &mousedev_handler
.h_list
, h_node
) {
429 mousedev
= handle
->private;
430 if (!mousedev
->open
&& mousedev
->exist
)
431 input_open_device(handle
);
434 if (!mousedev_mix
.open
&& list
->mousedev
->exist
)
435 input_open_device(&list
->mousedev
->handle
);
441 static inline int mousedev_limit_delta(int delta
, int limit
)
443 return delta
> limit
? limit
: (delta
< -limit
? -limit
: delta
);
446 static void mousedev_packet(struct mousedev_list
*list
, signed char *ps2_data
)
448 struct mousedev_motion
*p
;
451 spin_lock_irqsave(&list
->packet_lock
, flags
);
452 p
= &list
->packets
[list
->tail
];
454 ps2_data
[0] = 0x08 | ((p
->dx
< 0) << 4) | ((p
->dy
< 0) << 5) | (p
->buttons
& 0x07);
455 ps2_data
[1] = mousedev_limit_delta(p
->dx
, 127);
456 ps2_data
[2] = mousedev_limit_delta(p
->dy
, 127);
457 p
->dx
-= ps2_data
[1];
458 p
->dy
-= ps2_data
[2];
460 switch (list
->mode
) {
461 case MOUSEDEV_EMUL_EXPS
:
462 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 7);
463 p
->dz
-= ps2_data
[3];
464 ps2_data
[3] = (ps2_data
[3] & 0x0f) | ((p
->buttons
& 0x18) << 1);
468 case MOUSEDEV_EMUL_IMPS
:
469 ps2_data
[0] |= ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
470 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 127);
471 p
->dz
-= ps2_data
[3];
475 case MOUSEDEV_EMUL_PS2
:
477 ps2_data
[0] |= ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
483 if (!p
->dx
&& !p
->dy
&& !p
->dz
) {
484 if (list
->tail
== list
->head
) {
486 list
->last_buttons
= p
->buttons
;
488 list
->tail
= (list
->tail
+ 1) % PACKET_QUEUE_LEN
;
491 spin_unlock_irqrestore(&list
->packet_lock
, flags
);
495 static ssize_t
mousedev_write(struct file
* file
, const char __user
* buffer
, size_t count
, loff_t
*ppos
)
497 struct mousedev_list
*list
= file
->private_data
;
501 for (i
= 0; i
< count
; i
++) {
503 if (get_user(c
, buffer
+ i
))
506 if (c
== mousedev_imex_seq
[list
->imexseq
]) {
507 if (++list
->imexseq
== MOUSEDEV_SEQ_LEN
) {
509 list
->mode
= MOUSEDEV_EMUL_EXPS
;
511 } else list
->imexseq
= 0;
513 if (c
== mousedev_imps_seq
[list
->impsseq
]) {
514 if (++list
->impsseq
== MOUSEDEV_SEQ_LEN
) {
516 list
->mode
= MOUSEDEV_EMUL_IMPS
;
518 } else list
->impsseq
= 0;
524 case 0xeb: /* Poll */
525 mousedev_packet(list
, &list
->ps2
[1]);
526 list
->bufsiz
++; /* account for leading ACK */
529 case 0xf2: /* Get ID */
530 switch (list
->mode
) {
531 case MOUSEDEV_EMUL_PS2
: list
->ps2
[1] = 0; break;
532 case MOUSEDEV_EMUL_IMPS
: list
->ps2
[1] = 3; break;
533 case MOUSEDEV_EMUL_EXPS
: list
->ps2
[1] = 4; break;
538 case 0xe9: /* Get info */
539 list
->ps2
[1] = 0x60; list
->ps2
[2] = 3; list
->ps2
[3] = 200;
543 case 0xff: /* Reset */
544 list
->impsseq
= list
->imexseq
= 0;
545 list
->mode
= MOUSEDEV_EMUL_PS2
;
546 list
->ps2
[1] = 0xaa; list
->ps2
[2] = 0x00;
555 list
->buffer
= list
->bufsiz
;
558 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
560 wake_up_interruptible(&list
->mousedev
->wait
);
565 static ssize_t
mousedev_read(struct file
* file
, char __user
* buffer
, size_t count
, loff_t
*ppos
)
567 struct mousedev_list
*list
= file
->private_data
;
570 if (!list
->ready
&& !list
->buffer
&& (file
->f_flags
& O_NONBLOCK
))
573 retval
= wait_event_interruptible(list
->mousedev
->wait
,
574 !list
->mousedev
->exist
|| list
->ready
|| list
->buffer
);
579 if (!list
->mousedev
->exist
)
582 if (!list
->buffer
&& list
->ready
) {
583 mousedev_packet(list
, list
->ps2
);
584 list
->buffer
= list
->bufsiz
;
587 if (count
> list
->buffer
)
588 count
= list
->buffer
;
590 list
->buffer
-= count
;
592 if (copy_to_user(buffer
, list
->ps2
+ list
->bufsiz
- list
->buffer
- count
, count
))
598 /* No kernel lock - fine */
599 static unsigned int mousedev_poll(struct file
*file
, poll_table
*wait
)
601 struct mousedev_list
*list
= file
->private_data
;
602 poll_wait(file
, &list
->mousedev
->wait
, wait
);
603 return ((list
->ready
|| list
->buffer
) ? (POLLIN
| POLLRDNORM
) : 0) |
604 (list
->mousedev
->exist
? 0 : (POLLHUP
| POLLERR
));
607 static struct file_operations mousedev_fops
= {
608 .owner
= THIS_MODULE
,
609 .read
= mousedev_read
,
610 .write
= mousedev_write
,
611 .poll
= mousedev_poll
,
612 .open
= mousedev_open
,
613 .release
= mousedev_release
,
614 .fasync
= mousedev_fasync
,
617 static struct input_handle
*mousedev_connect(struct input_handler
*handler
, struct input_dev
*dev
, struct input_device_id
*id
)
619 struct mousedev
*mousedev
;
620 struct class_device
*cdev
;
623 for (minor
= 0; minor
< MOUSEDEV_MINORS
&& mousedev_table
[minor
]; minor
++);
624 if (minor
== MOUSEDEV_MINORS
) {
625 printk(KERN_ERR
"mousedev: no more free mousedev devices\n");
629 if (!(mousedev
= kmalloc(sizeof(struct mousedev
), GFP_KERNEL
)))
631 memset(mousedev
, 0, sizeof(struct mousedev
));
633 INIT_LIST_HEAD(&mousedev
->list
);
634 init_waitqueue_head(&mousedev
->wait
);
636 mousedev
->minor
= minor
;
638 mousedev
->handle
.dev
= dev
;
639 mousedev
->handle
.name
= mousedev
->name
;
640 mousedev
->handle
.handler
= handler
;
641 mousedev
->handle
.private = mousedev
;
642 sprintf(mousedev
->name
, "mouse%d", minor
);
644 if (mousedev_mix
.open
)
645 input_open_device(&mousedev
->handle
);
647 mousedev_table
[minor
] = mousedev
;
649 cdev
= class_device_create(&input_class
, &dev
->cdev
,
650 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ minor
),
651 dev
->cdev
.dev
, mousedev
->name
);
653 /* temporary symlink to keep userspace happy */
654 sysfs_create_link(&input_class
.subsys
.kset
.kobj
, &cdev
->kobj
,
657 return &mousedev
->handle
;
660 static void mousedev_disconnect(struct input_handle
*handle
)
662 struct mousedev
*mousedev
= handle
->private;
663 struct mousedev_list
*list
;
665 sysfs_remove_link(&input_class
.subsys
.kset
.kobj
, mousedev
->name
);
666 class_device_destroy(&input_class
,
667 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ mousedev
->minor
));
670 if (mousedev
->open
) {
671 input_close_device(handle
);
672 wake_up_interruptible(&mousedev
->wait
);
673 list_for_each_entry(list
, &mousedev
->list
, node
)
674 kill_fasync(&list
->fasync
, SIGIO
, POLL_HUP
);
676 if (mousedev_mix
.open
)
677 input_close_device(handle
);
678 mousedev_free(mousedev
);
682 static struct input_device_id mousedev_ids
[] = {
684 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_RELBIT
,
685 .evbit
= { BIT(EV_KEY
) | BIT(EV_REL
) },
686 .keybit
= { [LONG(BTN_LEFT
)] = BIT(BTN_LEFT
) },
687 .relbit
= { BIT(REL_X
) | BIT(REL_Y
) },
688 }, /* A mouse like device, at least one button, two relative axes */
690 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_RELBIT
,
691 .evbit
= { BIT(EV_KEY
) | BIT(EV_REL
) },
692 .relbit
= { BIT(REL_WHEEL
) },
693 }, /* A separate scrollwheel */
695 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
696 .evbit
= { BIT(EV_KEY
) | BIT(EV_ABS
) },
697 .keybit
= { [LONG(BTN_TOUCH
)] = BIT(BTN_TOUCH
) },
698 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) },
699 }, /* A tablet like device, at least touch detection, two absolute axes */
701 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
702 .evbit
= { BIT(EV_KEY
) | BIT(EV_ABS
) },
703 .keybit
= { [LONG(BTN_TOOL_FINGER
)] = BIT(BTN_TOOL_FINGER
) },
704 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) | BIT(ABS_PRESSURE
) | BIT(ABS_TOOL_WIDTH
) },
707 { }, /* Terminating entry */
710 MODULE_DEVICE_TABLE(input
, mousedev_ids
);
712 static struct input_handler mousedev_handler
= {
713 .event
= mousedev_event
,
714 .connect
= mousedev_connect
,
715 .disconnect
= mousedev_disconnect
,
716 .fops
= &mousedev_fops
,
717 .minor
= MOUSEDEV_MINOR_BASE
,
719 .id_table
= mousedev_ids
,
722 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
723 static struct miscdevice psaux_mouse
= {
724 PSMOUSE_MINOR
, "psaux", &mousedev_fops
726 static int psaux_registered
;
729 static int __init
mousedev_init(void)
731 input_register_handler(&mousedev_handler
);
733 memset(&mousedev_mix
, 0, sizeof(struct mousedev
));
734 INIT_LIST_HEAD(&mousedev_mix
.list
);
735 init_waitqueue_head(&mousedev_mix
.wait
);
736 mousedev_table
[MOUSEDEV_MIX
] = &mousedev_mix
;
737 mousedev_mix
.exist
= 1;
738 mousedev_mix
.minor
= MOUSEDEV_MIX
;
740 class_device_create(&input_class
, NULL
,
741 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ MOUSEDEV_MIX
), NULL
, "mice");
743 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
744 if (!(psaux_registered
= !misc_register(&psaux_mouse
)))
745 printk(KERN_WARNING
"mice: could not misc_register the device\n");
748 printk(KERN_INFO
"mice: PS/2 mouse device common for all mice\n");
753 static void __exit
mousedev_exit(void)
755 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
756 if (psaux_registered
)
757 misc_deregister(&psaux_mouse
);
759 class_device_destroy(&input_class
,
760 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ MOUSEDEV_MIX
));
761 input_unregister_handler(&mousedev_handler
);
764 module_init(mousedev_init
);
765 module_exit(mousedev_exit
);