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