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 /* Set up and register absolute device */ 462 snprintf(priv->phys, sizeof(priv->phys), "%s/input1", 463 psmouse->ps2dev.serio->phys); 464 465 /* Mimic name setup for relative device in psmouse-base.c */ 466 snprintf(priv->dev_name, sizeof(priv->dev_name), "%s %s %s", 467 VMMOUSE_PSNAME, VMMOUSE_VENDOR, VMMOUSE_NAME); 468 abs_dev->phys = priv->phys; 469 abs_dev->name = priv->dev_name; 470 abs_dev->id.bustype = BUS_I8042; 471 abs_dev->id.vendor = 0x0002; 472 abs_dev->id.product = PSMOUSE_VMMOUSE; 473 abs_dev->id.version = psmouse->model; 474 abs_dev->dev.parent = &psmouse->ps2dev.serio->dev; 475 476 /* Set absolute device capabilities */ 477 input_set_capability(abs_dev, EV_KEY, BTN_LEFT); 478 input_set_capability(abs_dev, EV_KEY, BTN_RIGHT); 479 input_set_capability(abs_dev, EV_KEY, BTN_MIDDLE); 480 input_set_capability(abs_dev, EV_ABS, ABS_X); 481 input_set_capability(abs_dev, EV_ABS, ABS_Y); 482 input_set_abs_params(abs_dev, ABS_X, 0, VMMOUSE_MAX_X, 0, 0); 483 input_set_abs_params(abs_dev, ABS_Y, 0, VMMOUSE_MAX_Y, 0, 0); 484 485 error = input_register_device(priv->abs_dev); 486 if (error) 487 goto init_fail; 488 489 /* Add wheel capability to the relative device */ 490 input_set_capability(rel_dev, EV_REL, REL_WHEEL); 491 492 psmouse->protocol_handler = vmmouse_process_byte; 493 psmouse->disconnect = vmmouse_disconnect; 494 psmouse->reconnect = vmmouse_reconnect; 495 496 return 0; 497 498 init_fail: 499 vmmouse_disable(psmouse); 500 psmouse_reset(psmouse); 501 input_free_device(abs_dev); 502 kfree(priv); 503 psmouse->private = NULL; 504 505 release_region: 506 release_region(VMMOUSE_PROTO_PORT, 4); 507 508 return error; 509 } 510