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/sched.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/input.h>
20 #include <linux/serio.h>
21 #include <linux/i8042.h>
22 #include <linux/init.h>
23 #include <linux/libps2.h>
25 #define DRIVER_DESC "PS/2 driver library"
27 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
28 MODULE_DESCRIPTION("PS/2 driver library");
29 MODULE_LICENSE("GPL");
32 * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
33 * It doesn't handle retransmission, though it could - because if there
34 * is a need for retransmissions device has to be replaced anyway.
36 * ps2_sendbyte() can only be called from a process context.
39 int ps2_sendbyte(struct ps2dev
*ps2dev
, unsigned char byte
, int timeout
)
41 serio_pause_rx(ps2dev
->serio
);
43 ps2dev
->flags
|= PS2_FLAG_ACK
;
44 serio_continue_rx(ps2dev
->serio
);
46 if (serio_write(ps2dev
->serio
, byte
) == 0)
47 wait_event_timeout(ps2dev
->wait
,
48 !(ps2dev
->flags
& PS2_FLAG_ACK
),
49 msecs_to_jiffies(timeout
));
51 serio_pause_rx(ps2dev
->serio
);
52 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
53 serio_continue_rx(ps2dev
->serio
);
57 EXPORT_SYMBOL(ps2_sendbyte
);
59 void ps2_begin_command(struct ps2dev
*ps2dev
)
61 mutex_lock(&ps2dev
->cmd_mutex
);
63 if (i8042_check_port_owner(ps2dev
->serio
))
66 EXPORT_SYMBOL(ps2_begin_command
);
68 void ps2_end_command(struct ps2dev
*ps2dev
)
70 if (i8042_check_port_owner(ps2dev
->serio
))
73 mutex_unlock(&ps2dev
->cmd_mutex
);
75 EXPORT_SYMBOL(ps2_end_command
);
78 * ps2_drain() waits for device to transmit requested number of bytes
82 void ps2_drain(struct ps2dev
*ps2dev
, int maxbytes
, int timeout
)
84 if (maxbytes
> sizeof(ps2dev
->cmdbuf
)) {
86 maxbytes
= sizeof(ps2dev
->cmdbuf
);
89 ps2_begin_command(ps2dev
);
91 serio_pause_rx(ps2dev
->serio
);
92 ps2dev
->flags
= PS2_FLAG_CMD
;
93 ps2dev
->cmdcnt
= maxbytes
;
94 serio_continue_rx(ps2dev
->serio
);
96 wait_event_timeout(ps2dev
->wait
,
97 !(ps2dev
->flags
& PS2_FLAG_CMD
),
98 msecs_to_jiffies(timeout
));
100 ps2_end_command(ps2dev
);
102 EXPORT_SYMBOL(ps2_drain
);
105 * ps2_is_keyboard_id() checks received ID byte against the list of
106 * known keyboard IDs.
109 int ps2_is_keyboard_id(char id_byte
)
111 static const char keyboard_ids
[] = {
112 0xab, /* Regular keyboards */
113 0xac, /* NCD Sun keyboard */
114 0x2b, /* Trust keyboard, translated */
115 0x5d, /* Trust keyboard */
116 0x60, /* NMB SGI keyboard, translated */
117 0x47, /* NMB SGI keyboard */
120 return memchr(keyboard_ids
, id_byte
, sizeof(keyboard_ids
)) != NULL
;
122 EXPORT_SYMBOL(ps2_is_keyboard_id
);
125 * ps2_adjust_timeout() is called after receiving 1st byte of command
126 * response and tries to reduce remaining timeout to speed up command
130 static int ps2_adjust_timeout(struct ps2dev
*ps2dev
, int command
, int timeout
)
133 case PS2_CMD_RESET_BAT
:
135 * Device has sent the first response byte after
136 * reset command, reset is thus done, so we can
137 * shorten the timeout.
138 * The next byte will come soon (keyboard) or not
141 if (timeout
> msecs_to_jiffies(100))
142 timeout
= msecs_to_jiffies(100);
147 * Microsoft Natural Elite keyboard responds to
148 * the GET ID command as it were a mouse, with
149 * a single byte. Fail the command so atkbd will
150 * use alternative probe to detect it.
152 if (ps2dev
->cmdbuf
[1] == 0xaa) {
153 serio_pause_rx(ps2dev
->serio
);
155 serio_continue_rx(ps2dev
->serio
);
160 * If device behind the port is not a keyboard there
161 * won't be 2nd byte of ID response.
163 if (!ps2_is_keyboard_id(ps2dev
->cmdbuf
[1])) {
164 serio_pause_rx(ps2dev
->serio
);
165 ps2dev
->flags
= ps2dev
->cmdcnt
= 0;
166 serio_continue_rx(ps2dev
->serio
);
179 * ps2_command() sends a command and its parameters to the mouse,
180 * then waits for the response and puts it in the param array.
182 * ps2_command() can only be called from a process context
185 int __ps2_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
188 int send
= (command
>> 12) & 0xf;
189 int receive
= (command
>> 8) & 0xf;
193 if (receive
> sizeof(ps2dev
->cmdbuf
)) {
198 if (send
&& !param
) {
203 serio_pause_rx(ps2dev
->serio
);
204 ps2dev
->flags
= command
== PS2_CMD_GETID
? PS2_FLAG_WAITID
: 0;
205 ps2dev
->cmdcnt
= receive
;
206 if (receive
&& param
)
207 for (i
= 0; i
< receive
; i
++)
208 ps2dev
->cmdbuf
[(receive
- 1) - i
] = param
[i
];
209 serio_continue_rx(ps2dev
->serio
);
212 * Some devices (Synaptics) peform the reset before
213 * ACKing the reset command, and so it can take a long
214 * time before the ACK arrrives.
216 if (ps2_sendbyte(ps2dev
, command
& 0xff,
217 command
== PS2_CMD_RESET_BAT
? 1000 : 200))
220 for (i
= 0; i
< send
; i
++)
221 if (ps2_sendbyte(ps2dev
, param
[i
], 200))
225 * The reset command takes a long time to execute.
227 timeout
= msecs_to_jiffies(command
== PS2_CMD_RESET_BAT
? 4000 : 500);
229 timeout
= wait_event_timeout(ps2dev
->wait
,
230 !(ps2dev
->flags
& PS2_FLAG_CMD1
), timeout
);
232 if (ps2dev
->cmdcnt
&& !(ps2dev
->flags
& PS2_FLAG_CMD1
)) {
234 timeout
= ps2_adjust_timeout(ps2dev
, command
, timeout
);
235 wait_event_timeout(ps2dev
->wait
,
236 !(ps2dev
->flags
& PS2_FLAG_CMD
), timeout
);
240 for (i
= 0; i
< receive
; i
++)
241 param
[i
] = ps2dev
->cmdbuf
[(receive
- 1) - i
];
243 if (ps2dev
->cmdcnt
&& (command
!= PS2_CMD_RESET_BAT
|| ps2dev
->cmdcnt
!= 1))
249 serio_pause_rx(ps2dev
->serio
);
251 serio_continue_rx(ps2dev
->serio
);
255 EXPORT_SYMBOL(__ps2_command
);
257 int ps2_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
261 ps2_begin_command(ps2dev
);
262 rc
= __ps2_command(ps2dev
, param
, command
);
263 ps2_end_command(ps2dev
);
267 EXPORT_SYMBOL(ps2_command
);
270 * ps2_init() initializes ps2dev structure
273 void ps2_init(struct ps2dev
*ps2dev
, struct serio
*serio
)
275 mutex_init(&ps2dev
->cmd_mutex
);
276 lockdep_set_subclass(&ps2dev
->cmd_mutex
, serio
->depth
);
277 init_waitqueue_head(&ps2dev
->wait
);
278 ps2dev
->serio
= serio
;
280 EXPORT_SYMBOL(ps2_init
);
283 * ps2_handle_ack() is supposed to be used in interrupt handler
284 * to properly process ACK/NAK of a command from a PS/2 device.
287 int ps2_handle_ack(struct ps2dev
*ps2dev
, unsigned char data
)
295 ps2dev
->flags
|= PS2_FLAG_NAK
;
296 ps2dev
->nak
= PS2_RET_NAK
;
300 if (ps2dev
->flags
& PS2_FLAG_NAK
) {
301 ps2dev
->flags
&= ~PS2_FLAG_NAK
;
302 ps2dev
->nak
= PS2_RET_ERR
;
307 * Workaround for mice which don't ACK the Get ID command.
308 * These are valid mouse IDs that we recognize.
313 if (ps2dev
->flags
& PS2_FLAG_WAITID
) {
324 ps2dev
->flags
&= ~PS2_FLAG_NAK
;
326 ps2dev
->flags
|= PS2_FLAG_CMD
| PS2_FLAG_CMD1
;
329 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
330 wake_up(&ps2dev
->wait
);
332 if (data
!= PS2_RET_ACK
)
333 ps2_handle_response(ps2dev
, data
);
337 EXPORT_SYMBOL(ps2_handle_ack
);
340 * ps2_handle_response() is supposed to be used in interrupt handler
341 * to properly store device's response to a command and notify process
342 * waiting for completion of the command.
345 int ps2_handle_response(struct ps2dev
*ps2dev
, unsigned char data
)
348 ps2dev
->cmdbuf
[--ps2dev
->cmdcnt
] = data
;
350 if (ps2dev
->flags
& PS2_FLAG_CMD1
) {
351 ps2dev
->flags
&= ~PS2_FLAG_CMD1
;
353 wake_up(&ps2dev
->wait
);
356 if (!ps2dev
->cmdcnt
) {
357 ps2dev
->flags
&= ~PS2_FLAG_CMD
;
358 wake_up(&ps2dev
->wait
);
363 EXPORT_SYMBOL(ps2_handle_response
);
365 void ps2_cmd_aborted(struct ps2dev
*ps2dev
)
367 if (ps2dev
->flags
& PS2_FLAG_ACK
)
370 if (ps2dev
->flags
& (PS2_FLAG_ACK
| PS2_FLAG_CMD
))
371 wake_up(&ps2dev
->wait
);
373 /* reset all flags except last nack */
374 ps2dev
->flags
&= PS2_FLAG_NAK
;
376 EXPORT_SYMBOL(ps2_cmd_aborted
);
This page took 0.037696 seconds and 6 git commands to generate.