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