4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 2003-2004 Dmitry Torokhov
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License version 2 as published by
11 * the Free Software Foundation.
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/input.h>
20 #include <linux/serio.h>
21 #include <linux/init.h>
22 #include <linux/libps2.h>
24 #include "synaptics.h"
25 #include "logips2pp.h"
29 #define DRIVER_DESC "PS/2 mouse driver"
31 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
32 MODULE_DESCRIPTION(DRIVER_DESC
);
33 MODULE_LICENSE("GPL");
35 static unsigned int psmouse_max_proto
= -1U;
36 static int psmouse_set_maxproto(const char *val
, struct kernel_param
*kp
);
37 static int psmouse_get_maxproto(char *buffer
, struct kernel_param
*kp
);
38 static char *psmouse_proto_abbrev
[] = { NULL
, "bare", NULL
, NULL
, NULL
, "imps", "exps", NULL
, NULL
, "lifebook" };
39 #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int)
40 #define param_set_proto_abbrev psmouse_set_maxproto
41 #define param_get_proto_abbrev psmouse_get_maxproto
42 module_param_named(proto
, psmouse_max_proto
, proto_abbrev
, 0644);
43 MODULE_PARM_DESC(proto
, "Highest protocol extension to probe (bare, imps, exps, lifebook, any). Useful for KVM switches.");
45 static unsigned int psmouse_resolution
= 200;
46 module_param_named(resolution
, psmouse_resolution
, uint
, 0644);
47 MODULE_PARM_DESC(resolution
, "Resolution, in dpi.");
49 static unsigned int psmouse_rate
= 100;
50 module_param_named(rate
, psmouse_rate
, uint
, 0644);
51 MODULE_PARM_DESC(rate
, "Report rate, in reports per second.");
53 static unsigned int psmouse_smartscroll
= 1;
54 module_param_named(smartscroll
, psmouse_smartscroll
, bool, 0644);
55 MODULE_PARM_DESC(smartscroll
, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
57 static unsigned int psmouse_resetafter
;
58 module_param_named(resetafter
, psmouse_resetafter
, uint
, 0644);
59 MODULE_PARM_DESC(resetafter
, "Reset device after so many bad packets (0 = never).");
61 PSMOUSE_DEFINE_ATTR(rate
);
62 PSMOUSE_DEFINE_ATTR(resolution
);
63 PSMOUSE_DEFINE_ATTR(resetafter
);
65 __obsolete_setup("psmouse_noext");
66 __obsolete_setup("psmouse_resolution=");
67 __obsolete_setup("psmouse_smartscroll=");
68 __obsolete_setup("psmouse_resetafter=");
69 __obsolete_setup("psmouse_rate=");
72 * psmouse_sem protects all operations changing state of mouse
73 * (connecting, disconnecting, changing rate or resolution via
74 * sysfs). We could use a per-device semaphore but since there
75 * rarely more than one PS/2 mouse connected and since semaphore
76 * is taken in "slow" paths it is not worth it.
78 static DECLARE_MUTEX(psmouse_sem
);
80 static char *psmouse_protocols
[] = { "None", "PS/2", "PS2++", "ThinkPS/2", "GenPS/2", "ImPS/2", "ImExPS/2", "SynPS/2", "AlpsPS/2", "LBPS/2" };
83 * psmouse_process_byte() analyzes the PS/2 data stream and reports
84 * relevant events to the input module once full packet has arrived.
87 static psmouse_ret_t
psmouse_process_byte(struct psmouse
*psmouse
, struct pt_regs
*regs
)
89 struct input_dev
*dev
= &psmouse
->dev
;
90 unsigned char *packet
= psmouse
->packet
;
92 if (psmouse
->pktcnt
< psmouse
->pktsize
)
93 return PSMOUSE_GOOD_DATA
;
96 * Full packet accumulated, process it
99 input_regs(dev
, regs
);
102 * Scroll wheel on IntelliMice, scroll buttons on NetMice
105 if (psmouse
->type
== PSMOUSE_IMPS
|| psmouse
->type
== PSMOUSE_GENPS
)
106 input_report_rel(dev
, REL_WHEEL
, -(signed char) packet
[3]);
109 * Scroll wheel and buttons on IntelliMouse Explorer
112 if (psmouse
->type
== PSMOUSE_IMEX
) {
113 input_report_rel(dev
, REL_WHEEL
, (int) (packet
[3] & 8) - (int) (packet
[3] & 7));
114 input_report_key(dev
, BTN_SIDE
, (packet
[3] >> 4) & 1);
115 input_report_key(dev
, BTN_EXTRA
, (packet
[3] >> 5) & 1);
119 * Extra buttons on Genius NewNet 3D
122 if (psmouse
->type
== PSMOUSE_GENPS
) {
123 input_report_key(dev
, BTN_SIDE
, (packet
[0] >> 6) & 1);
124 input_report_key(dev
, BTN_EXTRA
, (packet
[0] >> 7) & 1);
128 * Extra button on ThinkingMouse
130 if (psmouse
->type
== PSMOUSE_THINKPS
) {
131 input_report_key(dev
, BTN_EXTRA
, (packet
[0] >> 3) & 1);
132 /* Without this bit of weirdness moving up gives wildly high Y changes. */
133 packet
[1] |= (packet
[0] & 0x40) << 1;
140 input_report_key(dev
, BTN_LEFT
, packet
[0] & 1);
141 input_report_key(dev
, BTN_MIDDLE
, (packet
[0] >> 2) & 1);
142 input_report_key(dev
, BTN_RIGHT
, (packet
[0] >> 1) & 1);
144 input_report_rel(dev
, REL_X
, packet
[1] ? (int) packet
[1] - (int) ((packet
[0] << 4) & 0x100) : 0);
145 input_report_rel(dev
, REL_Y
, packet
[2] ? (int) ((packet
[0] << 3) & 0x100) - (int) packet
[2] : 0);
149 return PSMOUSE_FULL_PACKET
;
153 * psmouse_interrupt() handles incoming characters, either gathering them into
154 * packets or passing them to the command routine as command output.
157 static irqreturn_t
psmouse_interrupt(struct serio
*serio
,
158 unsigned char data
, unsigned int flags
, struct pt_regs
*regs
)
160 struct psmouse
*psmouse
= serio_get_drvdata(serio
);
163 if (psmouse
->state
== PSMOUSE_IGNORE
)
166 if (flags
& (SERIO_PARITY
|SERIO_TIMEOUT
)) {
167 if (psmouse
->state
== PSMOUSE_ACTIVATED
)
168 printk(KERN_WARNING
"psmouse.c: bad data from KBC -%s%s\n",
169 flags
& SERIO_TIMEOUT
? " timeout" : "",
170 flags
& SERIO_PARITY
? " bad parity" : "");
171 ps2_cmd_aborted(&psmouse
->ps2dev
);
175 if (unlikely(psmouse
->ps2dev
.flags
& PS2_FLAG_ACK
))
176 if (ps2_handle_ack(&psmouse
->ps2dev
, data
))
179 if (unlikely(psmouse
->ps2dev
.flags
& PS2_FLAG_CMD
))
180 if (ps2_handle_response(&psmouse
->ps2dev
, data
))
183 if (psmouse
->state
== PSMOUSE_INITIALIZING
)
186 if (psmouse
->state
== PSMOUSE_ACTIVATED
&&
187 psmouse
->pktcnt
&& time_after(jiffies
, psmouse
->last
+ HZ
/2)) {
188 printk(KERN_WARNING
"psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
189 psmouse
->name
, psmouse
->phys
, psmouse
->pktcnt
);
193 psmouse
->last
= jiffies
;
194 psmouse
->packet
[psmouse
->pktcnt
++] = data
;
196 if (psmouse
->packet
[0] == PSMOUSE_RET_BAT
) {
197 if (psmouse
->pktcnt
== 1)
200 if (psmouse
->pktcnt
== 2) {
201 if (psmouse
->packet
[1] == PSMOUSE_RET_ID
) {
202 psmouse
->state
= PSMOUSE_IGNORE
;
203 serio_reconnect(serio
);
206 if (psmouse
->type
== PSMOUSE_SYNAPTICS
) {
207 /* neither 0xAA nor 0x00 are valid first bytes
208 * for a packet in absolute mode
216 rc
= psmouse
->protocol_handler(psmouse
, regs
);
219 case PSMOUSE_BAD_DATA
:
220 printk(KERN_WARNING
"psmouse.c: %s at %s lost sync at byte %d\n",
221 psmouse
->name
, psmouse
->phys
, psmouse
->pktcnt
);
224 if (++psmouse
->out_of_sync
== psmouse
->resetafter
) {
225 psmouse
->state
= PSMOUSE_IGNORE
;
226 printk(KERN_NOTICE
"psmouse.c: issuing reconnect request\n");
227 serio_reconnect(psmouse
->ps2dev
.serio
);
231 case PSMOUSE_FULL_PACKET
:
233 if (psmouse
->out_of_sync
) {
234 psmouse
->out_of_sync
= 0;
235 printk(KERN_NOTICE
"psmouse.c: %s at %s - driver resynched.\n",
236 psmouse
->name
, psmouse
->phys
);
240 case PSMOUSE_GOOD_DATA
:
249 * psmouse_sliced_command() sends an extended PS/2 command to the mouse
250 * using sliced syntax, understood by advanced devices, such as Logitech
251 * or Synaptics touchpads. The command is encoded as:
252 * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
255 int psmouse_sliced_command(struct psmouse
*psmouse
, unsigned char command
)
259 if (ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE11
))
262 for (i
= 6; i
>= 0; i
-= 2) {
263 unsigned char d
= (command
>> i
) & 3;
264 if (ps2_command(&psmouse
->ps2dev
, &d
, PSMOUSE_CMD_SETRES
))
273 * psmouse_reset() resets the mouse into power-on state.
275 int psmouse_reset(struct psmouse
*psmouse
)
277 unsigned char param
[2];
279 if (ps2_command(&psmouse
->ps2dev
, param
, PSMOUSE_CMD_RESET_BAT
))
282 if (param
[0] != PSMOUSE_RET_BAT
&& param
[1] != PSMOUSE_RET_ID
)
290 * Genius NetMouse magic init.
292 static int genius_detect(struct psmouse
*psmouse
, int set_properties
)
294 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
295 unsigned char param
[4];
298 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRES
);
299 ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE11
);
300 ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE11
);
301 ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE11
);
302 ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETINFO
);
304 if (param
[0] != 0x00 || param
[1] != 0x33 || param
[2] != 0x55)
307 if (set_properties
) {
308 set_bit(BTN_EXTRA
, psmouse
->dev
.keybit
);
309 set_bit(BTN_SIDE
, psmouse
->dev
.keybit
);
310 set_bit(REL_WHEEL
, psmouse
->dev
.relbit
);
312 psmouse
->vendor
= "Genius";
313 psmouse
->name
= "Wheel Mouse";
314 psmouse
->pktsize
= 4;
321 * IntelliMouse magic init.
323 static int intellimouse_detect(struct psmouse
*psmouse
, int set_properties
)
325 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
326 unsigned char param
[2];
329 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
331 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
333 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
334 ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETID
);
339 if (set_properties
) {
340 set_bit(REL_WHEEL
, psmouse
->dev
.relbit
);
342 if (!psmouse
->vendor
) psmouse
->vendor
= "Generic";
343 if (!psmouse
->name
) psmouse
->name
= "Wheel Mouse";
344 psmouse
->pktsize
= 4;
351 * Try IntelliMouse/Explorer magic init.
353 static int im_explorer_detect(struct psmouse
*psmouse
, int set_properties
)
355 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
356 unsigned char param
[2];
358 intellimouse_detect(psmouse
, 0);
361 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
363 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
365 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
366 ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETID
);
371 if (set_properties
) {
372 set_bit(REL_WHEEL
, psmouse
->dev
.relbit
);
373 set_bit(BTN_SIDE
, psmouse
->dev
.keybit
);
374 set_bit(BTN_EXTRA
, psmouse
->dev
.keybit
);
376 if (!psmouse
->vendor
) psmouse
->vendor
= "Generic";
377 if (!psmouse
->name
) psmouse
->name
= "Explorer Mouse";
378 psmouse
->pktsize
= 4;
385 * Kensington ThinkingMouse / ExpertMouse magic init.
387 static int thinking_detect(struct psmouse
*psmouse
, int set_properties
)
389 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
390 unsigned char param
[2];
391 unsigned char seq
[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20, 0 };
395 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
397 ps2_command(ps2dev
, param
, PSMOUSE_CMD_SETRES
);
398 for (i
= 0; seq
[i
]; i
++)
399 ps2_command(ps2dev
, seq
+ i
, PSMOUSE_CMD_SETRATE
);
400 ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETID
);
405 if (set_properties
) {
406 set_bit(BTN_EXTRA
, psmouse
->dev
.keybit
);
408 psmouse
->vendor
= "Kensington";
409 psmouse
->name
= "ThinkingMouse";
416 * Bare PS/2 protocol "detection". Always succeeds.
418 static int ps2bare_detect(struct psmouse
*psmouse
, int set_properties
)
420 if (!psmouse
->vendor
) psmouse
->vendor
= "Generic";
421 if (!psmouse
->name
) psmouse
->name
= "Mouse";
427 * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
428 * the mouse may have.
431 static int psmouse_extensions(struct psmouse
*psmouse
,
432 unsigned int max_proto
, int set_properties
)
434 int synaptics_hardware
= 0;
437 * We always check for lifebook because it does not disturb mouse
438 * (it only checks DMI information).
440 if (lifebook_detect(psmouse
, set_properties
) == 0 ||
441 max_proto
== PSMOUSE_LIFEBOOK
) {
443 if (max_proto
> PSMOUSE_IMEX
) {
444 if (!set_properties
|| lifebook_init(psmouse
) == 0)
445 return PSMOUSE_LIFEBOOK
;
450 * Try Kensington ThinkingMouse (we try first, because synaptics probe
451 * upsets the thinkingmouse).
454 if (max_proto
> PSMOUSE_IMEX
&& thinking_detect(psmouse
, set_properties
) == 0)
455 return PSMOUSE_THINKPS
;
458 * Try Synaptics TouchPad
460 if (max_proto
> PSMOUSE_PS2
&& synaptics_detect(psmouse
, set_properties
) == 0) {
461 synaptics_hardware
= 1;
463 if (max_proto
> PSMOUSE_IMEX
) {
464 if (!set_properties
|| synaptics_init(psmouse
) == 0)
465 return PSMOUSE_SYNAPTICS
;
467 * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
468 * Unfortunately Logitech/Genius probes confuse some firmware versions so
469 * we'll have to skip them.
471 max_proto
= PSMOUSE_IMEX
;
474 * Make sure that touchpad is in relative mode, gestures (taps) are enabled
476 synaptics_reset(psmouse
);
482 if (max_proto
> PSMOUSE_IMEX
) {
483 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_RESET_DIS
);
484 if (alps_detect(psmouse
, set_properties
) == 0) {
485 if (!set_properties
|| alps_init(psmouse
) == 0)
488 * Init failed, try basic relative protocols
490 max_proto
= PSMOUSE_IMEX
;
494 if (max_proto
> PSMOUSE_IMEX
&& genius_detect(psmouse
, set_properties
) == 0)
495 return PSMOUSE_GENPS
;
497 if (max_proto
> PSMOUSE_IMEX
&& ps2pp_init(psmouse
, set_properties
) == 0)
498 return PSMOUSE_PS2PP
;
501 * Reset to defaults in case the device got confused by extended
504 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_RESET_DIS
);
506 if (max_proto
>= PSMOUSE_IMEX
&& im_explorer_detect(psmouse
, set_properties
) == 0)
509 if (max_proto
>= PSMOUSE_IMPS
&& intellimouse_detect(psmouse
, set_properties
) == 0)
513 * Okay, all failed, we have a standard mouse here. The number of the buttons
514 * is still a question, though. We assume 3.
516 ps2bare_detect(psmouse
, set_properties
);
518 if (synaptics_hardware
) {
520 * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
521 * We need to reset the touchpad because if there is a track point on the
522 * pass through port it could get disabled while probing for protocol
525 psmouse_reset(psmouse
);
526 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_RESET_DIS
);
533 * psmouse_probe() probes for a PS/2 mouse.
536 static int psmouse_probe(struct psmouse
*psmouse
)
538 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
539 unsigned char param
[2];
542 * First, we check if it's a mouse. It should send 0x00 or 0x03
543 * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
544 * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent
545 * ID queries, probably due to a firmware bug.
549 if (ps2_command(ps2dev
, param
, PSMOUSE_CMD_GETID
))
552 if (param
[0] != 0x00 && param
[0] != 0x03 &&
553 param
[0] != 0x04 && param
[0] != 0xff)
557 * Then we reset and disable the mouse so that it doesn't generate events.
560 if (ps2_command(ps2dev
, NULL
, PSMOUSE_CMD_RESET_DIS
))
561 printk(KERN_WARNING
"psmouse.c: Failed to reset mouse on %s\n", ps2dev
->serio
->phys
);
567 * Here we set the mouse resolution.
570 void psmouse_set_resolution(struct psmouse
*psmouse
, unsigned int resolution
)
572 unsigned char params
[] = { 0, 1, 2, 2, 3 };
574 if (resolution
== 0 || resolution
> 200)
577 ps2_command(&psmouse
->ps2dev
, ¶ms
[resolution
/ 50], PSMOUSE_CMD_SETRES
);
578 psmouse
->resolution
= 25 << params
[resolution
/ 50];
582 * Here we set the mouse report rate.
585 static void psmouse_set_rate(struct psmouse
*psmouse
, unsigned int rate
)
587 unsigned char rates
[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
590 while (rates
[i
] > rate
) i
++;
591 ps2_command(&psmouse
->ps2dev
, &rates
[i
], PSMOUSE_CMD_SETRATE
);
592 psmouse
->rate
= rates
[i
];
596 * psmouse_initialize() initializes the mouse to a sane state.
599 static void psmouse_initialize(struct psmouse
*psmouse
)
602 * We set the mouse into streaming mode.
605 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_SETSTREAM
);
608 * We set the mouse report rate, resolution and scaling.
611 if (psmouse_max_proto
!= PSMOUSE_PS2
) {
612 psmouse
->set_rate(psmouse
, psmouse
->rate
);
613 psmouse
->set_resolution(psmouse
, psmouse
->resolution
);
614 ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_SETSCALE11
);
619 * psmouse_set_state() sets new psmouse state and resets all flags and
620 * counters while holding serio lock so fighting with interrupt handler
624 static void psmouse_set_state(struct psmouse
*psmouse
, enum psmouse_state new_state
)
626 serio_pause_rx(psmouse
->ps2dev
.serio
);
627 psmouse
->state
= new_state
;
628 psmouse
->pktcnt
= psmouse
->out_of_sync
= 0;
629 psmouse
->ps2dev
.flags
= 0;
630 serio_continue_rx(psmouse
->ps2dev
.serio
);
634 * psmouse_activate() enables the mouse so that we get motion reports from it.
637 static void psmouse_activate(struct psmouse
*psmouse
)
639 if (ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_ENABLE
))
640 printk(KERN_WARNING
"psmouse.c: Failed to enable mouse on %s\n",
641 psmouse
->ps2dev
.serio
->phys
);
643 psmouse_set_state(psmouse
, PSMOUSE_ACTIVATED
);
648 * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
649 * reports from it unless we explicitely request it.
652 static void psmouse_deactivate(struct psmouse
*psmouse
)
654 if (ps2_command(&psmouse
->ps2dev
, NULL
, PSMOUSE_CMD_DISABLE
))
655 printk(KERN_WARNING
"psmouse.c: Failed to deactivate mouse on %s\n",
656 psmouse
->ps2dev
.serio
->phys
);
658 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
663 * psmouse_cleanup() resets the mouse into power-on state.
666 static void psmouse_cleanup(struct serio
*serio
)
668 struct psmouse
*psmouse
= serio_get_drvdata(serio
);
670 psmouse_reset(psmouse
);
674 * psmouse_disconnect() closes and frees.
677 static void psmouse_disconnect(struct serio
*serio
)
679 struct psmouse
*psmouse
, *parent
= NULL
;
681 psmouse
= serio_get_drvdata(serio
);
683 device_remove_file(&serio
->dev
, &psmouse_attr_rate
);
684 device_remove_file(&serio
->dev
, &psmouse_attr_resolution
);
685 device_remove_file(&serio
->dev
, &psmouse_attr_resetafter
);
689 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
691 if (serio
->parent
&& serio
->id
.type
== SERIO_PS_PSTHRU
) {
692 parent
= serio_get_drvdata(serio
->parent
);
693 psmouse_deactivate(parent
);
696 if (psmouse
->disconnect
)
697 psmouse
->disconnect(psmouse
);
699 if (parent
&& parent
->pt_deactivate
)
700 parent
->pt_deactivate(parent
);
702 psmouse_set_state(psmouse
, PSMOUSE_IGNORE
);
704 input_unregister_device(&psmouse
->dev
);
706 serio_set_drvdata(serio
, NULL
);
710 psmouse_activate(parent
);
716 * psmouse_connect() is a callback from the serio module when
717 * an unhandled serio port is found.
719 static int psmouse_connect(struct serio
*serio
, struct serio_driver
*drv
)
721 struct psmouse
*psmouse
, *parent
= NULL
;
727 * If this is a pass-through port deactivate parent so the device
728 * connected to this port can be successfully identified
730 if (serio
->parent
&& serio
->id
.type
== SERIO_PS_PSTHRU
) {
731 parent
= serio_get_drvdata(serio
->parent
);
732 psmouse_deactivate(parent
);
735 if (!(psmouse
= kcalloc(1, sizeof(struct psmouse
), GFP_KERNEL
))) {
740 ps2_init(&psmouse
->ps2dev
, serio
);
741 sprintf(psmouse
->phys
, "%s/input0", serio
->phys
);
742 psmouse
->dev
.evbit
[0] = BIT(EV_KEY
) | BIT(EV_REL
);
743 psmouse
->dev
.keybit
[LONG(BTN_MOUSE
)] = BIT(BTN_LEFT
) | BIT(BTN_MIDDLE
) | BIT(BTN_RIGHT
);
744 psmouse
->dev
.relbit
[0] = BIT(REL_X
) | BIT(REL_Y
);
745 psmouse
->dev
.private = psmouse
;
746 psmouse
->dev
.dev
= &serio
->dev
;
747 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
749 serio_set_drvdata(serio
, psmouse
);
751 retval
= serio_open(serio
, drv
);
753 serio_set_drvdata(serio
, NULL
);
758 if (psmouse_probe(psmouse
) < 0) {
760 serio_set_drvdata(serio
, NULL
);
766 psmouse
->rate
= psmouse_rate
;
767 psmouse
->resolution
= psmouse_resolution
;
768 psmouse
->resetafter
= psmouse_resetafter
;
769 psmouse
->smartscroll
= psmouse_smartscroll
;
770 psmouse
->set_rate
= psmouse_set_rate
;
771 psmouse
->set_resolution
= psmouse_set_resolution
;
772 psmouse
->protocol_handler
= psmouse_process_byte
;
773 psmouse
->pktsize
= 3;
775 psmouse
->type
= psmouse_extensions(psmouse
, psmouse_max_proto
, 1);
777 sprintf(psmouse
->devname
, "%s %s %s",
778 psmouse_protocols
[psmouse
->type
], psmouse
->vendor
, psmouse
->name
);
780 psmouse
->dev
.name
= psmouse
->devname
;
781 psmouse
->dev
.phys
= psmouse
->phys
;
782 psmouse
->dev
.id
.bustype
= BUS_I8042
;
783 psmouse
->dev
.id
.vendor
= 0x0002;
784 psmouse
->dev
.id
.product
= psmouse
->type
;
785 psmouse
->dev
.id
.version
= psmouse
->model
;
787 input_register_device(&psmouse
->dev
);
789 printk(KERN_INFO
"input: %s on %s\n", psmouse
->devname
, serio
->phys
);
791 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
793 psmouse_initialize(psmouse
);
795 if (parent
&& parent
->pt_activate
)
796 parent
->pt_activate(parent
);
798 device_create_file(&serio
->dev
, &psmouse_attr_rate
);
799 device_create_file(&serio
->dev
, &psmouse_attr_resolution
);
800 device_create_file(&serio
->dev
, &psmouse_attr_resetafter
);
802 psmouse_activate(psmouse
);
807 /* If this is a pass-through port the parent needs to be re-activated */
809 psmouse_activate(parent
);
816 static int psmouse_reconnect(struct serio
*serio
)
818 struct psmouse
*psmouse
= serio_get_drvdata(serio
);
819 struct psmouse
*parent
= NULL
;
820 struct serio_driver
*drv
= serio
->drv
;
823 if (!drv
|| !psmouse
) {
824 printk(KERN_DEBUG
"psmouse: reconnect request, but serio is disconnected, ignoring...\n");
830 if (serio
->parent
&& serio
->id
.type
== SERIO_PS_PSTHRU
) {
831 parent
= serio_get_drvdata(serio
->parent
);
832 psmouse_deactivate(parent
);
835 psmouse_set_state(psmouse
, PSMOUSE_INITIALIZING
);
837 if (psmouse
->reconnect
) {
838 if (psmouse
->reconnect(psmouse
))
840 } else if (psmouse_probe(psmouse
) < 0 ||
841 psmouse
->type
!= psmouse_extensions(psmouse
, psmouse_max_proto
, 0))
844 /* ok, the device type (and capabilities) match the old one,
845 * we can continue using it, complete intialization
847 psmouse_set_state(psmouse
, PSMOUSE_CMD_MODE
);
849 psmouse_initialize(psmouse
);
851 if (parent
&& parent
->pt_activate
)
852 parent
->pt_activate(parent
);
854 psmouse_activate(psmouse
);
858 /* If this is a pass-through port the parent waits to be activated */
860 psmouse_activate(parent
);
866 static struct serio_device_id psmouse_serio_ids
[] = {
874 .type
= SERIO_PS_PSTHRU
,
882 MODULE_DEVICE_TABLE(serio
, psmouse_serio_ids
);
884 static struct serio_driver psmouse_drv
= {
888 .description
= DRIVER_DESC
,
889 .id_table
= psmouse_serio_ids
,
890 .interrupt
= psmouse_interrupt
,
891 .connect
= psmouse_connect
,
892 .reconnect
= psmouse_reconnect
,
893 .disconnect
= psmouse_disconnect
,
894 .cleanup
= psmouse_cleanup
,
897 ssize_t
psmouse_attr_show_helper(struct device
*dev
, char *buf
,
898 ssize_t (*handler
)(struct psmouse
*, char *))
900 struct serio
*serio
= to_serio_port(dev
);
903 retval
= serio_pin_driver(serio
);
907 if (serio
->drv
!= &psmouse_drv
) {
912 retval
= handler(serio_get_drvdata(serio
), buf
);
915 serio_unpin_driver(serio
);
919 ssize_t
psmouse_attr_set_helper(struct device
*dev
, const char *buf
, size_t count
,
920 ssize_t (*handler
)(struct psmouse
*, const char *, size_t))
922 struct serio
*serio
= to_serio_port(dev
);
923 struct psmouse
*psmouse
= serio_get_drvdata(serio
);
924 struct psmouse
*parent
= NULL
;
927 retval
= serio_pin_driver(serio
);
931 if (serio
->drv
!= &psmouse_drv
) {
936 retval
= down_interruptible(&psmouse_sem
);
940 if (psmouse
->state
== PSMOUSE_IGNORE
) {
945 if (serio
->parent
&& serio
->id
.type
== SERIO_PS_PSTHRU
) {
946 parent
= serio_get_drvdata(serio
->parent
);
947 psmouse_deactivate(parent
);
949 psmouse_deactivate(psmouse
);
951 retval
= handler(psmouse
, buf
, count
);
953 psmouse_activate(psmouse
);
955 psmouse_activate(parent
);
960 serio_unpin_driver(serio
);
964 static ssize_t
psmouse_attr_show_rate(struct psmouse
*psmouse
, char *buf
)
966 return sprintf(buf
, "%d\n", psmouse
->rate
);
969 static ssize_t
psmouse_attr_set_rate(struct psmouse
*psmouse
, const char *buf
, size_t count
)
974 value
= simple_strtoul(buf
, &rest
, 10);
978 psmouse
->set_rate(psmouse
, value
);
982 static ssize_t
psmouse_attr_show_resolution(struct psmouse
*psmouse
, char *buf
)
984 return sprintf(buf
, "%d\n", psmouse
->resolution
);
987 static ssize_t
psmouse_attr_set_resolution(struct psmouse
*psmouse
, const char *buf
, size_t count
)
992 value
= simple_strtoul(buf
, &rest
, 10);
996 psmouse
->set_resolution(psmouse
, value
);
1000 static ssize_t
psmouse_attr_show_resetafter(struct psmouse
*psmouse
, char *buf
)
1002 return sprintf(buf
, "%d\n", psmouse
->resetafter
);
1005 static ssize_t
psmouse_attr_set_resetafter(struct psmouse
*psmouse
, const char *buf
, size_t count
)
1007 unsigned long value
;
1010 value
= simple_strtoul(buf
, &rest
, 10);
1014 psmouse
->resetafter
= value
;
1018 static int psmouse_set_maxproto(const char *val
, struct kernel_param
*kp
)
1025 if (!strncmp(val
, "any", 3)) {
1026 *((unsigned int *)kp
->arg
) = -1U;
1030 for (i
= 0; i
< ARRAY_SIZE(psmouse_proto_abbrev
); i
++) {
1031 if (!psmouse_proto_abbrev
[i
])
1034 if (!strncmp(val
, psmouse_proto_abbrev
[i
], strlen(psmouse_proto_abbrev
[i
]))) {
1035 *((unsigned int *)kp
->arg
) = i
;
1043 static int psmouse_get_maxproto(char *buffer
, struct kernel_param
*kp
)
1045 return sprintf(buffer
, "%s\n",
1046 psmouse_max_proto
< ARRAY_SIZE(psmouse_proto_abbrev
) ?
1047 psmouse_proto_abbrev
[psmouse_max_proto
] : "any");
1050 static int __init
psmouse_init(void)
1052 serio_register_driver(&psmouse_drv
);
1056 static void __exit
psmouse_exit(void)
1058 serio_unregister_driver(&psmouse_drv
);
1061 module_init(psmouse_init
);
1062 module_exit(psmouse_exit
);