toaruos/modules/vmware.c

516 lines
12 KiB
C
Raw Normal View History

2018-03-16 15:56:19 +03:00
/* 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
2018-03-16 15:56:19 +03:00
*
2018-09-29 05:53:01 +03:00
* VMWare backdoor driver.
2018-03-16 15:56:19 +03:00
*
2018-09-29 05:53:01 +03:00
* Supports absolute mouse cursor and resolution setting.
2018-03-16 15:56:19 +03:00
*
2018-09-29 05:53:01 +03:00
* Mouse:
* Toggle off / on with ioctl 1 and 2 respectively to /dev/vmmouse.
* Supports mouse buttons, unlike the one in VirtualBox.
* This device is also available by default in QEMU.
2018-03-16 15:56:19 +03:00
*
2018-09-29 05:53:01 +03:00
* Resolution setting:
* Enabled when the "vmware" LFB driver is active. Automatically
* resizes the display when the window size changes.
2018-03-16 15:56:19 +03:00
*/
2018-03-19 05:38:11 +03:00
#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>
2018-03-16 15:56:19 +03:00
2018-09-29 05:44:08 +03:00
#define VMWARE_MAGIC 0x564D5868 /* hXMV */
2018-09-28 18:48:15 +03:00
#define VMWARE_PORT 0x5658
#define VMWARE_PORTHB 0x5659
2018-03-16 15:56:19 +03:00
#define PACKETS_IN_PIPE 1024
#define DISCARD_POINT 32
2018-09-29 05:44:08 +03:00
#define CMD_GETVERSION 10
#define CMD_MESSAGE 30
#define CMD_ABSPOINTER_DATA 39
#define CMD_ABSPOINTER_STATUS 40
#define CMD_ABSPOINTER_COMMAND 41
#define ABSPOINTER_ENABLE 0x45414552 /* Q E A E */
#define ABSPOINTER_RELATIVE 0xF5
#define ABSPOINTER_ABSOLUTE 0x53424152 /* R A B S */
#define MESSAGE_RPCI 0x49435052 /* R P C I */
#define MESSAGE_TCLO 0x4f4c4354 /* T C L O */
2018-03-16 15:56:19 +03:00
/* -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;
2018-09-29 05:44:08 +03:00
/** Low bandwidth backdoor */
2018-03-16 15:56:19 +03:00
static void vmware_send(vmware_cmd * cmd) {
cmd->magic = VMWARE_MAGIC;
cmd->port = VMWARE_PORT;
2018-09-29 05:44:08 +03:00
asm volatile("in %%dx, %0" : "+a"(cmd->ax), "+b"(cmd->bx), "+c"(cmd->cx), "+d"(cmd->dx), "+S"(cmd->si), "+D"(cmd->di));
2018-03-16 15:56:19 +03:00
}
2018-09-29 05:44:08 +03:00
/** Output to high bandwidth backdoor */
2018-09-28 18:48:15 +03:00
static void vmware_send_hb(vmware_cmd * cmd) {
cmd->magic = VMWARE_MAGIC;
cmd->port = VMWARE_PORTHB;
2018-09-29 05:44:08 +03:00
asm volatile("cld; rep; outsb" : "+a"(cmd->ax), "+b"(cmd->bx), "+c"(cmd->cx), "+d"(cmd->dx), "+S"(cmd->si), "+D"(cmd->di));
2018-09-28 18:48:15 +03:00
}
2018-09-29 05:44:08 +03:00
/** Input from high bandwidth backdoor */
2018-09-28 18:48:15 +03:00
static void vmware_get_hb(vmware_cmd * cmd) {
cmd->magic = VMWARE_MAGIC;
cmd->port = VMWARE_PORTHB;
2018-09-29 05:44:08 +03:00
asm volatile("cld; rep; insb" : "+a"(cmd->ax), "+b"(cmd->bx), "+c"(cmd->cx), "+d"(cmd->dx), "+S"(cmd->si), "+D"(cmd->di));
2018-03-16 15:56:19 +03:00
}
static void mouse_off(void) {
/* Disable the absolute mouse */
vmware_cmd cmd;
2018-09-29 05:44:08 +03:00
cmd.bx = ABSPOINTER_RELATIVE;
cmd.command = CMD_ABSPOINTER_COMMAND;
2018-03-16 15:56:19 +03:00
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;
2018-09-29 05:44:08 +03:00
/* Enable */
cmd.bx = ABSPOINTER_ENABLE;
cmd.command = CMD_ABSPOINTER_COMMAND;
vmware_send(&cmd);
/* Status */
cmd.bx = 0;
cmd.command = CMD_ABSPOINTER_STATUS;
vmware_send(&cmd);
/* Read data (1) */
cmd.bx = 1;
cmd.command = CMD_ABSPOINTER_DATA;
vmware_send(&cmd);
/* Enable absolute */
cmd.bx = ABSPOINTER_ABSOLUTE;
cmd.command = CMD_ABSPOINTER_COMMAND;
2018-03-16 15:56:19 +03:00
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;
2018-09-29 05:44:08 +03:00
cmd.command = CMD_ABSPOINTER_STATUS;
2018-03-16 15:56:19 +03:00
vmware_send(&cmd);
if (cmd.ax == 0xffff0000) {
/* Device error; turn it off and back on again. */
mouse_off();
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 */
2018-09-29 05:44:08 +03:00
cmd.command = CMD_ABSPOINTER_DATA; /* read */
2018-03-16 15:56:19 +03:00
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;
2018-03-16 15:56:19 +03:00
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;
2018-03-16 15:56:19 +03:00
}
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);
2018-03-16 15:56:19 +03:00
}
static int detect_device(void) {
vmware_cmd cmd;
/* read version */
cmd.bx = ~VMWARE_MAGIC;
2018-09-29 05:44:08 +03:00
cmd.command = CMD_GETVERSION;
2018-03-16 15:56:19 +03:00
vmware_send(&cmd);
if (cmd.bx != VMWARE_MAGIC || cmd.ax == 0xFFFFFFFF) {
/* Not a vmware device... */
return 0;
}
/* Good to go! */
return 1;
}
2018-09-28 18:48:15 +03:00
static int open_msg_channel(uint32_t proto) {
vmware_cmd cmd;
2018-09-29 05:44:08 +03:00
cmd.cx = CMD_MESSAGE | 0x00000000; /* CMD_MESSAGE */
2018-09-28 18:48:15 +03:00
cmd.bx = proto;
vmware_send(&cmd);
if ((cmd.cx & 0x10000) == 0) {
return -1;
2018-03-16 15:56:19 +03:00
}
2018-09-28 18:48:15 +03:00
return cmd.dx >> 16;
}
static void msg_close(int channel) {
vmware_cmd cmd = {0};
2018-09-29 05:44:08 +03:00
cmd.cx = CMD_MESSAGE | 0x00060000;
2018-09-28 18:48:15 +03:00
cmd.bx = 0;
cmd.dx = channel << 16;
vmware_send(&cmd);
}
static int open_rpci_channel(void) {
2018-09-29 05:44:08 +03:00
return open_msg_channel(MESSAGE_RPCI);
2018-09-28 18:48:15 +03:00
}
2018-09-29 05:44:08 +03:00
static int tclo_channel = -1;
2018-09-28 18:48:15 +03:00
static int open_tclo_channel(void) {
2018-09-29 05:44:08 +03:00
if (tclo_channel != -1) {
2018-09-28 18:48:15 +03:00
msg_close(tclo_channel);
}
2018-09-29 05:44:08 +03:00
tclo_channel = open_msg_channel(MESSAGE_TCLO);
2018-09-28 18:48:15 +03:00
return tclo_channel;
}
static int msg_send(int channel, char * msg, size_t size) {
{
vmware_cmd cmd = {0};
2018-09-29 05:44:08 +03:00
cmd.cx = CMD_MESSAGE | 0x00010000; /* CMD_MESSAGE size */
2018-09-28 18:48:15 +03:00
cmd.size = size;
cmd.dx = channel << 16;
vmware_send(&cmd);
if (size == 0) return 0;
if (((cmd.cx >> 16) & 0x0081) != 0x0081) {
return -2;
}
}
{
vmware_cmd cmd = {0};
cmd.bx = 0x0010000;
cmd.cx = size;
cmd.dx = channel << 16;
cmd.si = (uint32_t)msg;
vmware_send_hb(&cmd);
if (!(cmd.bx & 0x0010000)) {
return -3;
}
}
return 0;
}
static int msg_recv(int channel, char * buf, size_t bufsize) {
size_t size;
{
vmware_cmd cmd = {0};
2018-09-29 05:44:08 +03:00
cmd.cx = CMD_MESSAGE | 0x00030000; /* CMD_MESSAGE receive ize */
2018-09-28 18:48:15 +03:00
cmd.dx = channel << 16;
vmware_send(&cmd);
size = cmd.bx;
if (size == 0) return 0;
if (((cmd.cx >> 16) & 0x0083) != 0x0083) {
return -2;
}
if (size > bufsize) return -1;
}
{
vmware_cmd cmd = {0};
cmd.bx = 0x00010000;
cmd.cx = size;
cmd.dx = channel << 16;
cmd.di = (uint32_t)buf;
vmware_get_hb(&cmd);
if (!(cmd.bx & 0x00010000)) {
return -3;
}
}
{
vmware_cmd cmd = {0};
2018-09-29 05:44:08 +03:00
cmd.cx = CMD_MESSAGE | 0x00050000;
2018-09-28 18:48:15 +03:00
cmd.bx = 0x0001;
cmd.dx = channel << 16;
vmware_send(&cmd);
}
return size;
}
static int rpci_string(char * request) {
/* Open channel */
int channel = open_rpci_channel();
if (channel < 0) return channel;
size_t size = strlen(request) + 1;
msg_send(channel, request, size);
char buf[16];
int recv_size = msg_recv(channel, buf, 16);
msg_close(channel);
if (recv_size < 0) return recv_size;
return 0;
}
static int attempt_scale(void) {
int i;
int c = open_tclo_channel();
if (c < 0) {
return 1;
}
char buf[256];
if ((i = msg_send(c, buf, 0)) < 0) { return 1; }
int resend = 0;
while (1) {
i = msg_recv(c, buf, 256);
if (i < 0) {
return 1;
} else if (i == 0) {
if (resend) {
if ((i = rpci_string("tools.capability.resolution_set 1")) < 0) { return 1; }
if ((i = rpci_string("tools.capability.resolution_server toolbox 1")) < 0) { return 1; }
if ((i = rpci_string("tools.capability.display_topology_set 1")) < 0) { return 1; }
if ((i = rpci_string("tools.capability.color_depth_set 1")) < 0) { return 1; }
if ((i = rpci_string("tools.capability.resolution_min 0 0")) < 0) { return 1; }
if ((i = rpci_string("tools.capability.unity 1")) < 0) { return 1; }
resend = 0;
} else {
unsigned long s, ss;
relative_time(0, 10, &s, &ss);
sleep_until((process_t *)current_process, s, ss);
switch_task(0);
}
if ((i = msg_send(c, buf, 0)) < 0) { return 1; }
} else {
buf[i] = '\0';
if (startswith(buf, "reset")) {
if ((i = msg_send(c, "OK ATR toolbox", strlen("OK ATR toolbox"))) < 0) {
return 1;
}
} else if (startswith(buf, "ping")) {
if ((i = msg_send(c, "OK ", strlen("OK "))) < 0) {
return 1;
}
} else if (startswith(buf, "Capabilities_Register")) {
if ((i = msg_send(c, "OK ", strlen("OK "))) < 0) {
return 1;
}
resend = 1;
} else if (startswith(buf, "Resolution_Set")) {
char * x = &buf[15];
char * y = strstr(x," ");
if (!y) {
return 1;
}
*y = '\0';
y++;
int _x = atoi(x);
int _y = atoi(y);
if (lfb_resolution_x && _x && (_x != lfb_resolution_x || _y != lfb_resolution_y)) {
lfb_set_resolution(_x, _y);
}
if ((i = msg_send(c, "OK ", strlen("OK "))) < 0) {
return 1;
}
msg_close(c);
return 0;
} else {
if ((i = msg_send(c, "ERROR Unknown command", strlen("ERROR Unknown command"))) < 0) {
return 1;
}
}
}
}
}
static void vmware_resize(void * data, char * name) {
while (1) {
attempt_scale();
unsigned long s, ss;
relative_time(1, 0, &s, &ss);
sleep_until((process_t *)current_process, s, ss);
switch_task(0);
}
}
static int ioctl_mouse(fs_node_t * node, int request, void * argp) {
switch (request) {
case 1:
/* Disable */
mouse_off();
ps2_mouse_alternate = NULL;
return 0;
case 2:
/* Enable */
ps2_mouse_alternate = vmware_mouse;
mouse_absolute();
return 0;
default:
return -EINVAL;
2018-03-16 15:56:19 +03:00
}
}
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_absolute();
2018-09-28 18:48:15 +03:00
if (lfb_driver_name && !strcmp(lfb_driver_name, "vmware") && !args_present("novmwareresset")) {
create_kernel_tasklet(vmware_resize, "[vmware]", NULL);
}
2018-03-16 15:56:19 +03:00
}
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 */