drivers/input/mouse/vmmouse.c

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