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 goto out; 217 218 for (i = 0; i < send; i++) 219 if (ps2_sendbyte(ps2dev, param[i], 200)) 220 goto out; 221 222 /* 223 * The reset command takes a long time to execute. 224 */ 225 timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500); 226 227 timeout = wait_event_timeout(ps2dev->wait, 228 !(ps2dev->flags & PS2_FLAG_CMD1), timeout); 229 230 if (ps2dev->cmdcnt && !(ps2dev->flags & PS2_FLAG_CMD1)) { 231 232 timeout = ps2_adjust_timeout(ps2dev, command, timeout); 233 wait_event_timeout(ps2dev->wait, 234 !(ps2dev->flags & PS2_FLAG_CMD), timeout); 235 } 236 237 if (param) 238 for (i = 0; i < receive; i++) 239 param[i] = ps2dev->cmdbuf[(receive - 1) - i]; 240 241 if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1)) 242 goto out; 243 244 rc = 0; 245 246 out: 247 serio_pause_rx(ps2dev->serio); 248 ps2dev->flags = 0; 249 serio_continue_rx(ps2dev->serio); 250 251 return rc; 252 } 253 EXPORT_SYMBOL(__ps2_command); 254 255 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command) 256 { 257 int rc; 258 259 ps2_begin_command(ps2dev); 260 rc = __ps2_command(ps2dev, param, command); 261 ps2_end_command(ps2dev); 262 263 return rc; 264 } 265 EXPORT_SYMBOL(ps2_command); 266 267 /* 268 * ps2_init() initializes ps2dev structure 269 */ 270 271 void ps2_init(struct ps2dev *ps2dev, struct serio *serio) 272 { 273 mutex_init(&ps2dev->cmd_mutex); 274 lockdep_set_subclass(&ps2dev->cmd_mutex, serio->depth); 275 init_waitqueue_head(&ps2dev->wait); 276 ps2dev->serio = serio; 277 } 278 EXPORT_SYMBOL(ps2_init); 279 280 /* 281 * ps2_handle_ack() is supposed to be used in interrupt handler 282 * to properly process ACK/NAK of a command from a PS/2 device. 283 */ 284 285 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data) 286 { 287 switch (data) { 288 case PS2_RET_ACK: 289 ps2dev->nak = 0; 290 break; 291 292 case PS2_RET_NAK: 293 ps2dev->flags |= PS2_FLAG_NAK; 294 ps2dev->nak = PS2_RET_NAK; 295 break; 296 297 case PS2_RET_ERR: 298 if (ps2dev->flags & PS2_FLAG_NAK) { 299 ps2dev->flags &= ~PS2_FLAG_NAK; 300 ps2dev->nak = PS2_RET_ERR; 301 break; 302 } 303 304 /* 305 * Workaround for mice which don't ACK the Get ID command. 306 * These are valid mouse IDs that we recognize. 307 */ 308 case 0x00: 309 case 0x03: 310 case 0x04: 311 if (ps2dev->flags & PS2_FLAG_WAITID) { 312 ps2dev->nak = 0; 313 break; 314 } 315 /* Fall through */ 316 default: 317 return 0; 318 } 319 320 321 if (!ps2dev->nak) { 322 ps2dev->flags &= ~PS2_FLAG_NAK; 323 if (ps2dev->cmdcnt) 324 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1; 325 } 326 327 ps2dev->flags &= ~PS2_FLAG_ACK; 328 wake_up(&ps2dev->wait); 329 330 if (data != PS2_RET_ACK) 331 ps2_handle_response(ps2dev, data); 332 333 return 1; 334 } 335 EXPORT_SYMBOL(ps2_handle_ack); 336 337 /* 338 * ps2_handle_response() is supposed to be used in interrupt handler 339 * to properly store device's response to a command and notify process 340 * waiting for completion of the command. 341 */ 342 343 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data) 344 { 345 if (ps2dev->cmdcnt) 346 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data; 347 348 if (ps2dev->flags & PS2_FLAG_CMD1) { 349 ps2dev->flags &= ~PS2_FLAG_CMD1; 350 if (ps2dev->cmdcnt) 351 wake_up(&ps2dev->wait); 352 } 353 354 if (!ps2dev->cmdcnt) { 355 ps2dev->flags &= ~PS2_FLAG_CMD; 356 wake_up(&ps2dev->wait); 357 } 358 359 return 1; 360 } 361 EXPORT_SYMBOL(ps2_handle_response); 362 363 void ps2_cmd_aborted(struct ps2dev *ps2dev) 364 { 365 if (ps2dev->flags & PS2_FLAG_ACK) 366 ps2dev->nak = 1; 367 368 if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD)) 369 wake_up(&ps2dev->wait); 370 371 /* reset all flags except last nack */ 372 ps2dev->flags &= PS2_FLAG_NAK; 373 } 374 EXPORT_SYMBOL(ps2_cmd_aborted); 375