toaruos/modules/vmware.c

/* vim: tabstop=4 shiftwidth=4 noexpandtab
 * This file is part of ToaruOS and is released under the terms
 * of the NCSA / University of Illinois License - see LICENSE.md
 * Copyright (C) 2017-2018 K. Lange
 *
 * VMWare absolute mouse driver.
 *
 * This device is also available by default in QEMU.
 *
 * Toggle off / back on with ioctl 1 and 2 respectively to /dev/vmmouse.
 *
 * Actually supports mouse buttons, unlike the one in VirtualBox.
 */

#include <kernel/system.h>
#include <kernel/fs.h>
#include <kernel/printf.h>
#include <kernel/types.h>
#include <kernel/logging.h>
#include <kernel/module.h>
#include <kernel/video.h>
#include <kernel/pipe.h>
#include <kernel/mouse.h>
#include <kernel/args.h>

#define VMWARE_MAGIC 0x564D5868
#define VMWARE_PORT  0x5658

#define PACKETS_IN_PIPE 1024
#define DISCARD_POINT 32

/* -Wpedantic complains about unnamed unions */
#pragma GCC diagnostic ignored "-Wpedantic"

extern void (*ps2_mouse_alternate)(void); /* modules/mouse.c */

static fs_node_t * mouse_pipe;

typedef struct {
	union {
		uint32_t ax;
		uint32_t magic;
	};
	union {
		uint32_t bx;
		size_t size;
	};
	union {
		uint32_t cx;
		uint16_t command;
	};
	union {
		uint32_t dx;
		uint16_t port;
	};
	uint32_t si;
	uint32_t di;
} vmware_cmd;

static void vmware_io(vmware_cmd * cmd) {
	uint32_t dummy;

	/* Now how's THAT for a VM backdoor... */

	asm volatile(
			"pushl %%ebx\n"
			"pushl %%eax\n"
			"movl 20(%%eax), %%edi\n" /* Load data into registers */
			"movl 16(%%eax), %%esi\n"
			"movl 12(%%eax), %%edx\n"
			"movl  8(%%eax), %%ecx\n"
			"movl  4(%%eax), %%ebx\n"
			"movl   (%%eax), %%eax\n"
			"inl %%dx, %%eax\n"       /* Then trip a magic i/o port */
			"xchgl %%eax, (%%esp)\n"
			"movl %%edi, 20(%%eax)\n" /* Data also comes back out by registers */
			"movl %%esi, 16(%%eax)\n"
			"movl %%edx, 12(%%eax)\n"
			"movl %%ecx,  8(%%eax)\n"
			"movl %%ebx,  4(%%eax)\n"
			"popl (%%eax)\n"
			"popl %%ebx\n"
			: "=a"(dummy)
			: "0"(cmd)
			: "ecx", "edx", "esi", "edi", "memory" /* And vmware / qemu could trash anything they desire... */
	);
}

static void vmware_send(vmware_cmd * cmd) {
	cmd->magic = VMWARE_MAGIC;
	cmd->port = VMWARE_PORT;

	vmware_io(cmd);
}

static void mouse_on(void) {
	vmware_cmd cmd;

	/* Enable */
	cmd.bx = 0x45414552;
	cmd.command = 41;
	vmware_send(&cmd);

	/* Status */
	cmd.bx = 0;
	cmd.command = 40;
	vmware_send(&cmd);

	/* Read data (1) */
	cmd.bx = 1;
	cmd.command = 39;
	vmware_send(&cmd);

	debug_print(WARNING, "Enabled with version ID %x", cmd.ax);
}

static void mouse_off(void) {
	/* Disable the absolute mouse */
	vmware_cmd cmd;
	cmd.bx = 0xf5;
	cmd.command = 41;
	vmware_send(&cmd);
}

static void mouse_absolute(void) {
	/*
	 * Set the mouse to absolute.
	 *
	 * You can also set a relative mode, but there's not
	 * a lot of use in that as disabling the device just
	 * falls back to the PS/2 (or USB, I guess) device anyway,
	 * so instead of using that we just... turn it off.
	 */

	vmware_cmd cmd;
	cmd.bx = 0x53424152; /* request absolute */
	cmd.command = 41; /* request for abs/rel */
	vmware_send(&cmd);
}

volatile int8_t vmware_mouse_byte;

