Branch data Line data Source code
1 : : /*
2 : : * PS/2 driver library
3 : : *
4 : : * Copyright (c) 1999-2002 Vojtech Pavlik
5 : : * Copyright (c) 2004 Dmitry Torokhov
6 : : */
7 : :
8 : : /*
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.
12 : : */
13 : :
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>
23 : :
24 : : #define DRIVER_DESC "PS/2 driver library"
25 : :
26 : : MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
27 : : MODULE_DESCRIPTION("PS/2 driver library");
28 : : MODULE_LICENSE("GPL");
29 : :
30 : : /*
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.
34 : : *
35 : : * ps2_sendbyte() can only be called from a process context.
36 : : */
37 : :
38 : 0 : int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout)
39 : : {
40 : 0 : serio_pause_rx(ps2dev->serio);
41 : 0 : ps2dev->nak = 1;
42 : 0 : ps2dev->flags |= PS2_FLAG_ACK;
43 : 0 : serio_continue_rx(ps2dev->serio);
44 : :
45 [ # # ]: 0 : if (serio_write(ps2dev->serio, byte) == 0)
46 [ # # ][ # # ]: 0 : wait_event_timeout(ps2dev->wait,
[ # # ][ # # ]
47 : : !(ps2dev->flags & PS2_FLAG_ACK),
48 : : msecs_to_jiffies(timeout));
49 : :
50 : 0 : serio_pause_rx(ps2dev->serio);
51 : 0 : ps2dev->flags &= ~PS2_FLAG_ACK;
52 : 0 : serio_continue_rx(ps2dev->serio);
53 : :
54 : 0 : return -ps2dev->nak;
55 : : }
56 : : EXPORT_SYMBOL(ps2_sendbyte);
57 : :
58 : 0 : void ps2_begin_command(struct ps2dev *ps2dev)
59 : : {
60 : 0 : mutex_lock(&ps2dev->cmd_mutex);
61 : :
62 : : if (i8042_check_port_owner(ps2dev->serio))
63 : : i8042_lock_chip();
64 : 0 : }
65 : : EXPORT_SYMBOL(ps2_begin_command);
66 : :
67 : 0 : void ps2_end_command(struct ps2dev *ps2dev)
68 : : {
69 : : if (i8042_check_port_owner(ps2dev->serio))
70 : : i8042_unlock_chip();
71 : :
72 : 0 : mutex_unlock(&ps2dev->cmd_mutex);
73 : 0 : }
74 : : EXPORT_SYMBOL(ps2_end_command);
75 : :
76 : : /*
77 : : * ps2_drain() waits for device to transmit requested number of bytes
78 : : * and discards them.
79 : : */
80 : :
81 : 0 : void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
82 : : {
83 [ # # ]: 0 : if (maxbytes > sizeof(ps2dev->cmdbuf)) {
84 : 0 : WARN_ON(1);
85 : : maxbytes = sizeof(ps2dev->cmdbuf);
86 : : }
87 : :
88 : : ps2_begin_command(ps2dev);
89 : :
90 : 0 : serio_pause_rx(ps2dev->serio);
91 : 0 : ps2dev->flags = PS2_FLAG_CMD;
92 : 0 : ps2dev->cmdcnt = maxbytes;
93 : 0 : serio_continue_rx(ps2dev->serio);
94 : :
95 [ # # ][ # # ]: 0 : wait_event_timeout(ps2dev->wait,
[ # # ][ # # ]
96 : : !(ps2dev->flags & PS2_FLAG_CMD),
97 : : msecs_to_jiffies(timeout));
98 : :
99 : : ps2_end_command(ps2dev);
100 : 0 : }
101 : : EXPORT_SYMBOL(ps2_drain);
102 : :
103 : : /*
104 : : * ps2_is_keyboard_id() checks received ID byte against the list of
105 : : * known keyboard IDs.
106 : : */
107 : :
108 : 0 : int ps2_is_keyboard_id(char id_byte)
109 : : {
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 */
117 : : };
118 : :
119 : 0 : return memchr(keyboard_ids, id_byte, sizeof(keyboard_ids)) != NULL;
120 : : }
121 : : EXPORT_SYMBOL(ps2_is_keyboard_id);
122 : :
123 : : /*
124 : : * ps2_adjust_timeout() is called after receiving 1st byte of command
125 : : * response and tries to reduce remaining timeout to speed up command
126 : : * completion.
127 : : */
128 : :
129 : 0 : static int ps2_adjust_timeout(struct ps2dev *ps2dev, int command, int timeout)
130 : : {
131 [ # # # ]: 0 : switch (command) {
132 : : case PS2_CMD_RESET_BAT:
133 : : /*
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
138 : : * at all (mouse).
139 : : */
140 [ # # ]: 0 : if (timeout > msecs_to_jiffies(100))
141 : 0 : timeout = msecs_to_jiffies(100);
142 : : break;
143 : :
144 : : case PS2_CMD_GETID:
145 : : /*
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.
150 : : */
151 [ # # ]: 0 : if (ps2dev->cmdbuf[1] == 0xaa) {
152 : 0 : serio_pause_rx(ps2dev->serio);
153 : 0 : ps2dev->flags = 0;
154 : 0 : serio_continue_rx(ps2dev->serio);
155 : : timeout = 0;
156 : : }
157 : :
158 : : /*
159 : : * If device behind the port is not a keyboard there
160 : : * won't be 2nd byte of ID response.
161 : : */
162 [ # # ]: 0 : if (!ps2_is_keyboard_id(ps2dev->cmdbuf[1])) {
163 : 0 : serio_pause_rx(ps2dev->serio);
164 : 0 : ps2dev->flags = ps2dev->cmdcnt = 0;
165 : 0 : serio_continue_rx(ps2dev->serio);
166 : : timeout = 0;
167 : : }
168 : : break;
169 : :
170 : : default:
171 : : break;
172 : : }
173 : :
174 : 0 : return timeout;
175 : : }
176 : :
177 : : /*
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.
180 : : *
181 : : * ps2_command() can only be called from a process context
182 : : */
183 : :
184 : 0 : int __ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
185 : : {
186 : : int timeout;
187 : 0 : int send = (command >> 12) & 0xf;
188 : 0 : int receive = (command >> 8) & 0xf;
189 : : int rc = -1;
190 : : int i;
191 : :
192 [ # # ]: 0 : if (receive > sizeof(ps2dev->cmdbuf)) {
193 : 0 : WARN_ON(1);
194 : 0 : return -1;
195 : : }
196 : :
197 [ # # ]: 0 : if (send && !param) {
198 : 0 : WARN_ON(1);
199 : 0 : return -1;
200 : : }
201 : :
202 : 0 : serio_pause_rx(ps2dev->serio);
203 [ # # ]: 0 : ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
204 : 0 : ps2dev->cmdcnt = receive;
205 [ # # ]: 0 : if (receive && param)
206 [ # # ]: 0 : for (i = 0; i < receive; i++)
207 : 0 : ps2dev->cmdbuf[(receive - 1) - i] = param[i];
208 : 0 : serio_continue_rx(ps2dev->serio);
209 : :
210 : : /*
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 arrives.
214 : : */
215 [ # # ][ # # ]: 0 : if (ps2_sendbyte(ps2dev, command & 0xff,
216 : : command == PS2_CMD_RESET_BAT ? 1000 : 200))
217 : : goto out;
218 : :
219 [ # # ]: 0 : for (i = 0; i < send; i++)
220 [ # # ]: 0 : if (ps2_sendbyte(ps2dev, param[i], 200))
221 : : goto out;
222 : :
223 : : /*
224 : : * The reset command takes a long time to execute.
225 : : */
226 [ # # ]: 0 : timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500);
227 : :
228 [ # # ][ # # ]: 0 : timeout = wait_event_timeout(ps2dev->wait,
[ # # ][ # # ]
229 : : !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
230 : :
231 [ # # ][ # # ]: 0 : if (ps2dev->cmdcnt && !(ps2dev->flags & PS2_FLAG_CMD1)) {
232 : :
233 : 0 : timeout = ps2_adjust_timeout(ps2dev, command, timeout);
234 [ # # ][ # # ]: 0 : wait_event_timeout(ps2dev->wait,
[ # # ][ # # ]
235 : : !(ps2dev->flags & PS2_FLAG_CMD), timeout);
236 : : }
237 : :
238 [ # # ]: 0 : if (param)
239 [ # # ]: 0 : for (i = 0; i < receive; i++)
240 : 0 : param[i] = ps2dev->cmdbuf[(receive - 1) - i];
241 : :
242 [ # # ][ # # ]: 0 : if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1))
[ # # ]
243 : : goto out;
244 : :
245 : : rc = 0;
246 : :
247 : : out:
248 : 0 : serio_pause_rx(ps2dev->serio);
249 : 0 : ps2dev->flags = 0;
250 : 0 : serio_continue_rx(ps2dev->serio);
251 : :
252 : 0 : return rc;
253 : : }
254 : : EXPORT_SYMBOL(__ps2_command);
255 : :
256 : 0 : int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
257 : : {
258 : : int rc;
259 : :
260 : : ps2_begin_command(ps2dev);
261 : 0 : rc = __ps2_command(ps2dev, param, command);
262 : : ps2_end_command(ps2dev);
263 : :
264 : 0 : return rc;
265 : : }
266 : : EXPORT_SYMBOL(ps2_command);
267 : :
268 : : /*
269 : : * ps2_init() initializes ps2dev structure
270 : : */
271 : :
272 : 0 : void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
273 : : {
274 : 0 : mutex_init(&ps2dev->cmd_mutex);
275 : : lockdep_set_subclass(&ps2dev->cmd_mutex, serio->depth);
276 : 0 : init_waitqueue_head(&ps2dev->wait);
277 : 0 : ps2dev->serio = serio;
278 : 0 : }
279 : : EXPORT_SYMBOL(ps2_init);
280 : :
281 : : /*
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.
284 : : */
285 : :
286 : 0 : int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
287 : : {
288 [ # # # # : 0 : switch (data) {
# ]
289 : : case PS2_RET_ACK:
290 : 0 : ps2dev->nak = 0;
291 : 0 : break;
292 : :
293 : : case PS2_RET_NAK:
294 : 0 : ps2dev->flags |= PS2_FLAG_NAK;
295 : 0 : ps2dev->nak = PS2_RET_NAK;
296 : 0 : break;
297 : :
298 : : case PS2_RET_ERR:
299 [ # # ]: 0 : if (ps2dev->flags & PS2_FLAG_NAK) {
300 : 0 : ps2dev->flags &= ~PS2_FLAG_NAK;
301 : 0 : ps2dev->nak = PS2_RET_ERR;
302 : 0 : break;
303 : : }
304 : :
305 : : /*
306 : : * Workaround for mice which don't ACK the Get ID command.
307 : : * These are valid mouse IDs that we recognize.
308 : : */
309 : : case 0x00:
310 : : case 0x03:
311 : : case 0x04:
312 [ # # ]: 0 : if (ps2dev->flags & PS2_FLAG_WAITID) {
313 : 0 : ps2dev->nak = 0;
314 : 0 : break;
315 : : }
316 : : /* Fall through */
317 : : default:
318 : : return 0;
319 : : }
320 : :
321 : :
322 [ # # ]: 0 : if (!ps2dev->nak) {
323 : 0 : ps2dev->flags &= ~PS2_FLAG_NAK;
324 [ # # ]: 0 : if (ps2dev->cmdcnt)
325 : 0 : ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
326 : : }
327 : :
328 : 0 : ps2dev->flags &= ~PS2_FLAG_ACK;
329 : 0 : wake_up(&ps2dev->wait);
330 : :
331 [ # # ]: 0 : if (data != PS2_RET_ACK)
332 : 0 : ps2_handle_response(ps2dev, data);
333 : :
334 : : return 1;
335 : : }
336 : : EXPORT_SYMBOL(ps2_handle_ack);
337 : :
338 : : /*
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.
342 : : */
343 : :
344 : 0 : int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
345 : : {
346 [ # # ]: 0 : if (ps2dev->cmdcnt)
347 : 0 : ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
348 : :
349 [ # # ]: 0 : if (ps2dev->flags & PS2_FLAG_CMD1) {
350 : 0 : ps2dev->flags &= ~PS2_FLAG_CMD1;
351 [ # # ]: 0 : if (ps2dev->cmdcnt)
352 : 0 : wake_up(&ps2dev->wait);
353 : : }
354 : :
355 [ # # ]: 0 : if (!ps2dev->cmdcnt) {
356 : 0 : ps2dev->flags &= ~PS2_FLAG_CMD;
357 : 0 : wake_up(&ps2dev->wait);
358 : : }
359 : :
360 : 0 : return 1;
361 : : }
362 : : EXPORT_SYMBOL(ps2_handle_response);
363 : :
364 : 0 : void ps2_cmd_aborted(struct ps2dev *ps2dev)
365 : : {
366 [ # # ]: 0 : if (ps2dev->flags & PS2_FLAG_ACK)
367 : 0 : ps2dev->nak = 1;
368 : :
369 [ # # ]: 0 : if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
370 : 0 : wake_up(&ps2dev->wait);
371 : :
372 : : /* reset all flags except last nack */
373 : 0 : ps2dev->flags &= PS2_FLAG_NAK;
374 : 0 : }
375 : : EXPORT_SYMBOL(ps2_cmd_aborted);
|
