forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
486 lines
13 KiB
486 lines
13 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Driver for Virtual PS/2 Mouse on VMware and QEMU hypervisors. |
|
* |
|
* Copyright (C) 2014, VMware, Inc. All Rights Reserved. |
|
* |
|
* Twin device code is hugely inspired by the ALPS driver. |
|
* Authors: |
|
* Dmitry Torokhov <[email protected]> |
|
* Thomas Hellstrom <[email protected]> |
|
*/ |
|
|
|
#include <linux/input.h> |
|
#include <linux/serio.h> |
|
#include <linux/libps2.h> |
|
#include <linux/slab.h> |
|
#include <linux/module.h> |
|
#include <asm/hypervisor.h> |
|
#include <asm/vmware.h> |
|
|
|
#include "psmouse.h" |
|
#include "vmmouse.h" |
|
|
|
#define VMMOUSE_PROTO_MAGIC 0x564D5868U |
|
|
|
/* |
|
* Main commands supported by the vmmouse hypervisor port. |
|
*/ |
|
#define VMMOUSE_PROTO_CMD_GETVERSION 10 |
|
#define VMMOUSE_PROTO_CMD_ABSPOINTER_DATA 39 |
|
#define VMMOUSE_PROTO_CMD_ABSPOINTER_STATUS 40 |
|
#define VMMOUSE_PROTO_CMD_ABSPOINTER_COMMAND 41 |
|
#define VMMOUSE_PROTO_CMD_ABSPOINTER_RESTRICT 86 |
|
|
|
/* |
|
* Subcommands for VMMOUSE_PROTO_CMD_ABSPOINTER_COMMAND |
|
*/ |
|
#define VMMOUSE_CMD_ENABLE 0x45414552U |
|
#define VMMOUSE_CMD_DISABLE 0x000000f5U |
|
#define VMMOUSE_CMD_REQUEST_RELATIVE 0x4c455252U |
|
#define VMMOUSE_CMD_REQUEST_ABSOLUTE 0x53424152U |
|
|
|
#define VMMOUSE_ERROR 0xffff0000U |
|
|
|
#define VMMOUSE_VERSION_ID 0x3442554aU |
|
|
|
#define VMMOUSE_RELATIVE_PACKET 0x00010000U |
|
|
|
#define VMMOUSE_LEFT_BUTTON 0x20 |
|
#define VMMOUSE_RIGHT_BUTTON 0x10 |
|
#define VMMOUSE_MIDDLE_BUTTON 0x08 |
|
|
|
/* |
|
* VMMouse Restrict command |
|
*/ |
|
#define VMMOUSE_RESTRICT_ANY 0x00 |
|
#define VMMOUSE_RESTRICT_CPL0 0x01 |
|
#define VMMOUSE_RESTRICT_IOPL 0x02 |
|
|
|
#define VMMOUSE_MAX_X 0xFFFF |
|
#define VMMOUSE_MAX_Y 0xFFFF |
|
|
|
#define VMMOUSE_VENDOR "VMware" |
|
#define VMMOUSE_NAME "VMMouse" |
|
|
|
/** |
|
* struct vmmouse_data - private data structure for the vmmouse driver |
|
* |
|
* @abs_dev: "Absolute" device used to report absolute mouse movement. |
|
* @phys: Physical path for the absolute device. |
|
* @dev_name: Name attribute name for the absolute device. |
|
*/ |
|
struct vmmouse_data { |
|
struct input_dev *abs_dev; |
|
char phys[32]; |
|
char dev_name[128]; |
|
}; |
|
|
|
/* |
|
* Hypervisor-specific bi-directional communication channel |
|
* implementing the vmmouse protocol. Should never execute on |
|
* bare metal hardware. |
|
*/ |
|
#define VMMOUSE_CMD(cmd, in1, out1, out2, out3, out4) \ |
|
({ \ |
|
unsigned long __dummy1, __dummy2; \ |
|
__asm__ __volatile__ (VMWARE_HYPERCALL : \ |
|
"=a"(out1), \ |
|
"=b"(out2), \ |
|
"=c"(out3), \ |
|
"=d"(out4), \ |
|
"=S"(__dummy1), \ |
|
"=D"(__dummy2) : \ |
|
"a"(VMMOUSE_PROTO_MAGIC), \ |
|
"b"(in1), \ |
|
"c"(VMMOUSE_PROTO_CMD_##cmd), \ |
|
"d"(0) : \ |
|
"memory"); \ |
|
}) |
|
|
|
/** |
|
* vmmouse_report_button - report button state on the correct input device |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* @abs_dev: The absolute input device |
|
* @rel_dev: The relative input device |
|
* @pref_dev: The preferred device for reporting |
|
* @code: Button code |
|
* @value: Button value |
|
* |
|
* Report @value and @code on @pref_dev, unless the button is already |
|
* pressed on the other device, in which case the state is reported on that |
|
* device. |
|
*/ |
|
static void vmmouse_report_button(struct psmouse *psmouse, |
|
struct input_dev *abs_dev, |
|
struct input_dev *rel_dev, |
|
struct input_dev *pref_dev, |
|
unsigned int code, int value) |
|
{ |
|
if (test_bit(code, abs_dev->key)) |
|
pref_dev = abs_dev; |
|
else if (test_bit(code, rel_dev->key)) |
|
pref_dev = rel_dev; |
|
|
|
input_report_key(pref_dev, code, value); |
|
} |
|
|
|
/** |
|
* vmmouse_report_events - process events on the vmmouse communications channel |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* This function pulls events from the vmmouse communications channel and |
|
* reports them on the correct (absolute or relative) input device. When the |
|
* communications channel is drained, or if we've processed more than 255 |
|
* psmouse commands, the function returns PSMOUSE_FULL_PACKET. If there is a |
|
* host- or synchronization error, the function returns PSMOUSE_BAD_DATA in |
|
* the hope that the caller will reset the communications channel. |
|
*/ |
|
static psmouse_ret_t vmmouse_report_events(struct psmouse *psmouse) |
|
{ |
|
struct input_dev *rel_dev = psmouse->dev; |
|
struct vmmouse_data *priv = psmouse->private; |
|
struct input_dev *abs_dev = priv->abs_dev; |
|
struct input_dev *pref_dev; |
|
u32 status, x, y, z; |
|
u32 dummy1, dummy2, dummy3; |
|
unsigned int queue_length; |
|
unsigned int count = 255; |
|
|
|
while (count--) { |
|
/* See if we have motion data. */ |
|
VMMOUSE_CMD(ABSPOINTER_STATUS, 0, |
|
status, dummy1, dummy2, dummy3); |
|
if ((status & VMMOUSE_ERROR) == VMMOUSE_ERROR) { |
|
psmouse_err(psmouse, "failed to fetch status data\n"); |
|
/* |
|
* After a few attempts this will result in |
|
* reconnect. |
|
*/ |
|
return PSMOUSE_BAD_DATA; |
|
} |
|
|
|
queue_length = status & 0xffff; |
|
if (queue_length == 0) |
|
break; |
|
|
|
if (queue_length % 4) { |
|
psmouse_err(psmouse, "invalid queue length\n"); |
|
return PSMOUSE_BAD_DATA; |
|
} |
|
|
|
/* Now get it */ |
|
VMMOUSE_CMD(ABSPOINTER_DATA, 4, status, x, y, z); |
|
|
|
/* |
|
* And report what we've got. Prefer to report button |
|
* events on the same device where we report motion events. |
|
* This doesn't work well with the mouse wheel, though. See |
|
* below. Ideally we would want to report that on the |
|
* preferred device as well. |
|
*/ |
|
if (status & VMMOUSE_RELATIVE_PACKET) { |
|
pref_dev = rel_dev; |
|
input_report_rel(rel_dev, REL_X, (s32)x); |
|
input_report_rel(rel_dev, REL_Y, -(s32)y); |
|
} else { |
|
pref_dev = abs_dev; |
|
input_report_abs(abs_dev, ABS_X, x); |
|
input_report_abs(abs_dev, ABS_Y, y); |
|
} |
|
|
|
/* Xorg seems to ignore wheel events on absolute devices */ |
|
input_report_rel(rel_dev, REL_WHEEL, -(s8)((u8) z)); |
|
|
|
vmmouse_report_button(psmouse, abs_dev, rel_dev, |
|
pref_dev, BTN_LEFT, |
|
status & VMMOUSE_LEFT_BUTTON); |
|
vmmouse_report_button(psmouse, abs_dev, rel_dev, |
|
pref_dev, BTN_RIGHT, |
|
status & VMMOUSE_RIGHT_BUTTON); |
|
vmmouse_report_button(psmouse, abs_dev, rel_dev, |
|
pref_dev, BTN_MIDDLE, |
|
status & VMMOUSE_MIDDLE_BUTTON); |
|
input_sync(abs_dev); |
|
input_sync(rel_dev); |
|
} |
|
|
|
return PSMOUSE_FULL_PACKET; |
|
} |
|
|
|
/** |
|
* vmmouse_process_byte - process data on the ps/2 channel |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* When the ps/2 channel indicates that there is vmmouse data available, |
|
* call vmmouse channel processing. Otherwise, continue to accept bytes. If |
|
* there is a synchronization or communication data error, return |
|
* PSMOUSE_BAD_DATA in the hope that the caller will reset the mouse. |
|
*/ |
|
static psmouse_ret_t vmmouse_process_byte(struct psmouse *psmouse) |
|
{ |
|
unsigned char *packet = psmouse->packet; |
|
|
|
switch (psmouse->pktcnt) { |
|
case 1: |
|
return (packet[0] & 0x8) == 0x8 ? |
|
PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA; |
|
|
|
case 2: |
|
return PSMOUSE_GOOD_DATA; |
|
|
|
default: |
|
return vmmouse_report_events(psmouse); |
|
} |
|
} |
|
|
|
/** |
|
* vmmouse_disable - Disable vmmouse |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* Tries to disable vmmouse mode. |
|
*/ |
|
static void vmmouse_disable(struct psmouse *psmouse) |
|
{ |
|
u32 status; |
|
u32 dummy1, dummy2, dummy3, dummy4; |
|
|
|
VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_DISABLE, |
|
dummy1, dummy2, dummy3, dummy4); |
|
|
|
VMMOUSE_CMD(ABSPOINTER_STATUS, 0, |
|
status, dummy1, dummy2, dummy3); |
|
|
|
if ((status & VMMOUSE_ERROR) != VMMOUSE_ERROR) |
|
psmouse_warn(psmouse, "failed to disable vmmouse device\n"); |
|
} |
|
|
|
/** |
|
* vmmouse_enable - Enable vmmouse and request absolute mode. |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* Tries to enable vmmouse mode. Performs basic checks and requests |
|
* absolute vmmouse mode. |
|
* Returns 0 on success, -ENODEV on failure. |
|
*/ |
|
static int vmmouse_enable(struct psmouse *psmouse) |
|
{ |
|
u32 status, version; |
|
u32 dummy1, dummy2, dummy3, dummy4; |
|
|
|
/* |
|
* Try enabling the device. If successful, we should be able to |
|
* read valid version ID back from it. |
|
*/ |
|
VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_ENABLE, |
|
dummy1, dummy2, dummy3, dummy4); |
|
|
|
/* |
|
* See if version ID can be retrieved. |
|
*/ |
|
VMMOUSE_CMD(ABSPOINTER_STATUS, 0, status, dummy1, dummy2, dummy3); |
|
if ((status & 0x0000ffff) == 0) { |
|
psmouse_dbg(psmouse, "empty flags - assuming no device\n"); |
|
return -ENXIO; |
|
} |
|
|
|
VMMOUSE_CMD(ABSPOINTER_DATA, 1 /* single item */, |
|
version, dummy1, dummy2, dummy3); |
|
if (version != VMMOUSE_VERSION_ID) { |
|
psmouse_dbg(psmouse, "Unexpected version value: %u vs %u\n", |
|
(unsigned) version, VMMOUSE_VERSION_ID); |
|
vmmouse_disable(psmouse); |
|
return -ENXIO; |
|
} |
|
|
|
/* |
|
* Restrict ioport access, if possible. |
|
*/ |
|
VMMOUSE_CMD(ABSPOINTER_RESTRICT, VMMOUSE_RESTRICT_CPL0, |
|
dummy1, dummy2, dummy3, dummy4); |
|
|
|
VMMOUSE_CMD(ABSPOINTER_COMMAND, VMMOUSE_CMD_REQUEST_ABSOLUTE, |
|
dummy1, dummy2, dummy3, dummy4); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Array of supported hypervisors. |
|
*/ |
|
static enum x86_hypervisor_type vmmouse_supported_hypervisors[] = { |
|
X86_HYPER_VMWARE, |
|
X86_HYPER_KVM, |
|
}; |
|
|
|
/** |
|
* vmmouse_check_hypervisor - Check if we're running on a supported hypervisor |
|
*/ |
|
static bool vmmouse_check_hypervisor(void) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < ARRAY_SIZE(vmmouse_supported_hypervisors); i++) |
|
if (vmmouse_supported_hypervisors[i] == x86_hyper_type) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
/** |
|
* vmmouse_detect - Probe whether vmmouse is available |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* @set_properties: Whether to set psmouse name and vendor |
|
* |
|
* Returns 0 if vmmouse channel is available. Negative error code if not. |
|
*/ |
|
int vmmouse_detect(struct psmouse *psmouse, bool set_properties) |
|
{ |
|
u32 response, version, dummy1, dummy2; |
|
|
|
if (!vmmouse_check_hypervisor()) { |
|
psmouse_dbg(psmouse, |
|
"VMMouse not running on supported hypervisor.\n"); |
|
return -ENXIO; |
|
} |
|
|
|
/* Check if the device is present */ |
|
response = ~VMMOUSE_PROTO_MAGIC; |
|
VMMOUSE_CMD(GETVERSION, 0, version, response, dummy1, dummy2); |
|
if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU) |
|
return -ENXIO; |
|
|
|
if (set_properties) { |
|
psmouse->vendor = VMMOUSE_VENDOR; |
|
psmouse->name = VMMOUSE_NAME; |
|
psmouse->model = version; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* vmmouse_disconnect - Take down vmmouse driver |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* Takes down vmmouse driver and frees resources set up in vmmouse_init(). |
|
*/ |
|
static void vmmouse_disconnect(struct psmouse *psmouse) |
|
{ |
|
struct vmmouse_data *priv = psmouse->private; |
|
|
|
vmmouse_disable(psmouse); |
|
psmouse_reset(psmouse); |
|
input_unregister_device(priv->abs_dev); |
|
kfree(priv); |
|
} |
|
|
|
/** |
|
* vmmouse_reconnect - Reset the ps/2 - and vmmouse connections |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* Attempts to reset the mouse connections. Returns 0 on success and |
|
* -1 on failure. |
|
*/ |
|
static int vmmouse_reconnect(struct psmouse *psmouse) |
|
{ |
|
int error; |
|
|
|
psmouse_reset(psmouse); |
|
vmmouse_disable(psmouse); |
|
error = vmmouse_enable(psmouse); |
|
if (error) { |
|
psmouse_err(psmouse, |
|
"Unable to re-enable mouse when reconnecting, err: %d\n", |
|
error); |
|
return error; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* vmmouse_init - Initialize the vmmouse driver |
|
* |
|
* @psmouse: Pointer to the psmouse struct |
|
* |
|
* Requests the device and tries to enable vmmouse mode. |
|
* If successful, sets up the input device for relative movement events. |
|
* It also allocates another input device and sets it up for absolute motion |
|
* events. Returns 0 on success and -1 on failure. |
|
*/ |
|
int vmmouse_init(struct psmouse *psmouse) |
|
{ |
|
struct vmmouse_data *priv; |
|
struct input_dev *rel_dev = psmouse->dev, *abs_dev; |
|
int error; |
|
|
|
psmouse_reset(psmouse); |
|
error = vmmouse_enable(psmouse); |
|
if (error) |
|
return error; |
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
|
abs_dev = input_allocate_device(); |
|
if (!priv || !abs_dev) { |
|
error = -ENOMEM; |
|
goto init_fail; |
|
} |
|
|
|
priv->abs_dev = abs_dev; |
|
psmouse->private = priv; |
|
|
|
/* Set up and register absolute device */ |
|
snprintf(priv->phys, sizeof(priv->phys), "%s/input1", |
|
psmouse->ps2dev.serio->phys); |
|
|
|
/* Mimic name setup for relative device in psmouse-base.c */ |
|
snprintf(priv->dev_name, sizeof(priv->dev_name), "%s %s %s", |
|
VMMOUSE_PSNAME, VMMOUSE_VENDOR, VMMOUSE_NAME); |
|
abs_dev->phys = priv->phys; |
|
abs_dev->name = priv->dev_name; |
|
abs_dev->id.bustype = BUS_I8042; |
|
abs_dev->id.vendor = 0x0002; |
|
abs_dev->id.product = PSMOUSE_VMMOUSE; |
|
abs_dev->id.version = psmouse->model; |
|
abs_dev->dev.parent = &psmouse->ps2dev.serio->dev; |
|
|
|
/* Set absolute device capabilities */ |
|
input_set_capability(abs_dev, EV_KEY, BTN_LEFT); |
|
input_set_capability(abs_dev, EV_KEY, BTN_RIGHT); |
|
input_set_capability(abs_dev, EV_KEY, BTN_MIDDLE); |
|
input_set_capability(abs_dev, EV_ABS, ABS_X); |
|
input_set_capability(abs_dev, EV_ABS, ABS_Y); |
|
input_set_abs_params(abs_dev, ABS_X, 0, VMMOUSE_MAX_X, 0, 0); |
|
input_set_abs_params(abs_dev, ABS_Y, 0, VMMOUSE_MAX_Y, 0, 0); |
|
|
|
error = input_register_device(priv->abs_dev); |
|
if (error) |
|
goto init_fail; |
|
|
|
/* Add wheel capability to the relative device */ |
|
input_set_capability(rel_dev, EV_REL, REL_WHEEL); |
|
|
|
psmouse->protocol_handler = vmmouse_process_byte; |
|
psmouse->disconnect = vmmouse_disconnect; |
|
psmouse->reconnect = vmmouse_reconnect; |
|
|
|
return 0; |
|
|
|
init_fail: |
|
vmmouse_disable(psmouse); |
|
psmouse_reset(psmouse); |
|
input_free_device(abs_dev); |
|
kfree(priv); |
|
psmouse->private = NULL; |
|
|
|
return error; |
|
}
|
|
|