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