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
];
132 if (mousedev
->pkt_count
>= 2) {
133 tmp
= ((value
- fx(2)) * (256 * FRACTION_DENOM
)) / size
;
134 tmp
+= mousedev
->frac_dx
;
135 mousedev
->packet
.dx
= tmp
/ FRACTION_DENOM
;
136 mousedev
->frac_dx
= tmp
- mousedev
->packet
.dx
* FRACTION_DENOM
;
142 if (mousedev
->pkt_count
>= 2) {
143 tmp
= -((value
- fy(2)) * (256 * FRACTION_DENOM
)) / size
;
144 tmp
+= mousedev
->frac_dy
;
145 mousedev
->packet
.dy
= tmp
/ FRACTION_DENOM
;
146 mousedev
->frac_dy
= tmp
- mousedev
->packet
.dy
* FRACTION_DENOM
;
153 static void mousedev_abs_event(struct input_dev
*dev
, struct mousedev
*mousedev
, unsigned int code
, int value
)
159 size
= dev
->absmax
[ABS_X
] - dev
->absmin
[ABS_X
];
162 if (value
> dev
->absmax
[ABS_X
])
163 value
= dev
->absmax
[ABS_X
];
164 if (value
< dev
->absmin
[ABS_X
])
165 value
= dev
->absmin
[ABS_X
];
166 mousedev
->packet
.x
= ((value
- dev
->absmin
[ABS_X
]) * xres
) / size
;
167 mousedev
->packet
.abs_event
= 1;
171 size
= dev
->absmax
[ABS_Y
] - dev
->absmin
[ABS_Y
];
174 if (value
> dev
->absmax
[ABS_Y
])
175 value
= dev
->absmax
[ABS_Y
];
176 if (value
< dev
->absmin
[ABS_Y
])
177 value
= dev
->absmin
[ABS_Y
];
178 mousedev
->packet
.y
= yres
- ((value
- dev
->absmin
[ABS_Y
]) * yres
) / size
;
179 mousedev
->packet
.abs_event
= 1;
184 static void mousedev_rel_event(struct mousedev
*mousedev
, unsigned int code
, int value
)
187 case REL_X
: mousedev
->packet
.dx
+= value
; break;
188 case REL_Y
: mousedev
->packet
.dy
-= value
; break;
189 case REL_WHEEL
: mousedev
->packet
.dz
-= value
; break;
193 static void mousedev_key_event(struct mousedev
*mousedev
, unsigned int code
, int value
)
201 case BTN_LEFT
: index
= 0; break;
204 case BTN_RIGHT
: index
= 1; break;
207 case BTN_MIDDLE
: index
= 2; break;
210 case BTN_SIDE
: index
= 3; break;
212 case BTN_EXTRA
: index
= 4; break;
217 set_bit(index
, &mousedev
->packet
.buttons
);
218 set_bit(index
, &mousedev_mix
.packet
.buttons
);
220 clear_bit(index
, &mousedev
->packet
.buttons
);
221 clear_bit(index
, &mousedev_mix
.packet
.buttons
);
225 static void mousedev_notify_readers(struct mousedev
*mousedev
, struct mousedev_hw_data
*packet
)
227 struct mousedev_list
*list
;
228 struct mousedev_motion
*p
;
230 int wake_readers
= 0;
232 list_for_each_entry(list
, &mousedev
->list
, node
) {
233 spin_lock_irqsave(&list
->packet_lock
, flags
);
235 p
= &list
->packets
[list
->head
];
236 if (list
->ready
&& p
->buttons
!= mousedev
->packet
.buttons
) {
237 unsigned int new_head
= (list
->head
+ 1) % PACKET_QUEUE_LEN
;
238 if (new_head
!= list
->tail
) {
239 p
= &list
->packets
[list
->head
= new_head
];
240 memset(p
, 0, sizeof(struct mousedev_motion
));
244 if (packet
->abs_event
) {
245 p
->dx
+= packet
->x
- list
->pos_x
;
246 p
->dy
+= packet
->y
- list
->pos_y
;
247 list
->pos_x
= packet
->x
;
248 list
->pos_y
= packet
->y
;
251 list
->pos_x
+= packet
->dx
;
252 list
->pos_x
= list
->pos_x
< 0 ? 0 : (list
->pos_x
>= xres
? xres
: list
->pos_x
);
253 list
->pos_y
+= packet
->dy
;
254 list
->pos_y
= list
->pos_y
< 0 ? 0 : (list
->pos_y
>= yres
? yres
: list
->pos_y
);
259 p
->buttons
= mousedev
->packet
.buttons
;
261 if (p
->dx
|| p
->dy
|| p
->dz
|| p
->buttons
!= list
->last_buttons
)
264 spin_unlock_irqrestore(&list
->packet_lock
, flags
);
267 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
273 wake_up_interruptible(&mousedev
->wait
);
276 static void mousedev_touchpad_touch(struct mousedev
*mousedev
, int value
)
279 if (mousedev
->touch
&&
280 time_before(jiffies
, mousedev
->touch
+ msecs_to_jiffies(tap_time
))) {
282 * Toggle left button to emulate tap.
283 * We rely on the fact that mousedev_mix always has 0
284 * motion packet so we won't mess current position.
286 set_bit(0, &mousedev
->packet
.buttons
);
287 set_bit(0, &mousedev_mix
.packet
.buttons
);
288 mousedev_notify_readers(mousedev
, &mousedev_mix
.packet
);
289 mousedev_notify_readers(&mousedev_mix
, &mousedev_mix
.packet
);
290 clear_bit(0, &mousedev
->packet
.buttons
);
291 clear_bit(0, &mousedev_mix
.packet
.buttons
);
293 mousedev
->touch
= mousedev
->pkt_count
= 0;
294 mousedev
->frac_dx
= 0;
295 mousedev
->frac_dy
= 0;
297 } else if (!mousedev
->touch
)
298 mousedev
->touch
= jiffies
;
301 static void mousedev_event(struct input_handle
*handle
, unsigned int type
, unsigned int code
, int value
)
303 struct mousedev
*mousedev
= handle
->private;
307 /* Ignore joysticks */
308 if (test_bit(BTN_TRIGGER
, handle
->dev
->keybit
))
311 if (test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
312 mousedev_touchpad_event(handle
->dev
, mousedev
, code
, value
);
314 mousedev_abs_event(handle
->dev
, mousedev
, code
, value
);
319 mousedev_rel_event(mousedev
, code
, value
);
324 if (code
== BTN_TOUCH
&& test_bit(BTN_TOOL_FINGER
, handle
->dev
->keybit
))
325 mousedev_touchpad_touch(mousedev
, value
);
327 mousedev_key_event(mousedev
, code
, value
);
332 if (code
== SYN_REPORT
) {
333 if (mousedev
->touch
) {
334 mousedev
->pkt_count
++;
335 /* Input system eats duplicate events, but we need all of them
336 * to do correct averaging so apply present one forward
342 mousedev_notify_readers(mousedev
, &mousedev
->packet
);
343 mousedev_notify_readers(&mousedev_mix
, &mousedev
->packet
);
345 mousedev
->packet
.dx
= mousedev
->packet
.dy
= mousedev
->packet
.dz
= 0;
346 mousedev
->packet
.abs_event
= 0;
352 static int mousedev_fasync(int fd
, struct file
*file
, int on
)
355 struct mousedev_list
*list
= file
->private_data
;
357 retval
= fasync_helper(fd
, file
, on
, &list
->fasync
);
359 return retval
< 0 ? retval
: 0;
362 static void mousedev_free(struct mousedev
*mousedev
)
364 mousedev_table
[mousedev
->minor
] = NULL
;
368 static void mixdev_release(void)
370 struct input_handle
*handle
;
372 list_for_each_entry(handle
, &mousedev_handler
.h_list
, h_node
) {
373 struct mousedev
*mousedev
= handle
->private;
375 if (!mousedev
->open
) {
377 input_close_device(&mousedev
->handle
);
379 mousedev_free(mousedev
);
384 static int mousedev_release(struct inode
* inode
, struct file
* file
)
386 struct mousedev_list
*list
= file
->private_data
;
388 mousedev_fasync(-1, file
, 0);
390 list_del(&list
->node
);
392 if (!--list
->mousedev
->open
) {
393 if (list
->mousedev
->minor
== MOUSEDEV_MIX
)
395 else if (!mousedev_mix
.open
) {
396 if (list
->mousedev
->exist
)
397 input_close_device(&list
->mousedev
->handle
);
399 mousedev_free(list
->mousedev
);
407 static int mousedev_open(struct inode
* inode
, struct file
* file
)
409 struct mousedev_list
*list
;
410 struct input_handle
*handle
;
411 struct mousedev
*mousedev
;
414 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
415 if (imajor(inode
) == MISC_MAJOR
)
419 i
= iminor(inode
) - MOUSEDEV_MINOR_BASE
;
421 if (i
>= MOUSEDEV_MINORS
|| !mousedev_table
[i
])
424 if (!(list
= kzalloc(sizeof(struct mousedev_list
), GFP_KERNEL
)))
427 spin_lock_init(&list
->packet_lock
);
428 list
->pos_x
= xres
/ 2;
429 list
->pos_y
= yres
/ 2;
430 list
->mousedev
= mousedev_table
[i
];
431 list_add_tail(&list
->node
, &mousedev_table
[i
]->list
);
432 file
->private_data
= list
;
434 if (!list
->mousedev
->open
++) {
435 if (list
->mousedev
->minor
== MOUSEDEV_MIX
) {
436 list_for_each_entry(handle
, &mousedev_handler
.h_list
, h_node
) {
437 mousedev
= handle
->private;
438 if (!mousedev
->open
&& mousedev
->exist
)
439 input_open_device(handle
);
442 if (!mousedev_mix
.open
&& list
->mousedev
->exist
)
443 input_open_device(&list
->mousedev
->handle
);
449 static inline int mousedev_limit_delta(int delta
, int limit
)
451 return delta
> limit
? limit
: (delta
< -limit
? -limit
: delta
);
454 static void mousedev_packet(struct mousedev_list
*list
, signed char *ps2_data
)
456 struct mousedev_motion
*p
;
459 spin_lock_irqsave(&list
->packet_lock
, flags
);
460 p
= &list
->packets
[list
->tail
];
462 ps2_data
[0] = 0x08 | ((p
->dx
< 0) << 4) | ((p
->dy
< 0) << 5) | (p
->buttons
& 0x07);
463 ps2_data
[1] = mousedev_limit_delta(p
->dx
, 127);
464 ps2_data
[2] = mousedev_limit_delta(p
->dy
, 127);
465 p
->dx
-= ps2_data
[1];
466 p
->dy
-= ps2_data
[2];
468 switch (list
->mode
) {
469 case MOUSEDEV_EMUL_EXPS
:
470 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 7);
471 p
->dz
-= ps2_data
[3];
472 ps2_data
[3] = (ps2_data
[3] & 0x0f) | ((p
->buttons
& 0x18) << 1);
476 case MOUSEDEV_EMUL_IMPS
:
477 ps2_data
[0] |= ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
478 ps2_data
[3] = mousedev_limit_delta(p
->dz
, 127);
479 p
->dz
-= ps2_data
[3];
483 case MOUSEDEV_EMUL_PS2
:
485 ps2_data
[0] |= ((p
->buttons
& 0x10) >> 3) | ((p
->buttons
& 0x08) >> 1);
491 if (!p
->dx
&& !p
->dy
&& !p
->dz
) {
492 if (list
->tail
== list
->head
) {
494 list
->last_buttons
= p
->buttons
;
496 list
->tail
= (list
->tail
+ 1) % PACKET_QUEUE_LEN
;
499 spin_unlock_irqrestore(&list
->packet_lock
, flags
);
503 static ssize_t
mousedev_write(struct file
* file
, const char __user
* buffer
, size_t count
, loff_t
*ppos
)
505 struct mousedev_list
*list
= file
->private_data
;
509 for (i
= 0; i
< count
; i
++) {
511 if (get_user(c
, buffer
+ i
))
514 if (c
== mousedev_imex_seq
[list
->imexseq
]) {
515 if (++list
->imexseq
== MOUSEDEV_SEQ_LEN
) {
517 list
->mode
= MOUSEDEV_EMUL_EXPS
;
522 if (c
== mousedev_imps_seq
[list
->impsseq
]) {
523 if (++list
->impsseq
== MOUSEDEV_SEQ_LEN
) {
525 list
->mode
= MOUSEDEV_EMUL_IMPS
;
534 case 0xeb: /* Poll */
535 mousedev_packet(list
, &list
->ps2
[1]);
536 list
->bufsiz
++; /* account for leading ACK */
539 case 0xf2: /* Get ID */
540 switch (list
->mode
) {
541 case MOUSEDEV_EMUL_PS2
: list
->ps2
[1] = 0; break;
542 case MOUSEDEV_EMUL_IMPS
: list
->ps2
[1] = 3; break;
543 case MOUSEDEV_EMUL_EXPS
: list
->ps2
[1] = 4; break;
548 case 0xe9: /* Get info */
549 list
->ps2
[1] = 0x60; list
->ps2
[2] = 3; list
->ps2
[3] = 200;
553 case 0xff: /* Reset */
554 list
->impsseq
= list
->imexseq
= 0;
555 list
->mode
= MOUSEDEV_EMUL_PS2
;
556 list
->ps2
[1] = 0xaa; list
->ps2
[2] = 0x00;
565 list
->buffer
= list
->bufsiz
;
568 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
570 wake_up_interruptible(&list
->mousedev
->wait
);
575 static ssize_t
mousedev_read(struct file
* file
, char __user
* buffer
, size_t count
, loff_t
*ppos
)
577 struct mousedev_list
*list
= file
->private_data
;
580 if (!list
->ready
&& !list
->buffer
&& (file
->f_flags
& O_NONBLOCK
))
583 retval
= wait_event_interruptible(list
->mousedev
->wait
,
584 !list
->mousedev
->exist
|| list
->ready
|| list
->buffer
);
589 if (!list
->mousedev
->exist
)
592 if (!list
->buffer
&& list
->ready
) {
593 mousedev_packet(list
, list
->ps2
);
594 list
->buffer
= list
->bufsiz
;
597 if (count
> list
->buffer
)
598 count
= list
->buffer
;
600 list
->buffer
-= count
;
602 if (copy_to_user(buffer
, list
->ps2
+ list
->bufsiz
- list
->buffer
- count
, count
))
608 /* No kernel lock - fine */
609 static unsigned int mousedev_poll(struct file
*file
, poll_table
*wait
)
611 struct mousedev_list
*list
= file
->private_data
;
613 poll_wait(file
, &list
->mousedev
->wait
, wait
);
614 return ((list
->ready
|| list
->buffer
) ? (POLLIN
| POLLRDNORM
) : 0) |
615 (list
->mousedev
->exist
? 0 : (POLLHUP
| POLLERR
));
618 static struct file_operations mousedev_fops
= {
619 .owner
= THIS_MODULE
,
620 .read
= mousedev_read
,
621 .write
= mousedev_write
,
622 .poll
= mousedev_poll
,
623 .open
= mousedev_open
,
624 .release
= mousedev_release
,
625 .fasync
= mousedev_fasync
,
628 static struct input_handle
*mousedev_connect(struct input_handler
*handler
, struct input_dev
*dev
, struct input_device_id
*id
)
630 struct mousedev
*mousedev
;
631 struct class_device
*cdev
;
634 for (minor
= 0; minor
< MOUSEDEV_MINORS
&& mousedev_table
[minor
]; minor
++);
635 if (minor
== MOUSEDEV_MINORS
) {
636 printk(KERN_ERR
"mousedev: no more free mousedev devices\n");
640 if (!(mousedev
= kzalloc(sizeof(struct mousedev
), GFP_KERNEL
)))
643 INIT_LIST_HEAD(&mousedev
->list
);
644 init_waitqueue_head(&mousedev
->wait
);
646 mousedev
->minor
= minor
;
648 mousedev
->handle
.dev
= dev
;
649 mousedev
->handle
.name
= mousedev
->name
;
650 mousedev
->handle
.handler
= handler
;
651 mousedev
->handle
.private = mousedev
;
652 sprintf(mousedev
->name
, "mouse%d", minor
);
654 if (mousedev_mix
.open
)
655 input_open_device(&mousedev
->handle
);
657 mousedev_table
[minor
] = mousedev
;
659 cdev
= class_device_create(&input_class
, &dev
->cdev
,
660 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ minor
),
661 dev
->cdev
.dev
, mousedev
->name
);
663 /* temporary symlink to keep userspace happy */
664 sysfs_create_link(&input_class
.subsys
.kset
.kobj
, &cdev
->kobj
,
667 return &mousedev
->handle
;
670 static void mousedev_disconnect(struct input_handle
*handle
)
672 struct mousedev
*mousedev
= handle
->private;
673 struct mousedev_list
*list
;
675 sysfs_remove_link(&input_class
.subsys
.kset
.kobj
, mousedev
->name
);
676 class_device_destroy(&input_class
,
677 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ mousedev
->minor
));
680 if (mousedev
->open
) {
681 input_close_device(handle
);
682 wake_up_interruptible(&mousedev
->wait
);
683 list_for_each_entry(list
, &mousedev
->list
, node
)
684 kill_fasync(&list
->fasync
, SIGIO
, POLL_HUP
);
686 if (mousedev_mix
.open
)
687 input_close_device(handle
);
688 mousedev_free(mousedev
);
692 static struct input_device_id mousedev_ids
[] = {
694 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_RELBIT
,
695 .evbit
= { BIT(EV_KEY
) | BIT(EV_REL
) },
696 .keybit
= { [LONG(BTN_LEFT
)] = BIT(BTN_LEFT
) },
697 .relbit
= { BIT(REL_X
) | BIT(REL_Y
) },
698 }, /* A mouse like device, at least one button, two relative axes */
700 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_RELBIT
,
701 .evbit
= { BIT(EV_KEY
) | BIT(EV_REL
) },
702 .relbit
= { BIT(REL_WHEEL
) },
703 }, /* A separate scrollwheel */
705 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
706 .evbit
= { BIT(EV_KEY
) | BIT(EV_ABS
) },
707 .keybit
= { [LONG(BTN_TOUCH
)] = BIT(BTN_TOUCH
) },
708 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) },
709 }, /* A tablet like device, at least touch detection, two absolute axes */
711 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
712 .evbit
= { BIT(EV_KEY
) | BIT(EV_ABS
) },
713 .keybit
= { [LONG(BTN_TOOL_FINGER
)] = BIT(BTN_TOOL_FINGER
) },
714 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) | BIT(ABS_PRESSURE
) | BIT(ABS_TOOL_WIDTH
) },
717 { }, /* Terminating entry */
720 MODULE_DEVICE_TABLE(input
, mousedev_ids
);
722 static struct input_handler mousedev_handler
= {
723 .event
= mousedev_event
,
724 .connect
= mousedev_connect
,
725 .disconnect
= mousedev_disconnect
,
726 .fops
= &mousedev_fops
,
727 .minor
= MOUSEDEV_MINOR_BASE
,
729 .id_table
= mousedev_ids
,
732 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
733 static struct miscdevice psaux_mouse
= {
734 PSMOUSE_MINOR
, "psaux", &mousedev_fops
736 static int psaux_registered
;
739 static int __init
mousedev_init(void)
741 input_register_handler(&mousedev_handler
);
743 memset(&mousedev_mix
, 0, sizeof(struct mousedev
));
744 INIT_LIST_HEAD(&mousedev_mix
.list
);
745 init_waitqueue_head(&mousedev_mix
.wait
);
746 mousedev_table
[MOUSEDEV_MIX
] = &mousedev_mix
;
747 mousedev_mix
.exist
= 1;
748 mousedev_mix
.minor
= MOUSEDEV_MIX
;
750 class_device_create(&input_class
, NULL
,
751 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ MOUSEDEV_MIX
), NULL
, "mice");
753 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
754 if (!(psaux_registered
= !misc_register(&psaux_mouse
)))
755 printk(KERN_WARNING
"mice: could not misc_register the device\n");
758 printk(KERN_INFO
"mice: PS/2 mouse device common for all mice\n");
763 static void __exit
mousedev_exit(void)
765 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
766 if (psaux_registered
)
767 misc_deregister(&psaux_mouse
);
769 class_device_destroy(&input_class
,
770 MKDEV(INPUT_MAJOR
, MOUSEDEV_MINOR_BASE
+ MOUSEDEV_MIX
));
771 input_unregister_handler(&mousedev_handler
);
774 module_init(mousedev_init
);
775 module_exit(mousedev_exit
);