drivers/input/mouse/vmmouse.c

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

DEFINITIONS
