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