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