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/interrupt.h>
18 #include <linux/input.h>
19 #include <linux/serio.h>
20 #include <linux/i8042.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");
31 * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
32 * It doesn't handle retransmission, though it could - because if there
33 * is a need for retransmissions device has to be replaced anyway.
35 * ps2_sendbyte() can only be called from a process context.
38 int ps2_sendbyte(struct ps2dev
*ps2dev
, unsigned char byte
, int timeout
)
40 serio_pause_rx(ps2dev
->serio
);
42 ps2dev
->flags
|= PS2_FLAG_ACK
;
43 serio_continue_rx(ps2dev
->serio
);
45 if (serio_write(ps2dev
->serio
, byte
) == 0)
46 wait_event_timeout(ps2dev
->wait
,
47 !(ps2dev
->flags
& PS2_FLAG_ACK
),
48 msecs_to_jiffies(timeout
));
50 serio_pause_rx(ps2dev
->serio
);
51 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
52 serio_continue_rx(ps2dev
->serio
);
56 EXPORT_SYMBOL(ps2_sendbyte
);
58 void ps2_begin_command(struct ps2dev
*ps2dev
)
60 mutex_lock(&ps2dev
->cmd_mutex
);
62 if (i8042_check_port_owner(ps2dev
->serio
))
65 EXPORT_SYMBOL(ps2_begin_command
);
67 void ps2_end_command(struct ps2dev
*ps2dev
)
69 if (i8042_check_port_owner(ps2dev
->serio
))
72 mutex_unlock(&ps2dev
->cmd_mutex
);
74 EXPORT_SYMBOL(ps2_end_command
);
77 * ps2_drain() waits for device to transmit requested number of bytes
81 void ps2_drain(struct ps2dev
*ps2dev
, int maxbytes
, int timeout
)
83 if (maxbytes
> sizeof(ps2dev
->cmdbuf
)) {
85 maxbytes
= sizeof(ps2dev
->cmdbuf
);
88 ps2_begin_command(ps2dev
);
90 serio_pause_rx(ps2dev
->serio
);
91 ps2dev
->flags
= PS2_FLAG_CMD
;
92 ps2dev
->cmdcnt
= maxbytes
;
93 serio_continue_rx(ps2dev
->serio
);
95 wait_event_timeout(ps2dev
->wait
,
96 !(ps2dev
->flags
& PS2_FLAG_CMD
),
97 msecs_to_jiffies(timeout
));
99 ps2_end_command(ps2dev
);
101 EXPORT_SYMBOL(ps2_drain
);
104 * ps2_is_keyboard_id() checks received ID byte against the list of
105 * known keyboard IDs.
108 int ps2_is_keyboard_id(char id_byte
)
110 static const char keyboard_ids
[] = {
111 0xab, /* Regular keyboards */
112 0xac, /* NCD Sun keyboard */
113 0x2b, /* Trust keyboard, translated */
114 0x5d, /* Trust keyboard */
115 0x60, /* NMB SGI keyboard, translated */
116 0x47, /* NMB SGI keyboard */
119 return memchr(keyboard_ids
, id_byte
, sizeof(keyboard_ids
)) != NULL
;
121 EXPORT_SYMBOL(ps2_is_keyboard_id
);
124 * ps2_adjust_timeout() is called after receiving 1st byte of command
125 * response and tries to reduce remaining timeout to speed up command
129 static int ps2_adjust_timeout(struct ps2dev
*ps2dev
, int command
, int timeout
)
132 case PS2_CMD_RESET_BAT
:
134 * Device has sent the first response byte after
135 * reset command, reset is thus done, so we can
136 * shorten the timeout.
137 * The next byte will come soon (keyboard) or not
140 if (timeout
> msecs_to_jiffies(100))
141 timeout
= msecs_to_jiffies(100);
146 * Microsoft Natural Elite keyboard responds to
147 * the GET ID command as it were a mouse, with
148 * a single byte. Fail the command so atkbd will
149 * use alternative probe to detect it.
151 if (ps2dev
->cmdbuf
[1] == 0xaa) {
152 serio_pause_rx(ps2dev
->serio
);
154 serio_continue_rx(ps2dev
->serio
);
159 * If device behind the port is not a keyboard there
160 * won't be 2nd byte of ID response.
162 if (!ps2_is_keyboard_id(ps2dev
->cmdbuf
[1])) {
163 serio_pause_rx(ps2dev
->serio
);
164 ps2dev
->flags
= ps2dev
->cmdcnt
= 0;
165 serio_continue_rx(ps2dev
->serio
);
178 * ps2_command() sends a command and its parameters to the mouse,
179 * then waits for the response and puts it in the param array.
181 * ps2_command() can only be called from a process context
184 int __ps2_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
187 int send
= (command
>> 12) & 0xf;
188 int receive
= (command
>> 8) & 0xf;
192 if (receive
> sizeof(ps2dev
->cmdbuf
)) {
197 if (send
&& !param
) {
202 serio_pause_rx(ps2dev
->serio
);
203 ps2dev
->flags
= command
== PS2_CMD_GETID
? PS2_FLAG_WAITID
: 0;
204 ps2dev
->cmdcnt
= receive
;
205 if (receive
&& param
)
206 for (i
= 0; i
< receive
; i
++)
207 ps2dev
->cmdbuf
[(receive
- 1) - i
] = param
[i
];
208 serio_continue_rx(ps2dev
->serio
);
211 * Some devices (Synaptics) peform the reset before
212 * ACKing the reset command, and so it can take a long
213 * time before the ACK arrrives.
215 if (ps2_sendbyte(ps2dev
, command
& 0xff,
216 command
== PS2_CMD_RESET_BAT
? 1000 : 200))
219 for (i
= 0; i
< send
; i
++)
220 if (ps2_sendbyte(ps2dev
, param
[i
], 200))
224 * The reset command takes a long time to execute.
226 timeout
= msecs_to_jiffies(command
== PS2_CMD_RESET_BAT
? 4000 : 500);
228 timeout
= wait_event_timeout(ps2dev
->wait
,
229 !(ps2dev
->flags
& PS2_FLAG_CMD1
), timeout
);
231 if (ps2dev
->cmdcnt
&& !(ps2dev
->flags
& PS2_FLAG_CMD1
)) {
233 timeout
= ps2_adjust_timeout(ps2dev
, command
, timeout
);
234 wait_event_timeout(ps2dev
->wait
,
235 !(ps2dev
->flags
& PS2_FLAG_CMD
), timeout
);
239 for (i
= 0; i
< receive
; i
++)
240 param
[i
] = ps2dev
->cmdbuf
[(receive
- 1) - i
];
242 if (ps2dev
->cmdcnt
&& (command
!= PS2_CMD_RESET_BAT
|| ps2dev
->cmdcnt
!= 1))
248 serio_pause_rx(ps2dev
->serio
);
250 serio_continue_rx(ps2dev
->serio
);
254 EXPORT_SYMBOL(__ps2_command
);
256 int ps2_command(struct ps2dev
*ps2dev
, unsigned char *param
, int command
)
260 ps2_begin_command(ps2dev
);
261 rc
= __ps2_command(ps2dev
, param
, command
);
262 ps2_end_command(ps2dev
);
266 EXPORT_SYMBOL(ps2_command
);
269 * ps2_init() initializes ps2dev structure
272 void ps2_init(struct ps2dev
*ps2dev
, struct serio
*serio
)
274 mutex_init(&ps2dev
->cmd_mutex
);
275 lockdep_set_subclass(&ps2dev
->cmd_mutex
, serio
->depth
);
276 init_waitqueue_head(&ps2dev
->wait
);
277 ps2dev
->serio
= serio
;
279 EXPORT_SYMBOL(ps2_init
);
282 * ps2_handle_ack() is supposed to be used in interrupt handler
283 * to properly process ACK/NAK of a command from a PS/2 device.
286 int ps2_handle_ack(struct ps2dev
*ps2dev
, unsigned char data
)
294 ps2dev
->flags
|= PS2_FLAG_NAK
;
295 ps2dev
->nak
= PS2_RET_NAK
;
299 if (ps2dev
->flags
& PS2_FLAG_NAK
) {
300 ps2dev
->flags
&= ~PS2_FLAG_NAK
;
301 ps2dev
->nak
= PS2_RET_ERR
;
306 * Workaround for mice which don't ACK the Get ID command.
307 * These are valid mouse IDs that we recognize.
312 if (ps2dev
->flags
& PS2_FLAG_WAITID
) {
323 ps2dev
->flags
&= ~PS2_FLAG_NAK
;
325 ps2dev
->flags
|= PS2_FLAG_CMD
| PS2_FLAG_CMD1
;
328 ps2dev
->flags
&= ~PS2_FLAG_ACK
;
329 wake_up(&ps2dev
->wait
);
331 if (data
!= PS2_RET_ACK
)
332 ps2_handle_response(ps2dev
, data
);
336 EXPORT_SYMBOL(ps2_handle_ack
);
339 * ps2_handle_response() is supposed to be used in interrupt handler
340 * to properly store device's response to a command and notify process
341 * waiting for completion of the command.
344 int ps2_handle_response(struct ps2dev
*ps2dev
, unsigned char data
)
347 ps2dev
->cmdbuf
[--ps2dev
->cmdcnt
] = data
;
349 if (ps2dev
->flags
& PS2_FLAG_CMD1
) {
350 ps2dev
->flags
&= ~PS2_FLAG_CMD1
;
352 wake_up(&ps2dev
->wait
);
355 if (!ps2dev
->cmdcnt
) {
356 ps2dev
->flags
&= ~PS2_FLAG_CMD
;
357 wake_up(&ps2dev
->wait
);
362 EXPORT_SYMBOL(ps2_handle_response
);
364 void ps2_cmd_aborted(struct ps2dev
*ps2dev
)
366 if (ps2dev
->flags
& PS2_FLAG_ACK
)
369 if (ps2dev
->flags
& (PS2_FLAG_ACK
| PS2_FLAG_CMD
))
370 wake_up(&ps2dev
->wait
);
372 /* reset all flags except last nack */
373 ps2dev
->flags
&= PS2_FLAG_NAK
;
375 EXPORT_SYMBOL(ps2_cmd_aborted
);
This page took 0.040406 seconds and 5 git commands to generate.