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