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);
38 EXPORT_SYMBOL(ps2_is_keyboard_id);
40 /* Work structure to schedule execution of a command */
42 struct work_struct work;
43 struct ps2dev *ps2dev;
45 unsigned char param[0];
50 * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
51 * It doesn't handle retransmission, though it could - because if there
52 * is a need for retransmissions device has to be replaced anyway.
54 * ps2_sendbyte() can only be called from a process context.
57 int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout)
59 serio_pause_rx(ps2dev->serio);
61 ps2dev->flags |= PS2_FLAG_ACK;
62 serio_continue_rx(ps2dev->serio);
64 if (serio_write(ps2dev->serio, byte) == 0)
65 wait_event_timeout(ps2dev->wait,
66 !(ps2dev->flags & PS2_FLAG_ACK),
67 msecs_to_jiffies(timeout));
69 serio_pause_rx(ps2dev->serio);
70 ps2dev->flags &= ~PS2_FLAG_ACK;
71 serio_continue_rx(ps2dev->serio);
77 * ps2_drain() waits for device to transmit requested number of bytes
81 void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
83 if (maxbytes > sizeof(ps2dev->cmdbuf)) {
85 maxbytes = sizeof(ps2dev->cmdbuf);
88 mutex_lock(&ps2dev->cmd_mutex);
90 serio_pause_rx(ps2dev->serio);
91 ps2dev->flags = PS2_FLAG_CMD;
92 ps2dev->cmdcnt = maxbytes;
93 serio_continue_rx(ps2dev->serio);
95 wait_event_timeout(ps2dev->wait,
96 !(ps2dev->flags & PS2_FLAG_CMD),
97 msecs_to_jiffies(timeout));
98 mutex_unlock(&ps2dev->cmd_mutex);
102 * ps2_is_keyboard_id() checks received ID byte against the list of
103 * known keyboard IDs.
106 int ps2_is_keyboard_id(char id_byte)
108 const static char keyboard_ids[] = {
109 0xab, /* Regular keyboards */
110 0xac, /* NCD Sun keyboard */
111 0x2b, /* Trust keyboard, translated */
112 0x5d, /* Trust keyboard */
113 0x60, /* NMB SGI keyboard, translated */
114 0x47, /* NMB SGI keyboard */
117 return memchr(keyboard_ids, id_byte, sizeof(keyboard_ids)) != NULL;
121 * ps2_adjust_timeout() is called after receiving 1st byte of command
122 * response and tries to reduce remaining timeout to speed up command
126 static int ps2_adjust_timeout(struct ps2dev *ps2dev, int command, int timeout)
129 case PS2_CMD_RESET_BAT:
131 * Device has sent the first response byte after
132 * reset command, reset is thus done, so we can
133 * shorten the timeout.
134 * The next byte will come soon (keyboard) or not
137 if (timeout > msecs_to_jiffies(100))
138 timeout = msecs_to_jiffies(100);
143 * Microsoft Natural Elite keyboard responds to
144 * the GET ID command as it were a mouse, with
145 * a single byte. Fail the command so atkbd will
146 * use alternative probe to detect it.
148 if (ps2dev->cmdbuf[1] == 0xaa) {
149 serio_pause_rx(ps2dev->serio);
151 serio_continue_rx(ps2dev->serio);
156 * If device behind the port is not a keyboard there
157 * won't be 2nd byte of ID response.
159 if (!ps2_is_keyboard_id(ps2dev->cmdbuf[1])) {
160 serio_pause_rx(ps2dev->serio);
161 ps2dev->flags = ps2dev->cmdcnt = 0;
162 serio_continue_rx(ps2dev->serio);
175 * ps2_command() sends a command and its parameters to the mouse,
176 * then waits for the response and puts it in the param array.
178 * ps2_command() can only be called from a process context
181 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
184 int send = (command >> 12) & 0xf;
185 int receive = (command >> 8) & 0xf;
189 if (receive > sizeof(ps2dev->cmdbuf)) {
194 if (send && !param) {
199 mutex_lock_nested(&ps2dev->cmd_mutex, SINGLE_DEPTH_NESTING);
201 serio_pause_rx(ps2dev->serio);
202 ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
203 ps2dev->cmdcnt = receive;
204 if (receive && param)
205 for (i = 0; i < receive; i++)
206 ps2dev->cmdbuf[(receive - 1) - i] = param[i];
207 serio_continue_rx(ps2dev->serio);
210 * Some devices (Synaptics) peform the reset before
211 * ACKing the reset command, and so it can take a long
212 * time before the ACK arrrives.
214 if (ps2_sendbyte(ps2dev, command & 0xff,
215 command == PS2_CMD_RESET_BAT ? 1000 : 200))
218 for (i = 0; i < send; i++)
219 if (ps2_sendbyte(ps2dev, param[i], 200))
223 * The reset command takes a long time to execute.
225 timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500);
227 timeout = wait_event_timeout(ps2dev->wait,
228 !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
230 if (ps2dev->cmdcnt && timeout > 0) {
232 timeout = ps2_adjust_timeout(ps2dev, command, timeout);
233 wait_event_timeout(ps2dev->wait,
234 !(ps2dev->flags & PS2_FLAG_CMD), timeout);
238 for (i = 0; i < receive; i++)
239 param[i] = ps2dev->cmdbuf[(receive - 1) - i];
241 if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1))
247 serio_pause_rx(ps2dev->serio);
249 serio_continue_rx(ps2dev->serio);
251 mutex_unlock(&ps2dev->cmd_mutex);
256 * ps2_execute_scheduled_command() sends a command, previously scheduled by
257 * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
260 static void ps2_execute_scheduled_command(void *data)
262 struct ps2work *ps2work = data;
264 ps2_command(ps2work->ps2dev, ps2work->param, ps2work->command);
269 * ps2_schedule_command() allows to schedule delayed execution of a PS/2
270 * command and can be used to issue a command from an interrupt or softirq
274 int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command)
276 struct ps2work *ps2work;
277 int send = (command >> 12) & 0xf;
278 int receive = (command >> 8) & 0xf;
280 if (!(ps2work = kmalloc(sizeof(struct ps2work) + max(send, receive), GFP_ATOMIC)))
283 memset(ps2work, 0, sizeof(struct ps2work));
284 ps2work->ps2dev = ps2dev;
285 ps2work->command = command;
286 memcpy(ps2work->param, param, send);
287 INIT_WORK(&ps2work->work, ps2_execute_scheduled_command, ps2work);
289 if (!schedule_work(&ps2work->work)) {
298 * ps2_init() initializes ps2dev structure
301 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
303 mutex_init(&ps2dev->cmd_mutex);
304 init_waitqueue_head(&ps2dev->wait);
305 ps2dev->serio = serio;
309 * ps2_handle_ack() is supposed to be used in interrupt handler
310 * to properly process ACK/NAK of a command from a PS/2 device.
313 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
325 * Workaround for mice which don't ACK the Get ID command.
326 * These are valid mouse IDs that we recognize.
331 if (ps2dev->flags & PS2_FLAG_WAITID) {
341 if (!ps2dev->nak && ps2dev->cmdcnt)
342 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
344 ps2dev->flags &= ~PS2_FLAG_ACK;
345 wake_up(&ps2dev->wait);
347 if (data != PS2_RET_ACK)
348 ps2_handle_response(ps2dev, data);
354 * ps2_handle_response() is supposed to be used in interrupt handler
355 * to properly store device's response to a command and notify process
356 * waiting for completion of the command.
359 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
362 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
364 if (ps2dev->flags & PS2_FLAG_CMD1) {
365 ps2dev->flags &= ~PS2_FLAG_CMD1;
367 wake_up(&ps2dev->wait);
370 if (!ps2dev->cmdcnt) {
371 ps2dev->flags &= ~PS2_FLAG_CMD;
372 wake_up(&ps2dev->wait);
378 void ps2_cmd_aborted(struct ps2dev *ps2dev)
380 if (ps2dev->flags & PS2_FLAG_ACK)
383 if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
384 wake_up(&ps2dev->wait);