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 /* Work structure to schedule execution of a command */ 31 struct 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 47 int 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 } 65 EXPORT_SYMBOL(ps2_sendbyte); 66 67 /* 68 * ps2_drain() waits for device to transmit requested number of bytes 69 * and discards them. 70 */ 71 72 void 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 } 91 EXPORT_SYMBOL(ps2_drain); 92 93 /* 94 * ps2_is_keyboard_id() checks received ID byte against the list of 95 * known keyboard IDs. 96 */ 97 98 int 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 } 111 EXPORT_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 119 static 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 174 int 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 } 247 EXPORT_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 254 static 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 268 int 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 } 290 EXPORT_SYMBOL(ps2_schedule_command); 291 292 /* 293 * ps2_init() initializes ps2dev structure 294 */ 295 296 void 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 } 303 EXPORT_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 310 int 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 /* 322 * Workaround for mice which don't ACK the Get ID command. 323 * These are valid mouse IDs that we recognize. 324 */ 325 case 0x00: 326 case 0x03: 327 case 0x04: 328 if (ps2dev->flags & PS2_FLAG_WAITID) { 329 ps2dev->nak = 0; 330 break; 331 } 332 /* Fall through */ 333 default: 334 return 0; 335 } 336 337 338 if (!ps2dev->nak && ps2dev->cmdcnt) 339 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1; 340 341 ps2dev->flags &= ~PS2_FLAG_ACK; 342 wake_up(&ps2dev->wait); 343 344 if (data != PS2_RET_ACK) 345 ps2_handle_response(ps2dev, data); 346 347 return 1; 348 } 349 EXPORT_SYMBOL(ps2_handle_ack); 350 351 /* 352 * ps2_handle_response() is supposed to be used in interrupt handler 353 * to properly store device's response to a command and notify process 354 * waiting for completion of the command. 355 */ 356 357 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data) 358 { 359 if (ps2dev->cmdcnt) 360 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data; 361 362 if (ps2dev->flags & PS2_FLAG_CMD1) { 363 ps2dev->flags &= ~PS2_FLAG_CMD1; 364 if (ps2dev->cmdcnt) 365 wake_up(&ps2dev->wait); 366 } 367 368 if (!ps2dev->cmdcnt) { 369 ps2dev->flags &= ~PS2_FLAG_CMD; 370 wake_up(&ps2dev->wait); 371 } 372 373 return 1; 374 } 375 EXPORT_SYMBOL(ps2_handle_response); 376 377 void ps2_cmd_aborted(struct ps2dev *ps2dev) 378 { 379 if (ps2dev->flags & PS2_FLAG_ACK) 380 ps2dev->nak = 1; 381 382 if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD)) 383 wake_up(&ps2dev->wait); 384 385 ps2dev->flags = 0; 386 } 387 EXPORT_SYMBOL(ps2_cmd_aborted); 388