drivers/input/mouse/vmmouse.c

   1 /*
   2  * Driver for Virtual PS/2 Mouse on VMware and QEMU hypervisors.
   3  *
   4  * Copyright (C) 2014, VMware, Inc. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * Twin device code is hugely inspired by the ALPS driver.
  11  * Authors:
  12  *   Dmitry Torokhov <dmitry.torokhov@gmail.com>
  13  *   Thomas Hellstrom <thellstrom@vmware.com>
  14  */
  15
  16 #include <linux/input.h>
  17 #include <linux/serio.h>
  18 #include <linux/libps2.h>
  19 #include <linux/slab.h>
  20 #include <linux/module.h>
  21 #include <asm/hypervisor.h>
  22
  23 #include "psmouse.h"
  24 #include "vmmouse.h"
  25
  26 #define VMMOUSE_PROTO_MAGIC                     0x564D5868U
  27 #define VMMOUSE_PROTO_PORT                      0x5658
  28
  29 /*
  30  * Main commands supported by the vmmouse hypervisor port.
  31  */
  32 #define VMMOUSE_PROTO_CMD_GETVERSION            10
  33 #define VMMOUSE_PROTO_CMD_ABSPOINTER_DATA       39
  34 #define VMMOUSE_PROTO_CMD_ABSPOINTER_STATUS     40
  35 #define VMMOUSE_PROTO_CMD_ABSPOINTER_COMMAND    41
  36 #define VMMOUSE_PROTO_CMD_ABSPOINTER_RESTRICT   86
  37
  38 /*
  39  * Subcommands for VMMOUSE_PROTO_CMD_ABSPOINTER_COMMAND
  40  */
  41 #define VMMOUSE_CMD_ENABLE                      0x45414552U
  42 #define VMMOUSE_CMD_DISABLE                     0x000000f5U
  43 #define VMMOUSE_CMD_REQUEST_RELATIVE            0x4c455252U
  44 #define VMMOUSE_CMD_REQUEST_ABSOLUTE            0x53424152U
  45
  46 #define VMMOUSE_ERROR                           0xffff0000U
  47
  48 #define VMMOUSE_VERSION_ID                      0x3442554aU
  49
  50 #define VMMOUSE_RELATIVE_PACKET                 0x00010000U
  51
  52 #define VMMOUSE_LEFT_BUTTON                     0x20
  53 #define VMMOUSE_RIGHT_BUTTON                    0x10
  54 #define VMMOUSE_MIDDLE_BUTTON                   0x08
  55
  56 /*
  57  * VMMouse Restrict command
  58  */
  59 #define VMMOUSE_RESTRICT_ANY                    0x00
  60 #define VMMOUSE_RESTRICT_CPL0                   0x01
  61 #define VMMOUSE_RESTRICT_IOPL                   0x02
  62
  63 #define VMMOUSE_MAX_X                           0xFFFF
  64 #define VMMOUSE_MAX_Y                           0xFFFF
  65
  66 #define VMMOUSE_VENDOR "VMware"
  67 #define VMMOUSE_NAME   "VMMouse"
  68
  69 /**
  70  * struct vmmouse_data - private data structure for the vmmouse driver
  71  *
  72  * @abs_dev: "Absolute" device used to report absolute mouse movement.
  73  * @phys: Physical path for the absolute device.
  74  * @dev_name: Name attribute name for the absolute device.
  75  */
  76 struct vmmouse_data {
  77         struct input_dev *abs_dev;
  78         char phys[32];
  79         char dev_name[128];
  80 };
  81
  82 /**
  83  * Hypervisor-specific bi-directional communication channel
  84  * implementing the vmmouse protocol. Should never execute on
  85  * bare metal hardware.
  86  */
  87 #define VMMOUSE_CMD(cmd, in1, out1, out2, out3, out4)   \
  88 ({                                                      \
  89         unsigned long __dummy1, __dummy2;               \
  90         __asm__ __volatile__ ("inl %%dx" :              \
  91                 "=a"(out1),                             \
  92                 "=b"(out2),                             \
  93                 "=c"(out3),                             \
  94                 "=d"(out4),                             \
  95                 "=S"(__dummy1),                         \
  96                 "=D"(__dummy2) :                        \
  97                 "a"(VMMOUSE_PROTO_MAGIC),               \
  98                 "b"(in1),                               \
  99                 "c"(VMMOUSE_PROTO_CMD_##cmd),           \
 100                 "d"(VMMOUSE_PROTO_PORT) :               \
 101                 "memory");                              \
 102 })
 103
 104 /**
 105  * vmmouse_report_button - report button state on the correct input device
 106  *
 107  * @psmouse:  Pointer to the psmouse struct
 108  * @abs_dev:  The absolute input device
 109  * @rel_dev:  The relative input device
 110  * @pref_dev: The preferred device for reporting
 111  * @code:     Button code
 112  * @value:    Button value
 113  *
 114  * Report @value and @code on @pref_dev, unless the button is already
 115  * pressed on the other device, in which case the state is reported on that
 116  * device.
 117  */
 118 static void vmmouse_report_button(struct psmouse *psmouse,
 119                                   struct input_dev *abs_dev,
 120                                   struct input_dev *rel_dev,
 121                                   struct input_dev *pref_dev,
 122                                   unsigned int code, int value)
 123 {
 124         if (test_bit(code, abs_dev->key))
 125                 pref_dev = abs_dev;
 126         else if (test_bit(code, rel_dev->key))
 127                 pref_dev = rel_dev;
 128
 129         input_report_key(pref_dev, code, value);
 130 }
 131
 132 /**
 133  * vmmouse_report_events - process events on the vmmouse communications channel
 134  *
 135  * @psmouse: Pointer to the psmouse struct
 136  *
 137  * This function pulls events from the vmmouse communications channel and
 138  * reports them on the correct (absolute or relative) input device. When the
 139  * communications channel is drained, or if we've processed more than 255
 140  * psmouse commands, the function returns PSMOUSE_FULL_PACKET. If there is a
 141  * host- or synchronization error, the function returns PSMOUSE_BAD_DATA in
 142  * the hope that the caller will reset the communications channel.
 143  */
 144 static psmouse_ret_t vmmouse_report_events(struct psmouse *psmouse)
 145 {
 146         struct input_dev *rel_dev = psmouse->dev;
 147         struct vmmouse_data *priv = psmouse->private;
 148         struct input_dev *abs_dev = priv->abs_dev;
 149         struct input_dev *pref_dev;
 150         u32 status, x, y, z;
 151         u32 dummy1, dummy2, dummy3;
 152         unsigned int queue_length;
 153         unsigned int count = 255;
 154
 155         while (count--) {
 156                 /* See if we have motion data. */
 157                 VMMOUSE_CMD(ABSPOINTER_STATUS, 0,
 158                             status, dummy1, dummy2, dummy3);
 159                 if ((status & VMMOUSE_ERROR) == VMMOUSE_ERROR) {
 160                         psmouse_err(psmouse, "failed to fetch status data\n");
 161                         /*
 162                          * After a few attempts this will result in
 163                          * reconnect.
 164                          */
 165                         return PSMOUSE_BAD_DATA;
 166                 }
 167
 168                 queue_length = status & 0xffff;
 169                 if (queue_length == 0)
 170                         break;
 171
 172                 if (queue_length % 4) {
 173                         psmouse_err(psmouse, "invalid queue length\n");
 174                         return PSMOUSE_BAD_DATA;
 175                 }
 176
 177                 /* Now get it */
 178                 VMMOUSE_CMD(ABSPOINTER_DATA, 4, status, x, y, z);
 179
 180                 /*
 181                  * And report what we've got. Prefer to report button
 182                  * events on the same device where we report motion events.
 183                  * This doesn't work well with the mouse wheel, though. See
 184                  * below. Ideally we would want to report that on the
 185                  * preferred device as well.
 186                  */
 187                 if (status & VMMOUSE_RELATIVE_PACKET) {
 188                         pref_dev = rel_dev;
 189                         input_report_rel(rel_dev, REL_X, (s32)x);
 190                         input_report_rel(rel_dev, REL_Y, -(s32)y);
 191                 } else {
 192                         pref_dev = abs_dev;
 193                         input_report_abs(abs_dev, ABS_X, x);
 194                         input_report_abs(abs_dev, ABS_Y, y);
 195                 }
 196
 197                 /* Xorg seems to ignore wheel events on absolute devices */
 198                 input_report_rel(rel_dev, REL_WHEEL, -(s8)((u8) z));
 199
 200                 vmmouse_report_button(psmouse, abs_dev, rel_dev,
 201                                       pref_dev, BTN_LEFT,
 202                                       status & VMMOUSE_LEFT_BUTTON);
 203                 vmmouse_report_button(psmouse, abs_dev, rel_dev,
 204                                       pref_dev, BTN_RIGHT,
 205                                       status & VMMOUSE_RIGHT_BUTTON);
 206                 vmmouse_report_button(psmouse, abs_dev, rel_dev,
 207                                       pref_dev, BTN_MIDDLE,
 208                                       status & VMMOUSE_MIDDLE_BUTTON);
 209                 input_sync(abs_dev);
 210                 input_sync(rel_dev);
 211         }
 212
 213         return PSMOUSE_FULL_PACKET;
 214 }
 215
 216 /**
 217  * vmmouse_process_byte - process data on the ps/2 channel
 218  *
 219  * @psmouse: Pointer to the psmouse struct
 220  *
 221  * When the ps/2 channel indicates that there is vmmouse data available,
 222  * call vmmouse channel processing. Otherwise, continue to accept bytes. If
 223  * there is a synchronization or communication data error, return
 224  * PSMOUSE_BAD_DATA in the hope that the caller will reset the mouse.
 225  */
 226 static psmouse_ret_t vmmouse_process_byte(struct psmouse *psmouse)
 227 {
 228         unsigned char *packet = psmouse->packet;
 229
 230         switch (psmouse->pktcnt) {
 231         case 1:
 232                 return (packet[0] & 0x8) == 0x8 ?
 233                         PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
 234
 235         case 2:
 236                 return PSMOUSE_GOOD_DATA;
 237
 238         default:
 239                 return vmmouse_report_events(psmouse);
 240         }
 241 }
 242
 243 /**
 244  * vmmouse_disable - Disable vmmouse
 245  *
 246  * @psmouse: Pointer to the psmouse struct
 247  *
 248  * Tries to disable vmmouse mode.
 249  */
 250 static void vmmouse_disable(struct psmouse *psmouse)
 251 {
 252         u32 status;
 253         u32 dummy1, dummy2, dummy3, dummy4;
 254
 255         VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_DISABLE,
 256                     dummy1, dummy2, dummy3, dummy4);
 257
 258         VMMOUSE_CMD(ABSPOINTER_STATUS, 0,
 259                     status, dummy1, dummy2, dummy3);
 260
 261         if ((status & VMMOUSE_ERROR) != VMMOUSE_ERROR)
 262                 psmouse_warn(psmouse, "failed to disable vmmouse device\n");
 263 }
 264
 265 /**
 266  * vmmouse_enable - Enable vmmouse and request absolute mode.
 267  *
 268  * @psmouse: Pointer to the psmouse struct
 269  *
 270  * Tries to enable vmmouse mode. Performs basic checks and requests
 271  * absolute vmmouse mode.
 272  * Returns 0 on success, -ENODEV on failure.
 273  */
 274 static int vmmouse_enable(struct psmouse *psmouse)
 275 {
 276         u32 status, version;
 277         u32 dummy1, dummy2, dummy3, dummy4;
 278
 279         /*
 280          * Try enabling the device. If successful, we should be able to
 281          * read valid version ID back from it.
 282          */
 283         VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_ENABLE,
 284                     dummy1, dummy2, dummy3, dummy4);
 285
 286         /*
 287          * See if version ID can be retrieved.
 288          */
 289         VMMOUSE_CMD(ABSPOINTER_STATUS, 0, status, dummy1, dummy2, dummy3);
 290         if ((status & 0x0000ffff) == 0) {
 291                 psmouse_dbg(psmouse, "empty flags - assuming no device\n");
 292                 return -ENXIO;
 293         }
 294
 295         VMMOUSE_CMD(ABSPOINTER_DATA, 1 /* single item */,
 296                     version, dummy1, dummy2, dummy3);
 297         if (version != VMMOUSE_VERSION_ID) {
 298                 psmouse_dbg(psmouse, "Unexpected version value: %u vs %u\n",
 299                             (unsigned) version, VMMOUSE_VERSION_ID);
 300                 vmmouse_disable(psmouse);
 301                 return -ENXIO;
 302         }
 303
 304         /*
 305          * Restrict ioport access, if possible.
 306          */
 307         VMMOUSE_CMD(ABSPOINTER_RESTRICT, VMMOUSE_RESTRICT_CPL0,
 308                     dummy1, dummy2, dummy3, dummy4);
 309
 310         VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_REQUEST_ABSOLUTE,
 311                     dummy1, dummy2, dummy3, dummy4);
 312
 313         return 0;
 314 }
 315
 316 /*
 317  * Array of supported hypervisors.
 318  */
 319 static const struct hypervisor_x86 *vmmouse_supported_hypervisors[] = {
 320         &x86_hyper_vmware,
 321 #ifdef CONFIG_KVM_GUEST
 322         &x86_hyper_kvm,
 323 #endif
 324 };
 325
 326 /**
 327  * vmmouse_check_hypervisor - Check if we're running on a supported hypervisor
 328  */
 329 static bool vmmouse_check_hypervisor(void)
 330 {
 331         int i;
 332
 333         for (i = 0; i < ARRAY_SIZE(vmmouse_supported_hypervisors); i++)
 334                 if (vmmouse_supported_hypervisors[i] == x86_hyper)
 335                         return true;
 336
 337         return false;
 338 }
 339
 340 /**
 341  * vmmouse_detect - Probe whether vmmouse is available
 342  *
 343  * @psmouse: Pointer to the psmouse struct
 344  * @set_properties: Whether to set psmouse name and vendor
 345  *
 346  * Returns 0 if vmmouse channel is available. Negative error code if not.
 347  */
 348 int vmmouse_detect(struct psmouse *psmouse, bool set_properties)
 349 {
 350         u32 response, version, dummy1, dummy2;
 351
 352         if (!vmmouse_check_hypervisor()) {
 353                 psmouse_dbg(psmouse,
 354                             "VMMouse not running on supported hypervisor.\n");
 355                 return -ENXIO;
 356         }
 357
 358         if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
 359                 psmouse_dbg(psmouse, "VMMouse port in use.\n");
 360                 return -EBUSY;
 361         }
 362
 363         /* Check if the device is present */
 364         response = ~VMMOUSE_PROTO_MAGIC;
 365         VMMOUSE_CMD(GETVERSION, 0, version, response, dummy1, dummy2);
 366         if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU) {
 367                 release_region(VMMOUSE_PROTO_PORT, 4);
 368                 return -ENXIO;
 369         }
 370
 371         if (set_properties) {
 372                 psmouse->vendor = VMMOUSE_VENDOR;
 373                 psmouse->name = VMMOUSE_NAME;
 374                 psmouse->model = version;
 375         }
 376
 377         release_region(VMMOUSE_PROTO_PORT, 4);
 378
 379         return 0;
 380 }
 381
 382 /**
 383  * vmmouse_disconnect - Take down vmmouse driver
 384  *
 385  * @psmouse: Pointer to the psmouse struct
 386  *
 387  * Takes down vmmouse driver and frees resources set up in vmmouse_init().
 388  */
 389 static void vmmouse_disconnect(struct psmouse *psmouse)
 390 {
 391         struct vmmouse_data *priv = psmouse->private;
 392
 393         vmmouse_disable(psmouse);
 394         psmouse_reset(psmouse);
 395         input_unregister_device(priv->abs_dev);
 396         kfree(priv);
 397         release_region(VMMOUSE_PROTO_PORT, 4);
 398 }
 399
 400 /**
 401  * vmmouse_reconnect - Reset the ps/2 - and vmmouse connections
 402  *
 403  * @psmouse: Pointer to the psmouse struct
 404  *
 405  * Attempts to reset the mouse connections. Returns 0 on success and
 406  * -1 on failure.
 407  */
 408 static int vmmouse_reconnect(struct psmouse *psmouse)
 409 {
 410         int error;
 411
 412         psmouse_reset(psmouse);
 413         vmmouse_disable(psmouse);
 414         error = vmmouse_enable(psmouse);
 415         if (error) {
 416                 psmouse_err(psmouse,
 417                             "Unable to re-enable mouse when reconnecting, err: %d\n",
 418                             error);
 419                 return error;
 420         }
 421
 422         return 0;
 423 }
 424
 425 /**
 426  * vmmouse_init - Initialize the vmmouse driver
 427  *
 428  * @psmouse: Pointer to the psmouse struct
 429  *
 430  * Requests the device and tries to enable vmmouse mode.
 431  * If successful, sets up the input device for relative movement events.
 432  * It also allocates another input device and sets it up for absolute motion
 433  * events. Returns 0 on success and -1 on failure.
 434  */
 435 int vmmouse_init(struct psmouse *psmouse)
 436 {
 437         struct vmmouse_data *priv;
 438         struct input_dev *rel_dev = psmouse->dev, *abs_dev;
 439         int error;
 440
 441         if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
 442                 psmouse_dbg(psmouse, "VMMouse port in use.\n");
 443                 return -EBUSY;
 444         }
 445
 446         psmouse_reset(psmouse);
 447         error = vmmouse_enable(psmouse);
 448         if (error)
 449                 goto release_region;
 450
 451         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 452         abs_dev = input_allocate_device();
 453         if (!priv || !abs_dev) {
 454                 error = -ENOMEM;
 455                 goto init_fail;
 456         }
 457
 458         priv->abs_dev = abs_dev;
 459         psmouse->private = priv;
 460
 461         input_set_capability(rel_dev, EV_REL, REL_WHEEL);
 462
 463         /* Set up and register absolute device */
 464         snprintf(priv->phys, sizeof(priv->phys), "%s/input1",
 465                  psmouse->ps2dev.serio->phys);
 466
 467         /* Mimic name setup for relative device in psmouse-base.c */
 468         snprintf(priv->dev_name, sizeof(priv->dev_name), "%s %s %s",
 469                  VMMOUSE_PSNAME, VMMOUSE_VENDOR, VMMOUSE_NAME);
 470         abs_dev->phys = priv->phys;
 471         abs_dev->name = priv->dev_name;
 472         abs_dev->id.bustype = BUS_I8042;
 473         abs_dev->id.vendor = 0x0002;
 474         abs_dev->id.product = PSMOUSE_VMMOUSE;
 475         abs_dev->id.version = psmouse->model;
 476         abs_dev->dev.parent = &psmouse->ps2dev.serio->dev;
 477
 478         error = input_register_device(priv->abs_dev);
 479         if (error)
 480                 goto init_fail;
 481
 482         /* Set absolute device capabilities */
 483         input_set_capability(abs_dev, EV_KEY, BTN_LEFT);
 484         input_set_capability(abs_dev, EV_KEY, BTN_RIGHT);
 485         input_set_capability(abs_dev, EV_KEY, BTN_MIDDLE);
 486         input_set_capability(abs_dev, EV_ABS, ABS_X);
 487         input_set_capability(abs_dev, EV_ABS, ABS_Y);
 488         input_set_abs_params(abs_dev, ABS_X, 0, VMMOUSE_MAX_X, 0, 0);
 489         input_set_abs_params(abs_dev, ABS_Y, 0, VMMOUSE_MAX_Y, 0, 0);
 490
 491         psmouse->protocol_handler = vmmouse_process_byte;
 492         psmouse->disconnect = vmmouse_disconnect;
 493         psmouse->reconnect = vmmouse_reconnect;
 494
 495         return 0;
 496
 497 init_fail:
 498         vmmouse_disable(psmouse);
 499         psmouse_reset(psmouse);
 500         input_free_device(abs_dev);
 501         kfree(priv);
 502         psmouse->private = NULL;
 503
 504 release_region:
 505         release_region(VMMOUSE_PROTO_PORT, 4);
 506
 507         return error;
 508 }