4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 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 #define DRIVER_DESC "PS/2 driver library"
26 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
27 MODULE_DESCRIPTION("PS/2 driver library");
28 MODULE_LICENSE("GPL");
30 EXPORT_SYMBOL(ps2_init
);
31 EXPORT_SYMBOL(ps2_sendbyte
);
32 EXPORT_SYMBOL(ps2_drain
);
33 EXPORT_SYMBOL(ps2_command
);
34 EXPORT_SYMBOL(ps2_schedule_command
);
35 EXPORT_SYMBOL(ps2_handle_ack
);
36 EXPORT_SYMBOL(ps2_handle_response
);
37 EXPORT_SYMBOL(ps2_cmd_aborted
);
39 /* Work structure to schedule execution of a command */
41 struct work_struct work
;
42 struct ps2dev
*ps2dev
;
44 unsigned char param
[0];
49 * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
50 * It doesn't handle retransmission, though it could - because if there
51 * is a need for retransmissions device has to be replaced anyway.
53 * ps2_sendbyte() can only be called from a process context.
56 int ps2_sendbyte(struct ps2dev
*ps2dev
, unsigned char byte
, int timeout
)
58 serio_pause_rx(ps2dev
->serio
);
60 ps2dev
->flags
|= PS2_FLAG_ACK
;
61 serio_continue_rx(ps2dev
->serio
);
63 if (serio_write(ps2dev
->serio
, byte
) == 0)
64 wait_event_timeout(ps2dev
->wait
,
65 !(ps2dev
->flags
& PS2_FLAG_ACK
),
66 msecs_to_jiffies(timeout
));
68 serio_pause_rx(ps2dev
->serio
);
69 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
70 serio_continue_rx(ps2dev
->serio
);
76 * ps2_drain() waits for device to transmit requested number of bytes
80 void ps2_drain(struct ps2dev
*ps2dev
, int maxbytes
, int timeout
)
82 if (maxbytes
> sizeof(ps2dev
->cmdbuf
)) {
84 maxbytes
= sizeof(ps2dev
->cmdbuf
);
87 down(&ps2dev
->cmd_sem
);
89 serio_pause_rx(ps2dev
->serio
);
90 ps2dev
->flags
= PS2_FLAG_CMD
;
91 ps2dev
->cmdcnt
= maxbytes
;
92 serio_continue_rx(ps2dev
->serio
);
94 wait_event_timeout(ps2dev
->wait
,
95 !(ps2dev
->flags
& PS2_FLAG_CMD
),
96 msecs_to_jiffies(timeout
));
101 * ps2_command() sends a command and its parameters to the mouse,
102 * then waits for the response and puts it in the param array.
104 * ps2_command() can only be called from a process context
107 int ps2_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
110 int send
= (command
>> 12) & 0xf;
111 int receive
= (command
>> 8) & 0xf;
115 if (receive
> sizeof(ps2dev
->cmdbuf
)) {
120 down(&ps2dev
->cmd_sem
);
122 serio_pause_rx(ps2dev
->serio
);
123 ps2dev
->flags
= command
== PS2_CMD_GETID
? PS2_FLAG_WAITID
: 0;
124 ps2dev
->cmdcnt
= receive
;
125 if (receive
&& param
)
126 for (i
= 0; i
< receive
; i
++)
127 ps2dev
->cmdbuf
[(receive
- 1) - i
] = param
[i
];
128 serio_continue_rx(ps2dev
->serio
);
131 * Some devices (Synaptics) peform the reset before
132 * ACKing the reset command, and so it can take a long
133 * time before the ACK arrrives.
135 if (ps2_sendbyte(ps2dev
, command
& 0xff,
136 command
== PS2_CMD_RESET_BAT
? 1000 : 200))
139 for (i
= 0; i
< send
; i
++)
140 if (ps2_sendbyte(ps2dev
, param
[i
], 200))
144 * The reset command takes a long time to execute.
146 timeout
= msecs_to_jiffies(command
== PS2_CMD_RESET_BAT
? 4000 : 500);
148 timeout
= wait_event_timeout(ps2dev
->wait
,
149 !(ps2dev
->flags
& PS2_FLAG_CMD1
), timeout
);
151 if (ps2dev
->cmdcnt
&& timeout
> 0) {
153 if (command
== PS2_CMD_RESET_BAT
&& timeout
> msecs_to_jiffies(100)) {
155 * Device has sent the first response byte
156 * after a reset command, reset is thus done,
157 * shorten the timeout. The next byte will come
158 * soon (keyboard) or not at all (mouse).
160 timeout
= msecs_to_jiffies(100);
163 if (command
== PS2_CMD_GETID
&&
164 ps2dev
->cmdbuf
[receive
- 1] != 0xab && /* Regular keyboards */
165 ps2dev
->cmdbuf
[receive
- 1] != 0xac && /* NCD Sun keyboard */
166 ps2dev
->cmdbuf
[receive
- 1] != 0x2b && /* Trust keyboard, translated */
167 ps2dev
->cmdbuf
[receive
- 1] != 0x5d && /* Trust keyboard */
168 ps2dev
->cmdbuf
[receive
- 1] != 0x60 && /* NMB SGI keyboard, translated */
169 ps2dev
->cmdbuf
[receive
- 1] != 0x47) { /* NMB SGI keyboard */
171 * Device behind the port is not a keyboard
172 * so we don't need to wait for the 2nd byte
175 serio_pause_rx(ps2dev
->serio
);
176 ps2dev
->flags
= ps2dev
->cmdcnt
= 0;
177 serio_continue_rx(ps2dev
->serio
);
180 wait_event_timeout(ps2dev
->wait
,
181 !(ps2dev
->flags
& PS2_FLAG_CMD
), timeout
);
185 for (i
= 0; i
< receive
; i
++)
186 param
[i
] = ps2dev
->cmdbuf
[(receive
- 1) - i
];
188 if (ps2dev
->cmdcnt
&& (command
!= PS2_CMD_RESET_BAT
|| ps2dev
->cmdcnt
!= 1))
194 serio_pause_rx(ps2dev
->serio
);
196 serio_continue_rx(ps2dev
->serio
);
198 up(&ps2dev
->cmd_sem
);
203 * ps2_execute_scheduled_command() sends a command, previously scheduled by
204 * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
207 static void ps2_execute_scheduled_command(void *data
)
209 struct ps2work
*ps2work
= data
;
211 ps2_command(ps2work
->ps2dev
, ps2work
->param
, ps2work
->command
);
216 * ps2_schedule_command() allows to schedule delayed execution of a PS/2
217 * command and can be used to issue a command from an interrupt or softirq
221 int ps2_schedule_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
223 struct ps2work
*ps2work
;
224 int send
= (command
>> 12) & 0xf;
225 int receive
= (command
>> 8) & 0xf;
227 if (!(ps2work
= kmalloc(sizeof(struct ps2work
) + max(send
, receive
), GFP_ATOMIC
)))
230 memset(ps2work
, 0, sizeof(struct ps2work
));
231 ps2work
->ps2dev
= ps2dev
;
232 ps2work
->command
= command
;
233 memcpy(ps2work
->param
, param
, send
);
234 INIT_WORK(&ps2work
->work
, ps2_execute_scheduled_command
, ps2work
);
236 if (!schedule_work(&ps2work
->work
)) {
245 * ps2_init() initializes ps2dev structure
248 void ps2_init(struct ps2dev
*ps2dev
, struct serio
*serio
)
250 init_MUTEX(&ps2dev
->cmd_sem
);
251 init_waitqueue_head(&ps2dev
->wait
);
252 ps2dev
->serio
= serio
;
256 * ps2_handle_ack() is supposed to be used in interrupt handler
257 * to properly process ACK/NAK of a command from a PS/2 device.
260 int ps2_handle_ack(struct ps2dev
*ps2dev
, unsigned char data
)
272 * Workaround for mice which don't ACK the Get ID command.
273 * These are valid mouse IDs that we recognize.
278 if (ps2dev
->flags
& PS2_FLAG_WAITID
) {
288 if (!ps2dev
->nak
&& ps2dev
->cmdcnt
)
289 ps2dev
->flags
|= PS2_FLAG_CMD
| PS2_FLAG_CMD1
;
291 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
292 wake_up(&ps2dev
->wait
);
294 if (data
!= PS2_RET_ACK
)
295 ps2_handle_response(ps2dev
, data
);
301 * ps2_handle_response() is supposed to be used in interrupt handler
302 * to properly store device's response to a command and notify process
303 * waiting for completion of the command.
306 int ps2_handle_response(struct ps2dev
*ps2dev
, unsigned char data
)
309 ps2dev
->cmdbuf
[--ps2dev
->cmdcnt
] = data
;
311 if (ps2dev
->flags
& PS2_FLAG_CMD1
) {
312 ps2dev
->flags
&= ~PS2_FLAG_CMD1
;
314 wake_up(&ps2dev
->wait
);
317 if (!ps2dev
->cmdcnt
) {
318 ps2dev
->flags
&= ~PS2_FLAG_CMD
;
319 wake_up(&ps2dev
->wait
);
325 void ps2_cmd_aborted(struct ps2dev
*ps2dev
)
327 if (ps2dev
->flags
& PS2_FLAG_ACK
)
330 if (ps2dev
->flags
& (PS2_FLAG_ACK
| PS2_FLAG_CMD
))
331 wake_up(&ps2dev
->wait
);