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