git.oblomov.eu Git - linux-2.6/blob - 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 EXPORT_SYMBOL(ps2_init);
  31 EXPORT_SYMBOL(ps2_sendbyte);
  32 EXPORT_SYMBOL(ps2_drain);
  33 EXPORT_SYMBOL(ps2_command);
  34 EXPORT_SYMBOL(ps2_schedule_command);
  35 EXPORT_SYMBOL(ps2_handle_ack);
  36 EXPORT_SYMBOL(ps2_handle_response);
  37 EXPORT_SYMBOL(ps2_cmd_aborted);
  38 EXPORT_SYMBOL(ps2_is_keyboard_id);
  39
  40 /* Work structure to schedule execution of a command */
  41 struct ps2work {
  42         struct work_struct work;
  43         struct ps2dev *ps2dev;
  44         int command;
  45         unsigned char param[0];
  46 };
  47
  48
  49 /*
  50  * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
  51  * It doesn't handle retransmission, though it could - because if there
  52  * is a need for retransmissions device has to be replaced anyway.
  53  *
  54  * ps2_sendbyte() can only be called from a process context.
  55  */
  56
  57 int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout)
  58 {
  59         serio_pause_rx(ps2dev->serio);
  60         ps2dev->nak = 1;
  61         ps2dev->flags |= PS2_FLAG_ACK;
  62         serio_continue_rx(ps2dev->serio);
  63
  64         if (serio_write(ps2dev->serio, byte) == 0)
  65                 wait_event_timeout(ps2dev->wait,
  66                                    !(ps2dev->flags & PS2_FLAG_ACK),
  67                                    msecs_to_jiffies(timeout));
  68
  69         serio_pause_rx(ps2dev->serio);
  70         ps2dev->flags &= ~PS2_FLAG_ACK;
  71         serio_continue_rx(ps2dev->serio);
  72
  73         return -ps2dev->nak;
  74 }
  75
  76 /*
  77  * ps2_drain() waits for device to transmit requested number of bytes
  78  * and discards them.
  79  */
  80
  81 void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
  82 {
  83         if (maxbytes > sizeof(ps2dev->cmdbuf)) {
  84                 WARN_ON(1);
  85                 maxbytes = sizeof(ps2dev->cmdbuf);
  86         }
  87
  88         mutex_lock(&ps2dev->cmd_mutex);
  89
  90         serio_pause_rx(ps2dev->serio);
  91         ps2dev->flags = PS2_FLAG_CMD;
  92         ps2dev->cmdcnt = maxbytes;
  93         serio_continue_rx(ps2dev->serio);
  94
  95         wait_event_timeout(ps2dev->wait,
  96                            !(ps2dev->flags & PS2_FLAG_CMD),
  97                            msecs_to_jiffies(timeout));
  98         mutex_unlock(&ps2dev->cmd_mutex);
  99 }
 100
 101 /*
 102  * ps2_is_keyboard_id() checks received ID byte against the list of
 103  * known keyboard IDs.
 104  */
 105
 106 int ps2_is_keyboard_id(char id_byte)
 107 {
 108         const static char keyboard_ids[] = {
 109                 0xab,   /* Regular keyboards            */
 110                 0xac,   /* NCD Sun keyboard             */
 111                 0x2b,   /* Trust keyboard, translated   */
 112                 0x5d,   /* Trust keyboard               */
 113                 0x60,   /* NMB SGI keyboard, translated */
 114                 0x47,   /* NMB SGI keyboard             */
 115         };
 116
 117         return memchr(keyboard_ids, id_byte, sizeof(keyboard_ids)) != NULL;
 118 }
 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         mutex_lock_nested(&ps2dev->cmd_mutex, SINGLE_DEPTH_NESTING);
 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 arrrives.
 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 && timeout > 0) {
 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         mutex_unlock(&ps2dev->cmd_mutex);
 252         return rc;
 253 }
 254
 255 /*
 256  * ps2_execute_scheduled_command() sends a command, previously scheduled by
 257  * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
 258  */
 259
 260 static void ps2_execute_scheduled_command(void *data)
 261 {
 262         struct ps2work *ps2work = data;
 263
 264         ps2_command(ps2work->ps2dev, ps2work->param, ps2work->command);
 265         kfree(ps2work);
 266 }
 267
 268 /*
 269  * ps2_schedule_command() allows to schedule delayed execution of a PS/2
 270  * command and can be used to issue a command from an interrupt or softirq
 271  * context.
 272  */
 273
 274 int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command)
 275 {
 276         struct ps2work *ps2work;
 277         int send = (command >> 12) & 0xf;
 278         int receive = (command >> 8) & 0xf;
 279
 280         if (!(ps2work = kmalloc(sizeof(struct ps2work) + max(send, receive), GFP_ATOMIC)))
 281                 return -1;
 282
 283         memset(ps2work, 0, sizeof(struct ps2work));
 284         ps2work->ps2dev = ps2dev;
 285         ps2work->command = command;
 286         memcpy(ps2work->param, param, send);
 287         INIT_WORK(&ps2work->work, ps2_execute_scheduled_command, ps2work);
 288
 289         if (!schedule_work(&ps2work->work)) {
 290                 kfree(ps2work);
 291                 return -1;
 292         }
 293
 294         return 0;
 295 }
 296
 297 /*
 298  * ps2_init() initializes ps2dev structure
 299  */
 300
 301 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
 302 {
 303         mutex_init(&ps2dev->cmd_mutex);
 304         init_waitqueue_head(&ps2dev->wait);
 305         ps2dev->serio = serio;
 306 }
 307
 308 /*
 309  * ps2_handle_ack() is supposed to be used in interrupt handler
 310  * to properly process ACK/NAK of a command from a PS/2 device.
 311  */
 312
 313 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
 314 {
 315         switch (data) {
 316                 case PS2_RET_ACK:
 317                         ps2dev->nak = 0;
 318                         break;
 319
 320                 case PS2_RET_NAK:
 321                         ps2dev->nak = 1;
 322                         break;
 323
 324                 /*
 325                  * Workaround for mice which don't ACK the Get ID command.
 326                  * These are valid mouse IDs that we recognize.
 327                  */
 328                 case 0x00:
 329                 case 0x03:
 330                 case 0x04:
 331                         if (ps2dev->flags & PS2_FLAG_WAITID) {
 332                                 ps2dev->nak = 0;
 333                                 break;
 334                         }
 335                         /* Fall through */
 336                 default:
 337                         return 0;
 338         }
 339
 340
 341         if (!ps2dev->nak && ps2dev->cmdcnt)
 342                 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
 343
 344         ps2dev->flags &= ~PS2_FLAG_ACK;
 345         wake_up(&ps2dev->wait);
 346
 347         if (data != PS2_RET_ACK)
 348                 ps2_handle_response(ps2dev, data);
 349
 350         return 1;
 351 }
 352
 353 /*
 354  * ps2_handle_response() is supposed to be used in interrupt handler
 355  * to properly store device's response to a command and notify process
 356  * waiting for completion of the command.
 357  */
 358
 359 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
 360 {
 361         if (ps2dev->cmdcnt)
 362                 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
 363
 364         if (ps2dev->flags & PS2_FLAG_CMD1) {
 365                 ps2dev->flags &= ~PS2_FLAG_CMD1;
 366                 if (ps2dev->cmdcnt)
 367                         wake_up(&ps2dev->wait);
 368         }
 369
 370         if (!ps2dev->cmdcnt) {
 371                 ps2dev->flags &= ~PS2_FLAG_CMD;
 372                 wake_up(&ps2dev->wait);
 373         }
 374
 375         return 1;
 376 }
 377
 378 void ps2_cmd_aborted(struct ps2dev *ps2dev)
 379 {
 380         if (ps2dev->flags & PS2_FLAG_ACK)
 381                 ps2dev->nak = 1;
 382
 383         if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
 384                 wake_up(&ps2dev->wait);
 385
 386         ps2dev->flags = 0;
 387 }
 388