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 <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/*
 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 */
 70struct 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 */
 90static 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 */
116static 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 */
197static 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 */
221static 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 */
241static 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 */
284static 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 */
292static 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 */
311int 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 */
343static 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 */
356static 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 */
374static 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 */
401int 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
460init_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}