static void vmware_mouse(void) {
	/* unused, but we need to read the fake mouse event bytes from the PS/2 device. */
	vmware_mouse_byte = inportb(0x60);

	/* Read status byte. */
	vmware_cmd cmd;
	cmd.bx = 0;
	cmd.command = 40;
	vmware_send(&cmd);

	if (cmd.ax == 0xffff0000) {
		/* Device error; turn it off and back on again. */
		mouse_off();
		mouse_on();
		mouse_absolute();
		return;
	}

	int words = cmd.ax & 0xFFFF;

	if (!words || words % 4) {
		/* If we don't have data, or for some reason data isn't a multiple of 4... bail */
		return;
	}

	/* Read 4 bytes of data */
	cmd.bx = 4; /* how many */
	cmd.command = 39; /* read */
	vmware_send(&cmd);

	/*
	 * I guess the flags tell you if this was relative or absolute, so if we
	 * actually used the relative mode, we'd want to check that, but...
	 */
	int flags   = (cmd.ax & 0xFFFF0000) >> 16;
	int buttons = (cmd.ax & 0x0000FFFF);

	debug_print(INFO, "flags=%4x buttons=%4x", flags, buttons);
	debug_print(INFO, "x=%x y=%x z=%x", cmd.bx, cmd.cx, cmd.dx);

	unsigned int x = 0;
	unsigned int y = 0;

	if (lfb_vid_memory && lfb_resolution_x && lfb_resolution_y) {
		/*
		 * Just like the virtualbox stuff, this is based on a mapping
		 * to the display resolution, independently scaled in
		 * each dimension...
		 */
		x = ((unsigned int)cmd.bx * lfb_resolution_x) / 0xFFFF;
		y = ((unsigned int)cmd.cx * lfb_resolution_y) / 0xFFFF;
	} else {
		x = cmd.bx;
		y = cmd.cx;
	}

	mouse_device_packet_t packet;
	packet.magic = MOUSE_MAGIC;
	packet.x_difference = x;
	packet.y_difference = y;
	packet.buttons = 0;

	/* The particular bits for the buttons seem weird, but okay... */
	if (buttons & 0x20) {
		packet.buttons |= LEFT_CLICK;
	}
	if (buttons & 0x10) {
		packet.buttons |= RIGHT_CLICK;
	}
	if (buttons & 0x08) {
		packet.buttons |= MIDDLE_CLICK;
	}

	/* dx = z = scroll amount */
	if ((int8_t)cmd.dx > 0) {
		packet.buttons |= MOUSE_SCROLL_DOWN;
	} else if ((int8_t)cmd.dx < 0) {
		packet.buttons |= MOUSE_SCROLL_UP;
	}

	mouse_device_packet_t bitbucket;
	while (pipe_size(mouse_pipe) > (int)(DISCARD_POINT * sizeof(packet))) {
		read_fs(mouse_pipe, 0, sizeof(packet), (uint8_t *)&bitbucket);
	}
	write_fs(mouse_pipe, 0, sizeof(packet), (uint8_t *)&packet);
}

static int detect_device(void) {
	vmware_cmd cmd;

	/* read version */
	cmd.bx = ~VMWARE_MAGIC;
	cmd.command = 10;
	vmware_send(&cmd);

	if (cmd.bx != VMWARE_MAGIC || cmd.ax == 0xFFFFFFFF) {
		/* Not a vmware device... */
		return 0;
	}

	/* Good to go! */
	return 1;
}

static int ioctl_mouse(fs_node_t * node, int request, void * argp) {
	if (request == 1) {
		/* Disable */
		mouse_off();
		ps2_mouse_alternate = NULL;
		return 0;
	}
	if (request == 2) {
		/* Enable */
		ps2_mouse_alternate = vmware_mouse;
		mouse_on();
		mouse_absolute();
		return 0;
	}
	return -1;
}

static int init(void) {
	if (detect_device()) {

		mouse_pipe = make_pipe(sizeof(mouse_device_packet_t) * PACKETS_IN_PIPE);
		mouse_pipe->flags = FS_CHARDEVICE;

		vfs_mount("/dev/vmmouse", mouse_pipe);

		mouse_pipe->flags = FS_CHARDEVICE;
		mouse_pipe->ioctl = ioctl_mouse;

		/*
		 * We have a hack in the PS/2 mouse driver that lets us
		 * take over for the normal mouse driver and essential
		 * intercept the interrputs when they are valid.
		 */
		ps2_mouse_alternate = vmware_mouse;

		mouse_on();
		mouse_absolute();

	}

	return 0;
}

static int fini(void) {
	return 0;
}

MODULE_DEF(vmmware, init, fini);
MODULE_DEPENDS(ps2mouse); /* For ps2_mouse_alternate */
MODULE_DEPENDS(lfbvideo); /* For lfb resolution */