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