4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 * Copyright (c) 2004 Dmitry Torokhov
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.
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>
24 #define DRIVER_DESC "PS/2 driver library"
26 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
27 MODULE_DESCRIPTION("PS/2 driver library");
28 MODULE_LICENSE("GPL");
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);
39 /* Work structure to schedule execution of a command */
41 struct work_struct work;
42 struct ps2dev *ps2dev;
44 unsigned char param[0];
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.
53 * ps2_sendbyte() can only be called from a process context.
56 int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout)
58 serio_pause_rx(ps2dev->serio);
60 ps2dev->flags |= PS2_FLAG_ACK;
61 serio_continue_rx(ps2dev->serio);
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));
68 serio_pause_rx(ps2dev->serio);
69 ps2dev->flags &= ~PS2_FLAG_ACK;
70 serio_continue_rx(ps2dev->serio);
76 * ps2_drain() waits for device to transmit requested number of bytes
80 void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
82 if (maxbytes > sizeof(ps2dev->cmdbuf)) {
84 maxbytes = sizeof(ps2dev->cmdbuf);
87 down(&ps2dev->cmd_sem);
89 serio_pause_rx(ps2dev->serio);
90 ps2dev->flags = PS2_FLAG_CMD;
91 ps2dev->cmdcnt = maxbytes;
92 serio_continue_rx(ps2dev->serio);
94 wait_event_timeout(ps2dev->wait,
95 !(ps2dev->flags & PS2_FLAG_CMD),
96 msecs_to_jiffies(timeout));
101 * ps2_command() sends a command and its parameters to the mouse,
102 * then waits for the response and puts it in the param array.
104 * ps2_command() can only be called from a process context
107 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
110 int send = (command >> 12) & 0xf;
111 int receive = (command >> 8) & 0xf;
115 if (receive > sizeof(ps2dev->cmdbuf)) {
120 down(&ps2dev->cmd_sem);
122 serio_pause_rx(ps2dev->serio);
123 ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
124 ps2dev->cmdcnt = receive;
125 if (receive && param)
126 for (i = 0; i < receive; i++)
127 ps2dev->cmdbuf[(receive - 1) - i] = param[i];
128 serio_continue_rx(ps2dev->serio);
131 * Some devices (Synaptics) peform the reset before
132 * ACKing the reset command, and so it can take a long
133 * time before the ACK arrrives.
135 if (ps2_sendbyte(ps2dev, command & 0xff,
136 command == PS2_CMD_RESET_BAT ? 1000 : 200))
139 for (i = 0; i < send; i++)
140 if (ps2_sendbyte(ps2dev, param[i], 200))
144 * The reset command takes a long time to execute.
146 timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500);
148 timeout = wait_event_timeout(ps2dev->wait,
149 !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
151 if (ps2dev->cmdcnt && timeout > 0) {
153 if (command == PS2_CMD_RESET_BAT && timeout > msecs_to_jiffies(100)) {
155 * Device has sent the first response byte
156 * after a reset command, reset is thus done,
157 * shorten the timeout. The next byte will come
158 * soon (keyboard) or not at all (mouse).
160 timeout = msecs_to_jiffies(100);
163 if (command == PS2_CMD_GETID &&
164 ps2dev->cmdbuf[receive - 1] != 0xab && /* Regular keyboards */
165 ps2dev->cmdbuf[receive - 1] != 0xac && /* NCD Sun keyboard */
166 ps2dev->cmdbuf[receive - 1] != 0x2b && /* Trust keyboard, translated */
167 ps2dev->cmdbuf[receive - 1] != 0x5d && /* Trust keyboard */
168 ps2dev->cmdbuf[receive - 1] != 0x60 && /* NMB SGI keyboard, translated */
169 ps2dev->cmdbuf[receive - 1] != 0x47) { /* NMB SGI keyboard */
171 * Device behind the port is not a keyboard
172 * so we don't need to wait for the 2nd byte
175 serio_pause_rx(ps2dev->serio);
176 ps2dev->flags = ps2dev->cmdcnt = 0;
177 serio_continue_rx(ps2dev->serio);
180 wait_event_timeout(ps2dev->wait,
181 !(ps2dev->flags & PS2_FLAG_CMD), timeout);
185 for (i = 0; i < receive; i++)
186 param[i] = ps2dev->cmdbuf[(receive - 1) - i];
188 if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1))
194 serio_pause_rx(ps2dev->serio);
196 serio_continue_rx(ps2dev->serio);
198 up(&ps2dev->cmd_sem);
203 * ps2_execute_scheduled_command() sends a command, previously scheduled by
204 * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
207 static void ps2_execute_scheduled_command(void *data)
209 struct ps2work *ps2work = data;
211 ps2_command(ps2work->ps2dev, ps2work->param, ps2work->command);
216 * ps2_schedule_command() allows to schedule delayed execution of a PS/2
217 * command and can be used to issue a command from an interrupt or softirq
221 int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command)
223 struct ps2work *ps2work;
224 int send = (command >> 12) & 0xf;
225 int receive = (command >> 8) & 0xf;
227 if (!(ps2work = kmalloc(sizeof(struct ps2work) + max(send, receive), GFP_ATOMIC)))
230 memset(ps2work, 0, sizeof(struct ps2work));
231 ps2work->ps2dev = ps2dev;
232 ps2work->command = command;
233 memcpy(ps2work->param, param, send);
234 INIT_WORK(&ps2work->work, ps2_execute_scheduled_command, ps2work);
236 if (!schedule_work(&ps2work->work)) {
245 * ps2_init() initializes ps2dev structure
248 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
250 init_MUTEX(&ps2dev->cmd_sem);
251 init_waitqueue_head(&ps2dev->wait);
252 ps2dev->serio = serio;
256 * ps2_handle_ack() is supposed to be used in interrupt handler
257 * to properly process ACK/NAK of a command from a PS/2 device.
260 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
272 * Workaround for mice which don't ACK the Get ID command.
273 * These are valid mouse IDs that we recognize.
278 if (ps2dev->flags & PS2_FLAG_WAITID) {
288 if (!ps2dev->nak && ps2dev->cmdcnt)
289 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
291 ps2dev->flags &= ~PS2_FLAG_ACK;
292 wake_up(&ps2dev->wait);
294 if (data != PS2_RET_ACK)
295 ps2_handle_response(ps2dev, data);
301 * ps2_handle_response() is supposed to be used in interrupt handler
302 * to properly store device's response to a command and notify process
303 * waiting for completion of the command.
306 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
309 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
311 if (ps2dev->flags & PS2_FLAG_CMD1) {
312 ps2dev->flags &= ~PS2_FLAG_CMD1;
314 wake_up(&ps2dev->wait);
317 if (!ps2dev->cmdcnt) {
318 ps2dev->flags &= ~PS2_FLAG_CMD;
319 wake_up(&ps2dev->wait);
325 void ps2_cmd_aborted(struct ps2dev *ps2dev)
327 if (ps2dev->flags & PS2_FLAG_ACK)
330 if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
331 wake_up(&ps2dev->wait);