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