kernel/drivers/input/serio/libps2.c

   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         struct mutex *m = ps2dev->serio->ps2_cmd_mutex ?: &ps2dev->cmd_mutex;
  60
  61         mutex_lock(m);
  62 }
  63 EXPORT_SYMBOL(ps2_begin_command);
  64
  65 void ps2_end_command(struct ps2dev *ps2dev)
  66 {
  67         struct mutex *m = ps2dev->serio->ps2_cmd_mutex ?: &ps2dev->cmd_mutex;
  68
  69         mutex_unlock(m);
  70 }
  71 EXPORT_SYMBOL(ps2_end_command);
  72
  73 /*
  74  * ps2_drain() waits for device to transmit requested number of bytes
  75  * and discards them.
  76  */
  77
  78 void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
  79 {
  80         if (maxbytes > sizeof(ps2dev->cmdbuf)) {
  81                 WARN_ON(1);
  82                 maxbytes = sizeof(ps2dev->cmdbuf);
  83         }
  84
  85         ps2_begin_command(ps2dev);
  86
  87         serio_pause_rx(ps2dev->serio);
  88         ps2dev->flags = PS2_FLAG_CMD;
  89         ps2dev->cmdcnt = maxbytes;
  90         serio_continue_rx(ps2dev->serio);
  91
  92         wait_event_timeout(ps2dev->wait,
  93                            !(ps2dev->flags & PS2_FLAG_CMD),
  94                            msecs_to_jiffies(timeout));
  95
  96         ps2_end_command(ps2dev);
  97 }
  98 EXPORT_SYMBOL(ps2_drain);
  99
 100 /*
 101  * ps2_is_keyboard_id() checks received ID byte against the list of
 102  * known keyboard IDs.
 103  */
 104
 105 int ps2_is_keyboard_id(char id_byte)
 106 {
 107         static const char keyboard_ids[] = {
 108                 0xab,   /* Regular keyboards            */
 109                 0xac,   /* NCD Sun keyboard             */
 110                 0x2b,   /* Trust keyboard, translated   */
 111                 0x5d,   /* Trust keyboard               */
 112                 0x60,   /* NMB SGI keyboard, translated */
 113                 0x47,   /* NMB SGI keyboard             */
 114         };
 115
 116         return memchr(keyboard_ids, id_byte, sizeof(keyboard_ids)) != NULL;
 117 }
 118 EXPORT_SYMBOL(ps2_is_keyboard_id);
 119
 120 /*
 121  * ps2_adjust_timeout() is called after receiving 1st byte of command
 122  * response and tries to reduce remaining timeout to speed up command
 123  * completion.
 124  */
 125
 126 static int ps2_adjust_timeout(struct ps2dev *ps2dev, int command, int timeout)
 127 {
 128         switch (command) {
 129                 case PS2_CMD_RESET_BAT:
 130                         /*
 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
 135                          * at all (mouse).
 136                          */
 137                         if (timeout > msecs_to_jiffies(100))
 138                                 timeout = msecs_to_jiffies(100);
 139                         break;
 140
 141                 case PS2_CMD_GETID:
 142                         /*
 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.
 147                          */
 148                         if (ps2dev->cmdbuf[1] == 0xaa) {
 149                                 serio_pause_rx(ps2dev->serio);
 150                                 ps2dev->flags = 0;
 151                                 serio_continue_rx(ps2dev->serio);
 152                                 timeout = 0;
 153                         }
 154
 155                         /*
 156                          * If device behind the port is not a keyboard there
 157                          * won't be 2nd byte of ID response.
 158                          */
 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);
 163                                 timeout = 0;
 164                         }
 165                         break;
 166
 167                 default:
 168                         break;
 169         }
 170
 171         return timeout;
 172 }
 173
 174 /*
 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.
 177  *
 178  * ps2_command() can only be called from a process context
 179  */
 180
 181 int __ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
 182 {
 183         int timeout;
 184         int send = (command >> 12) & 0xf;
 185         int receive = (command >> 8) & 0xf;
 186         int rc = -1;
 187         int i;
 188
 189         if (receive > sizeof(ps2dev->cmdbuf)) {
 190                 WARN_ON(1);
 191                 return -1;
 192         }
 193
 194         if (send && !param) {
 195                 WARN_ON(1);
 196                 return -1;
 197         }
 198
 199         serio_pause_rx(ps2dev->serio);
 200         ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
 201         ps2dev->cmdcnt = receive;
 202         if (receive && param)
 203                 for (i = 0; i < receive; i++)
 204                         ps2dev->cmdbuf[(receive - 1) - i] = param[i];
 205         serio_continue_rx(ps2dev->serio);
 206
 207         /*
 208          * Some devices (Synaptics) peform the reset before
 209          * ACKing the reset command, and so it can take a long
 210          * time before the ACK arrives.
 211          */
 212         if (ps2_sendbyte(ps2dev, command & 0xff,
 213                          command == PS2_CMD_RESET_BAT ? 1000 : 200)) {
 214                 serio_pause_rx(ps2dev->serio);
 215                 goto out_reset_flags;
 216         }
 217
 218         for (i = 0; i < send; i++) {
 219                 if (ps2_sendbyte(ps2dev, param[i], 200)) {
 220                         serio_pause_rx(ps2dev->serio);
 221                         goto out_reset_flags;
 222                 }
 223         }
 224
 225         /*
 226          * The reset command takes a long time to execute.
 227          */
 228         timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500);
 229
 230         timeout = wait_event_timeout(ps2dev->wait,
 231                                      !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
 232
 233         if (ps2dev->cmdcnt && !(ps2dev->flags & PS2_FLAG_CMD1)) {
 234
 235                 timeout = ps2_adjust_timeout(ps2dev, command, timeout);
 236                 wait_event_timeout(ps2dev->wait,
 237                                    !(ps2dev->flags & PS2_FLAG_CMD), timeout);
 238         }
 239
 240         serio_pause_rx(ps2dev->serio);
 241
 242         if (param)
 243                 for (i = 0; i < receive; i++)
 244                         param[i] = ps2dev->cmdbuf[(receive - 1) - i];
 245
 246         if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1))
 247                 goto out_reset_flags;
 248
 249         rc = 0;
 250
 251  out_reset_flags:
 252         ps2dev->flags = 0;
 253         serio_continue_rx(ps2dev->serio);
 254
 255         return rc;
 256 }
 257 EXPORT_SYMBOL(__ps2_command);
 258
 259 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
 260 {
 261         int rc;
 262
 263         ps2_begin_command(ps2dev);
 264         rc = __ps2_command(ps2dev, param, command);
 265         ps2_end_command(ps2dev);
 266
 267         return rc;
 268 }
 269 EXPORT_SYMBOL(ps2_command);
 270
 271 /*
 272  * ps2_init() initializes ps2dev structure
 273  */
 274
 275 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
 276 {
 277         mutex_init(&ps2dev->cmd_mutex);
 278         lockdep_set_subclass(&ps2dev->cmd_mutex, serio->depth);
 279         init_waitqueue_head(&ps2dev->wait);
 280         ps2dev->serio = serio;
 281 }
 282 EXPORT_SYMBOL(ps2_init);
 283
 284 /*
 285  * ps2_handle_ack() is supposed to be used in interrupt handler
 286  * to properly process ACK/NAK of a command from a PS/2 device.
 287  */
 288
 289 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
 290 {
 291         switch (data) {
 292                 case PS2_RET_ACK:
 293                         ps2dev->nak = 0;
 294                         break;
 295
 296                 case PS2_RET_NAK:
 297                         ps2dev->flags |= PS2_FLAG_NAK;
 298                         ps2dev->nak = PS2_RET_NAK;
 299                         break;
 300
 301                 case PS2_RET_ERR:
 302                         if (ps2dev->flags & PS2_FLAG_NAK) {
 303                                 ps2dev->flags &= ~PS2_FLAG_NAK;
 304                                 ps2dev->nak = PS2_RET_ERR;
 305                                 break;
 306                         }
 307
 308                 /*
 309                  * Workaround for mice which don't ACK the Get ID command.
 310                  * These are valid mouse IDs that we recognize.
 311                  */
 312                 case 0x00:
 313                 case 0x03:
 314                 case 0x04:
 315                         if (ps2dev->flags & PS2_FLAG_WAITID) {
 316                                 ps2dev->nak = 0;
 317                                 break;
 318                         }
 319                         /* Fall through */
 320                 default:
 321                         return 0;
 322         }
 323
 324
 325         if (!ps2dev->nak) {
 326                 ps2dev->flags &= ~PS2_FLAG_NAK;
 327                 if (ps2dev->cmdcnt)
 328                         ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
 329         }
 330
 331         ps2dev->flags &= ~PS2_FLAG_ACK;
 332         wake_up(&ps2dev->wait);
 333
 334         if (data != PS2_RET_ACK)
 335                 ps2_handle_response(ps2dev, data);
 336
 337         return 1;
 338 }
 339 EXPORT_SYMBOL(ps2_handle_ack);
 340
 341 /*
 342  * ps2_handle_response() is supposed to be used in interrupt handler
 343  * to properly store device's response to a command and notify process
 344  * waiting for completion of the command.
 345  */
 346
 347 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
 348 {
 349         if (ps2dev->cmdcnt)
 350                 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
 351
 352         if (ps2dev->flags & PS2_FLAG_CMD1) {
 353                 ps2dev->flags &= ~PS2_FLAG_CMD1;
 354                 if (ps2dev->cmdcnt)
 355                         wake_up(&ps2dev->wait);
 356         }
 357
 358         if (!ps2dev->cmdcnt) {
 359                 ps2dev->flags &= ~PS2_FLAG_CMD;
 360                 wake_up(&ps2dev->wait);
 361         }
 362
 363         return 1;
 364 }
 365 EXPORT_SYMBOL(ps2_handle_response);
 366
 367 void ps2_cmd_aborted(struct ps2dev *ps2dev)
 368 {
 369         if (ps2dev->flags & PS2_FLAG_ACK)
 370                 ps2dev->nak = 1;
 371
 372         if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
 373                 wake_up(&ps2dev->wait);
 374
 375         /* reset all flags except last nack */
 376         ps2dev->flags &= PS2_FLAG_NAK;
 377 }
 378 EXPORT_SYMBOL(ps2_cmd_aborted);