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_command);
  33 EXPORT_SYMBOL(ps2_schedule_command);
  34 EXPORT_SYMBOL(ps2_handle_ack);
  35 EXPORT_SYMBOL(ps2_handle_response);
  36 EXPORT_SYMBOL(ps2_cmd_aborted);
  37
  38 /* Work structure to schedule execution of a command */
  39 struct ps2work {
  40         struct work_struct work;
  41         struct ps2dev *ps2dev;
  42         int command;
  43         unsigned char param[0];
  44 };
  45
  46
  47 /*
  48  * ps2_sendbyte() sends a byte to the mouse, and waits for acknowledge.
  49  * It doesn't handle retransmission, though it could - because when there would
  50  * be need for retransmissions, the mouse has to be replaced anyway.
  51  *
  52  * ps2_sendbyte() can only be called from a process context
  53  */
  54
  55 int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout)
  56 {
  57         serio_pause_rx(ps2dev->serio);
  58         ps2dev->nak = 1;
  59         ps2dev->flags |= PS2_FLAG_ACK;
  60         serio_continue_rx(ps2dev->serio);
  61
  62         if (serio_write(ps2dev->serio, byte) == 0)
  63                 wait_event_timeout(ps2dev->wait,
  64                                    !(ps2dev->flags & PS2_FLAG_ACK),
  65                                    msecs_to_jiffies(timeout));
  66
  67         serio_pause_rx(ps2dev->serio);
  68         ps2dev->flags &= ~PS2_FLAG_ACK;
  69         serio_continue_rx(ps2dev->serio);
  70
  71         return -ps2dev->nak;
  72 }
  73
  74 /*
  75  * ps2_command() sends a command and its parameters to the mouse,
  76  * then waits for the response and puts it in the param array.
  77  *
  78  * ps2_command() can only be called from a process context
  79  */
  80
  81 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
  82 {
  83         int timeout;
  84         int send = (command >> 12) & 0xf;
  85         int receive = (command >> 8) & 0xf;
  86         int rc = -1;
  87         int i;
  88
  89         down(&ps2dev->cmd_sem);
  90
  91         serio_pause_rx(ps2dev->serio);
  92         ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
  93         ps2dev->cmdcnt = receive;
  94         if (receive && param)
  95                 for (i = 0; i < receive; i++)
  96                         ps2dev->cmdbuf[(receive - 1) - i] = param[i];
  97         serio_continue_rx(ps2dev->serio);
  98
  99         /*
 100          * Some devices (Synaptics) peform the reset before
 101          * ACKing the reset command, and so it can take a long
 102          * time before the ACK arrrives.
 103          */
 104         if (command & 0xff)
 105                 if (ps2_sendbyte(ps2dev, command & 0xff,
 106                         command == PS2_CMD_RESET_BAT ? 1000 : 200))
 107                         goto out;
 108
 109         for (i = 0; i < send; i++)
 110                 if (ps2_sendbyte(ps2dev, param[i], 200))
 111                         goto out;
 112
 113         /*
 114          * The reset command takes a long time to execute.
 115          */
 116         timeout = msecs_to_jiffies(command == PS2_CMD_RESET_BAT ? 4000 : 500);
 117
 118         timeout = wait_event_timeout(ps2dev->wait,
 119                                      !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
 120
 121         if (ps2dev->cmdcnt && timeout > 0) {
 122
 123                 if (command == PS2_CMD_RESET_BAT && timeout > msecs_to_jiffies(100)) {
 124                         /*
 125                          * Device has sent the first response byte
 126                          * after a reset command, reset is thus done,
 127                          * shorten the timeout. The next byte will come
 128                          * soon (keyboard) or not at all (mouse).
 129                          */
 130                         timeout = msecs_to_jiffies(100);
 131                 }
 132
 133                 if (command == PS2_CMD_GETID &&
 134                     ps2dev->cmdbuf[receive - 1] != 0xab && /* Regular keyboards */
 135                     ps2dev->cmdbuf[receive - 1] != 0xac && /* NCD Sun keyboard */
 136                     ps2dev->cmdbuf[receive - 1] != 0x2b && /* Trust keyboard, translated */
 137                     ps2dev->cmdbuf[receive - 1] != 0x5d && /* Trust keyboard */
 138                     ps2dev->cmdbuf[receive - 1] != 0x60 && /* NMB SGI keyboard, translated */
 139                     ps2dev->cmdbuf[receive - 1] != 0x47) { /* NMB SGI keyboard */
 140                         /*
 141                          * Device behind the port is not a keyboard
 142                          * so we don't need to wait for the 2nd byte
 143                          * of ID response.
 144                          */
 145                         serio_pause_rx(ps2dev->serio);
 146                         ps2dev->flags = ps2dev->cmdcnt = 0;
 147                         serio_continue_rx(ps2dev->serio);
 148                 }
 149
 150                 wait_event_timeout(ps2dev->wait,
 151                                    !(ps2dev->flags & PS2_FLAG_CMD), timeout);
 152         }
 153
 154         if (param)
 155                 for (i = 0; i < receive; i++)
 156                         param[i] = ps2dev->cmdbuf[(receive - 1) - i];
 157
 158         if (ps2dev->cmdcnt && (command != PS2_CMD_RESET_BAT || ps2dev->cmdcnt != 1))
 159                 goto out;
 160
 161         rc = 0;
 162
 163 out:
 164         serio_pause_rx(ps2dev->serio);
 165         ps2dev->flags = 0;
 166         serio_continue_rx(ps2dev->serio);
 167
 168         up(&ps2dev->cmd_sem);
 169         return rc;
 170 }
 171
 172 /*
 173  * ps2_execute_scheduled_command() sends a command, previously scheduled by
 174  * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
 175  */
 176
 177 static void ps2_execute_scheduled_command(void *data)
 178 {
 179         struct ps2work *ps2work = data;
 180
 181         ps2_command(ps2work->ps2dev, ps2work->param, ps2work->command);
 182         kfree(ps2work);
 183 }
 184
 185 /*
 186  * ps2_schedule_command() allows to schedule delayed execution of a PS/2
 187  * command and can be used to issue a command from an interrupt or softirq
 188  * context.
 189  */
 190
 191 int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command)
 192 {
 193         struct ps2work *ps2work;
 194         int send = (command >> 12) & 0xf;
 195         int receive = (command >> 8) & 0xf;
 196
 197         if (!(ps2work = kmalloc(sizeof(struct ps2work) + max(send, receive), GFP_ATOMIC)))
 198                 return -1;
 199
 200         memset(ps2work, 0, sizeof(struct ps2work));
 201         ps2work->ps2dev = ps2dev;
 202         ps2work->command = command;
 203         memcpy(ps2work->param, param, send);
 204         INIT_WORK(&ps2work->work, ps2_execute_scheduled_command, ps2work);
 205
 206         if (!schedule_work(&ps2work->work)) {
 207                 kfree(ps2work);
 208                 return -1;
 209         }
 210
 211         return 0;
 212 }
 213
 214 /*
 215  * ps2_init() initializes ps2dev structure
 216  */
 217
 218 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
 219 {
 220         init_MUTEX(&ps2dev->cmd_sem);
 221         init_waitqueue_head(&ps2dev->wait);
 222         ps2dev->serio = serio;
 223 }
 224
 225 /*
 226  * ps2_handle_ack() is supposed to be used in interrupt handler
 227  * to properly process ACK/NAK of a command from a PS/2 device.
 228  */
 229
 230 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data)
 231 {
 232         switch (data) {
 233                 case PS2_RET_ACK:
 234                         ps2dev->nak = 0;
 235                         break;
 236
 237                 case PS2_RET_NAK:
 238                         ps2dev->nak = 1;
 239                         break;
 240
 241                 /*
 242                  * Workaround for mice which don't ACK the Get ID command.
 243                  * These are valid mouse IDs that we recognize.
 244                  */
 245                 case 0x00:
 246                 case 0x03:
 247                 case 0x04:
 248                         if (ps2dev->flags & PS2_FLAG_WAITID) {
 249                                 ps2dev->nak = 0;
 250                                 break;
 251                         }
 252                         /* Fall through */
 253                 default:
 254                         return 0;
 255         }
 256
 257
 258         if (!ps2dev->nak && ps2dev->cmdcnt)
 259                 ps2dev->flags |= PS2_FLAG_CMD | PS2_FLAG_CMD1;
 260
 261         ps2dev->flags &= ~PS2_FLAG_ACK;
 262         wake_up(&ps2dev->wait);
 263
 264         if (data != PS2_RET_ACK)
 265                 ps2_handle_response(ps2dev, data);
 266
 267         return 1;
 268 }
 269
 270 /*
 271  * ps2_handle_response() is supposed to be used in interrupt handler
 272  * to properly store device's response to a command and notify process
 273  * waiting for completion of the command.
 274  */
 275
 276 int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data)
 277 {
 278         if (ps2dev->cmdcnt)
 279                 ps2dev->cmdbuf[--ps2dev->cmdcnt] = data;
 280
 281         if (ps2dev->flags & PS2_FLAG_CMD1) {
 282                 ps2dev->flags &= ~PS2_FLAG_CMD1;
 283                 if (ps2dev->cmdcnt)
 284                         wake_up(&ps2dev->wait);
 285         }
 286
 287         if (!ps2dev->cmdcnt) {
 288                 ps2dev->flags &= ~PS2_FLAG_CMD;
 289                 wake_up(&ps2dev->wait);
 290         }
 291
 292         return 1;
 293 }
 294
 295 void ps2_cmd_aborted(struct ps2dev *ps2dev)
 296 {
 297         if (ps2dev->flags & PS2_FLAG_ACK)
 298                 ps2dev->nak = 1;
 299
 300         if (ps2dev->flags & (PS2_FLAG_ACK | PS2_FLAG_CMD))
 301                 wake_up(&ps2dev->wait);
 302
 303         ps2dev->flags = 0;
 304 }
 305