← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to drivers/input/serio/libps2.c

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

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