diff options
Diffstat (limited to 'mousetsr.c')
| -rw-r--r-- | mousetsr.c | 1468 |
1 files changed, 1468 insertions, 0 deletions
diff --git a/mousetsr.c b/mousetsr.c new file mode 100644 index 0000000..fed2c9b --- /dev/null +++ b/mousetsr.c @@ -0,0 +1,1468 @@ +/* + * VBMouse - DOS mouse driver resident part + * Copyright (C) 2022 Javier S. Pedro + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdlib.h> +#include <string.h> +#include <i86.h> + +#include "dlog.h" +#include "ps2.h" +#include "int10vga.h" +#include "int16kbd.h" +#include "int2fwin.h" +#include "int33.h" +#include "vbox.h" +#include "vmware.h" +#include "mousetsr.h" + +#define MSB_MASK 0x8000U + +TSRDATA data; + +static const uint16_t default_cursor_graphic[] = { + 0x3FFF, 0x1FFF, 0x0FFF, 0x07FF, + 0x03FF, 0x01FF, 0x00FF, 0x007F, + 0x003F, 0x001F, 0x01FF, 0x00FF, + 0x30FF, 0xF87F, 0xF87F, 0xFCFF, + 0x0000, 0x4000, 0x6000, 0x7000, + 0x7800, 0x7C00, 0x7E00, 0x7F00, + 0x7F80, 0x7C00, 0x6C00, 0x4600, + 0x0600, 0x0300, 0x0300, 0x0000 +}; + +/** Constraint current mouse position to the user-set window. */ +static void bound_position_to_window(void) +{ + if (data.pos.x < data.min.x) data.pos.x = data.min.x; + if (data.pos.x > data.max.x) data.pos.x = data.max.x; + if (data.pos.y < data.min.y) data.pos.y = data.min.y; + if (data.pos.y > data.max.y) data.pos.y = data.max.y; +} + +/** Constraints coordinate value to the desired granularity, + * which must be a power of two. */ +static inline int16_t snap_to_grid(int16_t val, int16_t granularity) +{ + // Build a bitmask that masks away the undesired low-order bits + return val & (-granularity); +} + +static void hide_text_cursor(void) +{ + // Restore the character under the old position of the cursor + uint16_t __far *ch = get_video_char(&data.video_mode, + data.cursor_pos.x / 8, data.cursor_pos.y / 8); + *ch = data.cursor_prev_char; + data.cursor_visible = false; +} + +static void show_text_cursor(void) +{ + uint16_t __far *ch = get_video_char(&data.video_mode, + data.pos.x / 8, data.pos.y / 8); + data.cursor_prev_char = *ch; + data.cursor_pos = data.pos; + *ch = (*ch & data.cursor_text_and_mask) ^ data.cursor_text_xor_mask; + data.cursor_visible = true; +} + +/** Given the new position of the cursor, compute the both our source + * (i.e. the mouse cursor shape) and target clipping areas. + * @param cursor_pos cursor position + * @param start top left corner of clipping box in screen + * @param size size of the clipping box in screen as well as cursor shape + * @param offset top left corner of clipping box in mouse cursor shape */ +static bool get_graphic_cursor_area(struct point __far *cursor_pos, + struct point __far *start, + struct point __far *size, + struct point __far *offset) +{ + start->x = (cursor_pos->x / data.screen_scale.x) - data.cursor_hotspot.x; + start->y = (cursor_pos->y / data.screen_scale.y) - data.cursor_hotspot.y; + size->x = GRAPHIC_CURSOR_WIDTH; + size->y = GRAPHIC_CURSOR_HEIGHT; + offset->x = 0; + offset->y = 0; + + // Start clipping around + // Cursor is left/top of visible area + if (start->x <= -size->x) { + return false; + } else if (start->x < 0) { + offset->x += -start->x; + size->x -= -start->x; + start->x = 0; + } + if (start->y <= -size->y) { + return false; + } else if (start->y < 0) { + offset->y += -start->y; + size->y -= -start->y; + start->y = 0; + } + // Cursor is right/bottom of visible area + if (start->x > data.video_mode.pixels_width) { + return false; // Don't render cursor + } else if (start->x + size->x > data.video_mode.pixels_width) { + size->x -= (start->x + size->x) - data.video_mode.pixels_width; + } + if (start->y > data.video_mode.pixels_height) { + return false; + } else if (start->y + size->y > data.video_mode.pixels_height) { + size->y -= (start->y + size->y) - data.video_mode.pixels_height; + } + + return true; +} + +static inline uint8_t * get_prev_graphic_cursor_scanline(unsigned bytes_per_line, + unsigned num_lines, + unsigned plane, + unsigned y) +{ + return &data.cursor_prev_graphic[((plane * num_lines) + y) * bytes_per_line]; +} + +static inline uint16_t get_graphic_cursor_and_mask_line(unsigned y) +{ + return data.cursor_graphic[y]; +} + +static inline uint16_t get_graphic_cursor_xor_mask_line(unsigned y) +{ + return data.cursor_graphic[GRAPHIC_CURSOR_HEIGHT + y]; +} + +/** Compute the total number of bytes between start and end pixels, + * rounding up as necessary to cover all bytes. */ +static inline unsigned get_scanline_segment_bytes(unsigned bits_per_pixel, unsigned start, unsigned size) +{ + // Get starting byte (round down) + unsigned start_byte = (start * bits_per_pixel) / 8; + // Get end byte (round up) + unsigned end_byte = (((start + size) * bits_per_pixel) + (8-1)) / 8; + + return end_byte - start_byte; +} + +/** Creates a bitmask that extracts the topmost N bits of a byte. */ +static inline uint8_t build_pixel_mask(unsigned bits_per_pixel) +{ + if (bits_per_pixel == 1) return 0x80; + else if (bits_per_pixel == 2) return 0xC0; + else if (bits_per_pixel == 4) return 0xF0; + else return 0xFF; +} + +/** Hides the graphical mouse cursor, by restoring the contents of + * data.cursor_prev_graphic (i.e. what was below the cursor before we drew it) + * to video memory. */ +static void hide_graphic_cursor(void) +{ + struct modeinfo *info = &data.video_mode; + struct point start, size, offset; + unsigned cursor_bytes_per_line; + unsigned plane, y; + + // Compute the area where the cursor is currently positioned + if (!get_graphic_cursor_area(&data.cursor_pos, &start, &size, &offset)) { + return; + } + + // For each scanline, we will copy this amount of bytes + cursor_bytes_per_line = get_scanline_segment_bytes(info->bits_per_pixel, + start.x, size.x); + + for (plane = 0; plane < info->num_planes; plane++) { + if (info->num_planes > 1) vga_select_plane(plane); + + for (y = 0; y < size.y; y++) { + uint8_t __far *line = get_video_scanline(info, start.y + y) + + (start.x * info->bits_per_pixel) / 8; + uint8_t *prev = get_prev_graphic_cursor_scanline(cursor_bytes_per_line, size.y, + plane, y); + + // Restore this scaline from cursor_prev + _fmemcpy(line, prev, cursor_bytes_per_line); + } + } + + data.cursor_visible = false; +} + +/** Renders the graphical cursor. + * It will also backup whatever pixels are below + * the cursor area to cursor_prev_graphic. */ +static void show_graphic_cursor(void) +{ + const struct modeinfo *info = &data.video_mode; + struct point start, size, offset; + unsigned cursor_bytes_per_line; + const uint8_t msb_pixel_mask = build_pixel_mask(info->bits_per_pixel); + unsigned plane, y; + + // Compute the area where the cursor is supposed to be drawn + if (!get_graphic_cursor_area(&data.pos, &start, &size, &offset)) { + return; + } + + // For each scanline, we will copy this amount of bytes + cursor_bytes_per_line = get_scanline_segment_bytes(info->bits_per_pixel, + start.x, size.x); + + for (plane = 0; plane < info->num_planes; plane++) { + if (info->num_planes > 1) vga_select_plane(plane); + + for (y = 0; y < size.y; y++) { + uint8_t __far *line = get_video_scanline(info, start.y + y) + + (start.x * info->bits_per_pixel) / 8; + uint8_t *prev = get_prev_graphic_cursor_scanline(cursor_bytes_per_line, size.y, + plane, y); + uint16_t cursor_and_mask = get_graphic_cursor_and_mask_line(offset.y + y) + << offset.x; + uint16_t cursor_xor_mask = get_graphic_cursor_xor_mask_line(offset.y + y) + << offset.x; + unsigned x; + + // First, backup this scanline to prev before any changes + _fmemcpy(prev, line, cursor_bytes_per_line); + + if (info->bits_per_pixel < 8) { + uint8_t pixel_mask = msb_pixel_mask; + uint8_t pixel = *line; + + // when start.x is not pixel aligned, + // scaline points the previous multiple of pixels_per_byte; + // and the initial pixel will not be at the MSB of it. + // advance the pixel_mask accordingly + pixel_mask >>= (start.x * info->bits_per_pixel) % 8; + + for (x = 0; x < size.x; x++) { + // The MSBs of each mask correspond to the current pixel + if (!(cursor_and_mask & MSB_MASK)) { + pixel &= ~pixel_mask; + } + if (cursor_xor_mask & MSB_MASK) { + pixel ^= pixel_mask; + } + + // Advance to the next pixel + pixel_mask >>= info->bits_per_pixel; + if (!pixel_mask) { + // Time to advance to the next byte + *line = pixel; // Save current byte first + pixel = *(++line); + pixel_mask = msb_pixel_mask; + } + + // Advance to the next bit in the cursor mask + cursor_and_mask <<= 1; + cursor_xor_mask <<= 1; + } + + if (pixel_mask != msb_pixel_mask) { + // We ended up in the middle of a byte, save it + *line = pixel; + } + } else if (info->bits_per_pixel == 8) { + // Simplified version for byte-aligned pixels + for (x = 0; x < size.x; x++) { + uint8_t pixel = 0; + + if (cursor_and_mask & MSB_MASK) { + pixel = *line; + } + if (cursor_xor_mask & MSB_MASK) { + pixel ^= 0x0F; // Use 0x0F as "white pixel" + } + + // Advance to the next pixel + *line = pixel; + ++line; + + // Advance to the next bit in the cursor mask + cursor_and_mask <<= 1; + cursor_xor_mask <<= 1; + } + } + } + } + + data.cursor_pos = data.pos; + data.cursor_visible = true; +} + +/** Refreshes cursor position and visibility. */ +static void refresh_cursor(void) +{ + bool should_show = data.visible_count >= 0; + bool pos_changed, needs_refresh; + +#if USE_WIN386 + // Windows 386 is already rendering the cursor for us. + // Hide our own. + if (data.w386cursor) should_show = false; +#endif + +#if USE_VIRTUALBOX + if (data.vbavail && data.vbwantcursor) { + // We want to use the VirtualBox host cursor. + // See if we have to update its visibility. + int err = 0; + if (should_show != data.cursor_visible) { + err = vbox_set_pointer_visible(&data.vb, should_show); + if (err == 0 && data.vbhaveabs) { + data.cursor_visible = should_show; + } + } + if (err == 0 && data.vbhaveabs) { + // No need to refresh the cursor; VirtualBox is already showing it for us. + return; + } + } +#endif + + pos_changed = data.cursor_pos.x != data.pos.x || data.cursor_pos.y != data.pos.y; + needs_refresh = should_show && pos_changed || should_show != data.cursor_visible; + + if (!needs_refresh) { + // Nothing to do + return; + } + + if (data.video_mode.type == VIDEO_TEXT) { + // Text video mode + if (data.cursor_visible) { + // Hide the cursor at the old position if any + hide_text_cursor(); + } + if (should_show) { + // Show the cursor at the new position + show_text_cursor(); + } + } else if (data.video_mode.type != VIDEO_UNKNOWN) { + // Graphic video modes + + bool video_planar = data.video_mode.num_planes > 1; + struct videoregs regs; + // If current video mode is planar, + // we will have to play with the VGA registers + // so let's save and restore them. + if (video_planar) { + vga_save_registers(®s); + vga_set_graphics_mode(®s, 0, 0); + } + + if (data.cursor_visible) { + hide_graphic_cursor(); + } + if (should_show) { + show_graphic_cursor(); + } + + if (video_planar) { + vga_restore_register(®s); + } + } else { + // Unknown video mode, don't render cursor. + } +} + +/** Forcefully hides the mouse cursor if shown. */ +static void hide_cursor(void) +{ +#if USE_VIRTUALBOX + if (data.vbavail && data.vbwantcursor) { + vbox_set_pointer_visible(&data.vb, false); + if (data.vbhaveabs) { + data.cursor_visible = false; + } + } +#endif + + if (data.cursor_visible) { + if (data.video_mode.type == VIDEO_TEXT) { + hide_text_cursor(); + } else if (data.video_mode.type != VIDEO_UNKNOWN) { + hide_graphic_cursor(); + } + } +} + +/** Loads the current graphic cursor, + * which in this case means uploading it to the host. */ +static void load_cursor(void) +{ +#if USE_VIRTUALBOX + if (data.vbavail && data.vbwantcursor) { + VMMDevReqMousePointer *req = (VMMDevReqMousePointer *) data.vb.buf; + const unsigned width = GRAPHIC_CURSOR_WIDTH, height = GRAPHIC_CURSOR_HEIGHT; + uint8_t *output = req->pointerData; + unsigned int y, x; + + memset(req, 0, sizeof(VMMDevReqMousePointer)); + + req->header.size = vbox_req_mouse_pointer_size(width, height); + req->header.version = VMMDEV_REQUEST_HEADER_VERSION; + req->header.requestType = VMMDevReq_SetPointerShape; + req->header.rc = -1; + + req->fFlags = VBOX_MOUSE_POINTER_SHAPE; + req->xHot = BOUND(data.cursor_hotspot.x, 0, width); + req->yHot = BOUND(data.cursor_hotspot.y, 0, height); + req->width = width; + req->height = height; + + // AND mask + // int33 format is 1-bit per pixel packed into 16-bit LE values, + // while VirtualBox wants 1-bit per pixel packed into 8-bit. + // All we have to do is byteswap 16-bit values. + for (y = 0; y < height; ++y) { + uint16_t cursor_line = get_graphic_cursor_and_mask_line(y); + output[0] = (cursor_line >> 8) & 0xFF; + output[1] = cursor_line & 0xFF; + output += GRAPHIC_CURSOR_SCANLINE_LEN; + } + + // XOR mask + // int33 format is again 1-bit per pixel packed into 16-bit LE values, + // however VirtualBox wants 4-byte per pixel packed "RGBA". + for (y = 0; y < height; ++y) { + uint16_t cursor_line = get_graphic_cursor_xor_mask_line(y); + + for (x = 0; x < width; ++x) { + // MSB of line is current mask bit, we shift it on each iteration + uint8_t val = (cursor_line & MSB_MASK) ? 0xFF : 0; + + output[0] = val; + output[1] = val; + output[2] = val; + output[3] = 0; + + cursor_line <<= 1; + output += 4; + } + } + + dlog_puts("Loading cursor to VBox"); + + vbox_send_request(data.vb.iobase, data.vb.dds.physicalAddress); + + if (req->header.rc != 0) { + dlog_puts("Could not send cursor to VirtualBox"); + return; + } + + // After we send this message, it looks like VirtualBox shows the cursor + // even if we didn't actually want it to be visible at this point. + vbox_set_pointer_visible(&data.vb, false); + } +#endif +} + +/** Reloads the information about the current video mode. */ +static void reload_video_info(void) +{ + get_current_video_mode_info(&data.video_mode); + + data.screen_max.x = data.video_mode.pixels_width - 1; + data.screen_max.y = data.video_mode.pixels_height - 1; + data.screen_scale.x = 1; + data.screen_scale.y = 1; + data.screen_granularity.x = 1; + data.screen_granularity.y = 1; + + // The actual range of coordinates expected by int33 clients + // is, for some reason, different than real resolution in some modes. + // For example, 320x... modes are mapped to 640x... pixels. + if (data.video_mode.pixels_width == 320) { + data.screen_max.x = 640 - 1; + data.screen_scale.x = 640 / 320; + } + + // In text modes, we are supposed to always round the mouse cursor + // to character boundaries. + if (data.video_mode.type == VIDEO_TEXT) { + // Always assume 8x8 character size irregardless of true font + data.screen_granularity.x = 8; + data.screen_granularity.y = 8; + } + + dlog_print("Current video mode="); + dlog_printx(data.video_mode.mode); + dlog_print(" screen_max="); + dlog_printd(data.screen_max.x); + dlog_putc(','); + dlog_printd(data.screen_max.y); + dlog_endline(); +} + +/** True if the current video is different from what we have stored + * and we probably need to recompute video mode info. */ +static inline bool video_mode_changed(void) +{ + uint8_t cur_mode = bda_get_video_mode() & ~0x80; + + if (cur_mode != data.video_mode.mode) + return true; + + if (data.video_mode.type == VIDEO_TEXT) { + // Also check to see if the font size was changed.. + return data.video_mode.pixels_height != (bda_get_last_row()+1) * 8; + } else { + return false; + } +} + +/** Checks if the video mode has changed and if so + * refreshes the information about the current video mode. */ +static void refresh_video_info(void) +{ + if (video_mode_changed()) { + if (data.cursor_visible) { + // Assume cursor is lost with no way to restore prev contents + data.cursor_visible = false; + } + + reload_video_info(); + + if (data.video_mode.type != VIDEO_UNKNOWN) { + // If we know the screen size for this mode, then reset the window to it + data.min.x = 0; + data.min.y = 0; + data.max.x = data.screen_max.x; + data.max.y = data.screen_max.y; + } + } +} + +/** Calls the application-registered event handler. */ +static void call_event_handler(void (__far *handler)(), uint16_t events, + uint16_t buttons, int16_t x, int16_t y, + int16_t delta_x, int16_t delta_y) +{ +#if TRACE_EVENTS + dlog_print("calling event handler events="); + dlog_printx(events); + dlog_print(" buttons="); + dlog_printx(buttons); + dlog_print(" x="); + dlog_printd(x); + dlog_print(" y="); + dlog_printd(y); + dlog_print(" dx="); + dlog_printd(delta_x); + dlog_print(" dy="); + dlog_printd(delta_y); + dlog_endline(); +#endif + + __asm { + mov ax, [events] + mov bx, [buttons] + mov cx, [x] + mov dx, [y] + mov si, [delta_x] + mov di, [delta_y] + + call dword ptr [handler] + } +} + +/** Process a mouse event internally. + * @param buttons currently pressed buttons as a bitfield + * @param absolute whether mouse coordinates are an absolute value + * @param x y if absolute, then absolute coordinates in screen pixels + * if relative, then relative coordinates in mickeys + * @param z relative wheel mouse movement + */ +static void handle_mouse_event(uint16_t buttons, bool absolute, int x, int y, int z) +{ + uint16_t events = 0; + int i; + +#if TRACE_EVENTS + dlog_print("handle mouse event"); + if (absolute) dlog_print(" absolute"); + dlog_print(" buttons="); + dlog_printx(buttons); + dlog_print(" x="); + dlog_printd(x); + dlog_print(" y="); + dlog_printd(y); + dlog_print(" z="); + dlog_printd(z); + dlog_endline(); +#endif + + if (absolute) { + // Absolute movement: x,y are in screen pixels units + events |= INT33_EVENT_MASK_ABSOLUTE; + + if (x != data.pos.x || y != data.pos.y) { + events |= INT33_EVENT_MASK_MOVEMENT; + + // Simulate a fake relative movement in mickeys + // This is almost certainly broken. + // Programs that expect relative movement data + // will almost never set a mickeyPerPixel value. + // So all we can do is guess. + if (data.abs_pos.x >= 0 && data.abs_pos.y >= 0) { + data.delta.x += (x - data.abs_pos.x) * 8; + data.delta.y += (y - data.abs_pos.y) * 8; + } + data.abs_pos.x = x; + data.abs_pos.y = y; + + // Set the new absolute position + data.pos.x = x; + data.pos.y = y; + data.pos_frac.x = 0; + data.pos_frac.y = 0; + } + } else if (x || y) { + // Relative movement: x,y are in mickeys + uint16_t ticks = bda_get_tick_count_lo(); + unsigned ax = abs(x), ay = abs(y); + + events |= INT33_EVENT_MASK_MOVEMENT; + + // Check if around one second has passed + if ((ticks - data.last_ticks) >= 18) { + data.total_motion = 0; + data.last_ticks = ticks; + } + + // If more than the double speed threshold has been moved in the last second, + // double the speed + data.total_motion += ax * ax + ay * ay; + if (data.total_motion > data.doubleSpeedThreshold * data.doubleSpeedThreshold) { + x *= 2; + y *= 2; + } + + data.delta.x += x; + data.delta.y += y; + data.delta_frac.x = 0; + data.delta_frac.y = 0; + data.abs_pos.x = -1; + data.abs_pos.y = -1; + + // Convert mickeys into pixels + data.pos.x += scalei_rem(x, data.mickeysPerLine.x, 8, &data.pos_frac.x); + data.pos.y += scalei_rem(y, data.mickeysPerLine.y, 8, &data.pos_frac.y); + } + + bound_position_to_window(); + +#if USE_WHEEL + if (data.haswheel && z) { + if (!data.usewheelapi && (data.wheel_up_key || data.wheel_down_key)) { + // Emulate keystrokes on wheel movement + if (z < 0 && data.wheel_up_key) { + for (; z < 0; z++) { + int16_store_keystroke(data.wheel_up_key); + } + } else if (z > 0 && data.wheel_up_key) { + for (; z > 0; z--) { + int16_store_keystroke(data.wheel_down_key); + } + } + } else { + events |= INT33_EVENT_MASK_WHEEL_MOVEMENT; + // Higher byte of buttons contains wheel movement + buttons |= (z & 0xFF) << 8; + // Accumulate delta wheel movement + data.wheel_delta += z; + data.wheel_last.x = data.pos.x; + data.wheel_last.y = data.pos.y; + } + } +#endif + + // Update button status + for (i = 0; i < NUM_BUTTONS; ++i) { + uint8_t btn = 1 << i; + uint8_t evt = 0; + if ((buttons & btn) && !(data.buttons & btn)) { + // Button pressed + evt = 1 << (1 + (i * 2)); // Press event mask + data.button[i].pressed.count++; + data.button[i].pressed.last.x = data.pos.x; + data.button[i].pressed.last.y = data.pos.y; + } else if (!(buttons & btn) && (data.buttons & btn)) { + // Button released + evt = 1 << (2 + (i * 2)); // Release event mask + data.button[i].released.count++; + data.button[i].released.last.x = data.pos.x; + data.button[i].released.last.y = data.pos.y; + } + events |= evt; + } + data.buttons = buttons; + + refresh_cursor(); + + events &= data.event_mask; + if (data.event_handler && events) { + x = snap_to_grid(data.pos.x, data.screen_granularity.x); + y = snap_to_grid(data.pos.y, data.screen_granularity.y); + + call_event_handler(data.event_handler, events, + buttons, x, y, data.delta.x, data.delta.y); + } +} + +/** PS/2 BIOS calls this routine to notify mouse events. */ +static void ps2_mouse_handler(uint16_t word1, uint16_t word2, uint16_t word3, uint16_t word4) +{ +#pragma aux ps2_mouse_handler "*" parm caller [ax] [bx] [cx] [dx] modify [ax bx cx dx si di es fs gs] + + unsigned status; + int x, y, z; + bool abs = false; + +#if TRACE_EVENTS + dlog_print("ps2 callback "); + dlog_printx(word1); + dlog_putc(' '); + dlog_printx(word2); + dlog_putc(' '); + dlog_printx(word3); + dlog_putc(' '); + dlog_printx(word4); + dlog_endline(); +#endif /* TRACE_EVENTS */ + + // Decode the PS2 event args + // In a normal IBM PS/2 BIOS (incl. VirtualBox/Bochs/qemu/SeaBIOS): + // word1 low byte = status (following PS2M_STATUS_*) + // word2 low byte = x + // word3 low byte = y + // word4 = always zero + // In a PS/2 BIOS with wheel support (incl. VMware/DOSBox-X): + // taken from CuteMouse/KoKo: + // word1 high byte = x + // word1 low byte = status + // word2 low byte = y + // word3 low byte = z + // word4 = always zero + // VirtualBox/Bochs/qemu/SeaBIOS behave like a normal one, + // but they also store the raw contents of all mouse packets in the EBDA (starting 0x28 = packet 0). + // Other BIOSes don't do that so it is not a reliable option either. + // So, how to detect which BIOS we have? + // For now we are always assuming "normal" PS/2 BIOS. + // But with VirtualBox integration on we'll get the wheel packet from the EBDA, + // and with VMWare integration on we'll get it from the VMware protocol. + status = (uint8_t) word1; + x = (uint8_t) word2; + y = (uint8_t) word3; + z = 0; + (void) word4; + + // Sign-extend X, Y as per the status byte + x = status & PS2M_STATUS_X_NEG ? 0xFF00 | x : x; + y = -(status & PS2M_STATUS_Y_NEG ? 0xFF00 | y : y); + +#if USE_VIRTUALBOX + if (data.vbavail) { + uint16_t vbx, vby; + if ((vbox_get_mouse(&data.vb, &abs, &vbx, &vby) == 0) && abs) { + // VirtualBox gives unsigned coordinates from 0...0xFFFFU, + // scale to 0..screen_size (in pixels). + refresh_video_info(); + // If the user is using a window larger than the screen, use it. + x = scaleu(vbx, 0xFFFFU, MAX(data.max.x, data.screen_max.x)); + y = scaleu(vby, 0xFFFFU, MAX(data.max.y, data.screen_max.y)); + data.vbhaveabs = true; + } else { + // VirtualBox does not support absolute coordinates, + // or user has disabled them. + data.vbhaveabs = false; + // Rely on PS/2 relative coordinates. + } + +#if USE_WHEEL + // VirtualBox/Bochs BIOS does not pass wheel data to the callback, + // so we will fetch it directly from the BIOS data segment. + if (data.haswheel) { + int8_t __far * mouse_packet = MK_FP(bda_get_ebda_segment(), 0x28); + z = mouse_packet[3]; + } +#endif + } +#endif /* USE_VIRTUALBOX */ + +#if USE_VMWARE + if (data.vmwavail) { + uint32_t vmwstatus = vmware_abspointer_status(); + uint16_t data_avail = vmwstatus & VMWARE_ABSPOINTER_STATUS_MASK_DATA; + +#if TRACE_EVENTS + dlog_print("vmware status=0x"); + dlog_printx(vmwstatus >> 16); + dlog_print(" "); + dlog_printx(vmwstatus & 0xFFFF); + dlog_endline(); +#endif + + if (data_avail >= VMWARE_ABSPOINTER_DATA_PACKET_SIZE) { + struct vmware_abspointer_data vmw; + vmware_abspointer_data(VMWARE_ABSPOINTER_DATA_PACKET_SIZE, &vmw); + +#if TRACE_EVENTS + dlog_print("vmware pstatus=0x"); + dlog_printx(status); + dlog_print(" x=0x"); + dlog_printx(vmw.x); + dlog_print(" z="); + dlog_printd((int8_t) (uint8_t) vmw.z); + dlog_endline(); +#endif + + if (vmw.status & VMWARE_ABSPOINTER_STATUS_RELATIVE) { + x = (int16_t) vmw.x; + y = (int16_t) vmw.y; + z = (int8_t) (uint8_t) vmw.z; + } else { + abs = true; + // Scale to screen coordinates + refresh_video_info(); + x = scaleu(vmw.x & 0xFFFFU, 0xFFFFU, + MAX(data.max.x, data.screen_max.x)); + y = scaleu(vmw.y & 0xFFFFU, 0xFFFFU, + MAX(data.max.y, data.screen_max.y)); + z = (int8_t) (uint8_t) vmw.z; + } + + if (vmw.status & VMWARE_ABSPOINTER_STATUS_BUTTON_LEFT) { + status |= PS2M_STATUS_BUTTON_1; + } + if (vmw.status & VMWARE_ABSPOINTER_STATUS_BUTTON_RIGHT) { + status |= PS2M_STATUS_BUTTON_2; + } + if (vmw.status & VMWARE_ABSPOINTER_STATUS_BUTTON_MIDDLE) { + status |= PS2M_STATUS_BUTTON_3; + } + } else { + return; // Ignore the PS/2 packet otherwise, it is likely garbage + } + } +#endif /* USE_VMWARE */ + + handle_mouse_event(status & (PS2M_STATUS_BUTTON_1 | PS2M_STATUS_BUTTON_2 | PS2M_STATUS_BUTTON_3), + abs, x, y, z); +} + +void __declspec(naked) __far ps2_mouse_callback() +{ + __asm { + pusha + push ds + push es + push fs + push gs + + ; 8 + 4 saved registers, 24 bytes + ; plus 4 bytes for retf address + ; = 28 bytes of stack before callback args + + mov bp, sp + push cs + pop ds + + mov ax,[bp+28+6] ; Status + mov bx,[bp+28+4] ; X + mov cx,[bp+28+2] ; Y + mov dx,[bp+28+0] ; Z + + call ps2_mouse_handler + + pop gs + pop fs + pop es + pop ds + popa + + retf + } +} + +#if USE_INTEGRATION +static void set_absolute(bool enable) +{ +#if USE_VIRTUALBOX + data.vbhaveabs = false; + if (data.vbavail) { + int err = vbox_set_mouse(&data.vb, enable, false); + if (enable && !err) { + dlog_puts("VBox absolute mouse enabled"); + data.vbhaveabs = true; + } else if (!enable) { + dlog_puts("VBox absolute mouse disabled"); + } + } +#endif /* USE_VIRTUALBOX */ +#if USE_VMWARE + if (data.vmwavail) { + if (enable) { + uint16_t data_avail; + // It looks like a reset of the PS/2 mouse completely disables + // the vmware interface, so we have to reenable it from scratch. + vmware_abspointer_cmd(VMWARE_ABSPOINTER_CMD_ENABLE); + vmware_abspointer_data_clear(); + vmware_abspointer_cmd(VMWARE_ABSPOINTER_CMD_REQUEST_ABSOLUTE); + + dlog_puts("VMware absolute mouse enabled"); + } else { + vmware_abspointer_cmd(VMWARE_ABSPOINTER_CMD_REQUEST_RELATIVE); + vmware_abspointer_cmd(VMWARE_ABSPOINTER_CMD_DISABLE); + + dlog_puts("VMware absolute mouse disabled"); + } + } +#endif /* USE_VMWARE */ +} +#endif /* USE_INTEGRATION */ + +static void reset_mouse_hardware() +{ + ps2m_enable(false); + +#if USE_WHEEL + if (data.usewheel && ps2m_detect_wheel()) { + // Detect wheel also reinitializes the mouse to the proper packet size + data.haswheel = true; + } else { + // Otherwise do an extra reset to return back to initial state, just in case + data.haswheel = false; + ps2m_init(PS2M_PACKET_SIZE_PLAIN); + } +#else + ps2m_init(PS2M_PACKET_SIZE_PLAIN); +#endif + + ps2m_set_resolution(3); // 3 = 200 dpi, 8 counts per millimeter + ps2m_set_sample_rate(4); // 4 = 80 reports per second + ps2m_set_scaling_factor(1); // 1 = 1:1 scaling + + ps2m_set_callback(get_cs():>ps2_mouse_callback); + +#if USE_INTEGRATION + // By default, enable absolute mouse + set_absolute(true); + // Reload hardware cursor + load_cursor(); +#endif + + ps2m_enable(true); +} + +/** Reset "software" mouse settings, i.e. those configurable by the client program. */ +static void reset_mouse_settings() +{ + data.event_mask = 0; + data.event_handler = 0; + + data.mickeysPerLine.x = 8; + data.mickeysPerLine.y = 16; + data.doubleSpeedThreshold = 64; + data.min.x = 0; + data.max.x = data.screen_max.x; + data.min.y = 0; + data.max.y = data.screen_max.y; + data.visible_count = -1; + data.cursor_text_type = 0; + data.cursor_text_and_mask = 0xFFFFU; + data.cursor_text_xor_mask = 0x7700U; + data.cursor_hotspot.x = 0; + data.cursor_hotspot.y = 0; + memcpy(data.cursor_graphic, default_cursor_graphic, sizeof(data.cursor_graphic)); + +#if USE_WHEEL + data.usewheelapi = false; +#endif + + refresh_cursor(); // This will hide the cursor and update data.cursor_visible +} + +/** Reset the current mouse state and throw away past events. */ +static void reset_mouse_state() +{ + int i; + data.pos.x = data.min.x; + data.pos.y = data.min.y; + data.pos_frac.x = 0; + data.pos_frac.y = 0; + data.delta.x = 0; + data.delta.y = 0; + data.delta_frac.x = 0; + data.delta_frac.y = 0; + data.abs_pos.x = -1; + data.abs_pos.y = -1; + data.buttons = 0; + for (i = 0; i < NUM_BUTTONS; i++) { + data.button[i].pressed.count = 0; + data.button[i].pressed.last.x = 0; + data.button[i].pressed.last.y = 0; + data.button[i].released.count = 0; + data.button[i].released.last.x = 0; + data.button[i].released.last.y = 0; + } + data.wheel_delta = 0; + data.cursor_visible = false; + data.cursor_pos.x = 0; + data.cursor_pos.y = 0; + data.cursor_prev_char = 0; + memset(data.cursor_prev_graphic, 0, sizeof(data.cursor_prev_graphic)); +} + +static void return_clear_wheel_counter(union INTPACK __far *r) +{ + r->x.cx = snap_to_grid(data.wheel_last.x, data.screen_granularity.x); + r->x.dx = snap_to_grid(data.wheel_last.y, data.screen_granularity.y); + r->x.bx = data.wheel_delta; + data.wheel_last.x = 0; + data.wheel_last.y = 0; + data.wheel_delta = 0; +} + +static void return_clear_button_counter(union INTPACK __far *r, struct buttoncounter *c) +{ + r->x.cx = snap_to_grid(c->last.x, data.screen_granularity.x); + r->x.dx = snap_to_grid(c->last.y, data.screen_granularity.y); + r->x.bx = c->count; + c->last.x = 0; + c->last.y = 0; + c->count = 0; +} + +/** Entry point for our int33 API. */ +static void int33_handler(union INTPACK r) +#pragma aux int33_handler "*" parm caller [] modify [ax bx cx dx si di es fs gs] +{ + switch (r.x.ax) { + case INT33_RESET_MOUSE: + dlog_puts("Mouse reset"); + reload_video_info(); + reset_mouse_settings(); + reset_mouse_hardware(); + reset_mouse_state(); + r.x.ax = INT33_MOUSE_FOUND; + r.x.bx = NUM_BUTTONS; + break; + case INT33_SHOW_CURSOR: + data.visible_count++; + refresh_cursor(); + break; + case INT33_HIDE_CURSOR: + data.visible_count--; + refresh_cursor(); + break; + case INT33_GET_MOUSE_POSITION: +#if TRACE_EVENTS + dlog_puts("Mouse get position"); +#endif + r.x.cx = snap_to_grid(data.pos.x, data.screen_granularity.x); + r.x.dx = snap_to_grid(data.pos.y, data.screen_granularity.y); + r.x.bx = data.buttons; +#if USE_WHEEL + if (data.haswheel) { + r.h.bh = data.wheel_delta; + data.wheel_delta = 0; + } +#endif + break; + case INT33_SET_MOUSE_POSITION: +#if TRACE_EVENTS + dlog_puts("Mouse set position"); +#endif + data.pos.x = r.x.cx; + data.pos.y = r.x.dx; + data.pos_frac.x = 0; + data.pos_frac.y = 0; + data.delta.x = 0; + data.delta.y = 0; + data.delta_frac.x = 0; + data.delta_frac.y = 0; + bound_position_to_window(); + break; + case INT33_GET_BUTTON_PRESSED_COUNTER: + r.x.ax = data.buttons; +#if USE_WHEEL + if (data.haswheel) { + r.h.bh = data.wheel_delta; + if (r.x.bx == -1) { + // Asked for wheel information + return_clear_wheel_counter(&r); + break; + } + } +#endif + // Regular button information + return_clear_button_counter(&r, + &data.button[MIN(r.x.bx, NUM_BUTTONS - 1)].pressed); + break; + case INT33_GET_BUTTON_RELEASED_COUNTER: + r.x.ax = data.buttons; +#if USE_WHEEL + if (data.haswheel) { + r.h.bh = data.wheel_delta; + if (r.x.bx == -1) { + // Asked for wheel information + return_clear_wheel_counter(&r); + break; + } + } +#endif + return_clear_button_counter(&r, + &data.button[MIN(r.x.bx, NUM_BUTTONS - 1)].released); + break; + case INT33_SET_HORIZONTAL_WINDOW: + dlog_print("Mouse set horizontal window ["); + dlog_printd(r.x.cx); + dlog_putc(','); + dlog_printd(r.x.dx); + dlog_puts("]"); + // Recheck in case someone changed the video mode + refresh_video_info(); + data.min.x = r.x.cx; + data.max.x = r.x.dx; + bound_position_to_window(); + break; + case INT33_SET_VERTICAL_WINDOW: + dlog_print("Mouse set vertical window ["); + dlog_printd(r.x.cx); + dlog_putc(','); + dlog_printd(r.x.dx); + dlog_puts("]"); + refresh_video_info(); + data.min.y = r.x.cx; + data.max.y = r.x.dx; + bound_position_to_window(); + break; + case INT33_SET_GRAPHICS_CURSOR: + dlog_puts("Mouse set graphics cursor"); + hide_cursor(); + data.cursor_hotspot.x = r.x.bx; + data.cursor_hotspot.y = r.x.cx; + _fmemcpy(data.cursor_graphic, MK_FP(r.x.es, r.x.dx), sizeof(data.cursor_graphic)); + load_cursor(); + refresh_cursor(); + break; + case INT33_SET_TEXT_CURSOR: + dlog_print("Mouse set text cursor "); + dlog_printd(r.x.bx); + dlog_endline(); + hide_cursor(); + data.cursor_text_type = r.x.bx; + data.cursor_text_and_mask = r.x.cx; + data.cursor_text_xor_mask = r.x.dx; + refresh_cursor(); + break; + case INT33_GET_MOUSE_MOTION: +#if TRACE_EVENTS + dlog_puts("Mouse get motion"); +#endif + r.x.cx = data.delta.x; + r.x.dx = data.delta.y; + data.delta.x = 0; + data.delta.y = 0; + break; + case INT33_SET_EVENT_HANDLER: + dlog_puts("Mouse set event handler"); + data.event_mask = r.x.cx; + data.event_handler = MK_FP(r.x.es, r.x.dx); + break; + case INT33_SET_MOUSE_SPEED: + dlog_print("Mouse set speed x="); + dlog_printd(r.x.cx); + dlog_print(" y="); + dlog_printd(r.x.dx); + dlog_endline(); + data.mickeysPerLine.x = r.x.cx; + data.mickeysPerLine.y = r.x.dx; + break; + case INT33_SET_SPEED_DOUBLE_THRESHOLD: + dlog_print("Mouse set speed double threshold="); + dlog_printd(r.x.dx); + dlog_endline(); + data.doubleSpeedThreshold = r.x.dx; + break; + case INT33_EXCHANGE_EVENT_HANDLER: + dlog_puts("Mouse exchange event handler"); + data.event_mask = r.x.cx; + { + void (__far *prev_event_handler)() = data.event_handler; + data.event_handler = MK_FP(r.x.es, r.x.dx); + r.x.es = FP_SEG(prev_event_handler); + r.x.dx = FP_OFF(prev_event_handler); + } + break; + case INT33_GET_MOUSE_STATUS_SIZE: + dlog_puts("Mouse get status size"); + r.x.bx = sizeof(TSRDATA); + break; + case INT33_SAVE_MOUSE_STATUS: + dlog_puts("Mouse save status"); + _fmemcpy(MK_FP(r.x.es, r.x.dx), &data, sizeof(TSRDATA)); + break; + case INT33_LOAD_MOUSE_STATUS: + dlog_puts("Mouse load status"); + _fmemcpy(&data, MK_FP(r.x.es, r.x.dx), sizeof(TSRDATA)); + break; + case INT33_SET_MOUSE_SENSITIVITY: + dlog_print("Mouse set speed x="); + dlog_printd(r.x.bx); + dlog_print(" y="); + dlog_printd(r.x.cx); + dlog_print(" threshold="); + dlog_printd(r.x.dx); + dlog_endline(); + data.mickeysPerLine.x = r.x.bx; + data.mickeysPerLine.y = r.x.cx; + data.doubleSpeedThreshold = r.x.dx; + break; + case INT33_GET_MOUSE_SENSITIVITY: + r.x.bx = data.mickeysPerLine.x; + r.x.cx = data.mickeysPerLine.y; + r.x.dx = data.doubleSpeedThreshold; + break; + case INT33_RESET_SETTINGS: + dlog_puts("Mouse reset settings"); + reload_video_info(); + reset_mouse_settings(); + reset_mouse_state(); + r.x.ax = INT33_MOUSE_FOUND; + r.x.bx = NUM_BUTTONS; + break; + case INT33_GET_LANGUAGE: + r.x.bx = 0; + break; + case INT33_GET_DRIVER_INFO: + dlog_puts("Mouse get driver info"); + r.h.bh = REPORTED_VERSION_MAJOR; + r.h.bl = REPORTED_VERSION_MINOR; + r.h.ch = INT33_MOUSE_TYPE_PS2; + r.h.cl = 0; + break; + case INT33_GET_MAX_COORDINATES: + r.x.bx = 0; + r.x.cx = MAX(data.screen_max.x, data.max.x); + r.x.dx = MAX(data.screen_max.y, data.max.y); + break; + case INT33_GET_WINDOW: + r.x.ax = data.min.x; + r.x.bx = data.min.y; + r.x.cx = data.max.x; + r.x.dx = data.max.y; + break; +#if USE_WHEEL + // Wheel API extensions: + case INT33_GET_CAPABILITIES: + dlog_puts("Mouse get capabitilies"); + r.x.ax = INT33_WHEEL_API_MAGIC; // Driver supports wheel API + r.x.bx = 0; + r.x.cx = data.haswheel ? INT33_CAPABILITY_MOUSE_API : 0; + data.usewheelapi = true; // Someone calling this function likely wants to use wheel API + break; +#endif + // Our internal API extensions: + case INT33_GET_TSR_DATA: + dlog_puts("Get TSR data"); + r.x.es = FP_SEG(&data); + r.x.di = FP_OFF(&data); + break; + default: + dlog_print("Unknown mouse function ax="); + dlog_printx(r.x.ax); + dlog_endline(); + break; + } +} + +// Can't use __interrupt, it makes a call to GETDS on the runtime +void __declspec(naked) __far int33_isr(void) +{ + __asm { + pusha + push ds + push es + push fs + push gs + + mov bp, sp + push cs + pop ds + + call int33_handler + + pop gs + pop fs + pop es + pop ds + popa + iret + } +} + +#if USE_WIN386 +/** Windows will call this function to notify events when we are inside a DOS box. */ +static void windows_mouse_handler(int action, int x, int y, int buttons, int events) +#pragma aux windows_mouse_handler "*" parm [ax] [bx] [cx] [dx] [si] modify [ax bx cx dx es] +{ + switch (action) { + case VMD_ACTION_MOUSE_EVENT: + (void) events; + // Forward event to our internal system + handle_mouse_event(buttons, true, x, y, 0); + break; + case VMD_ACTION_HIDE_CURSOR: + dlog_puts("VMD_ACTION_HIDE_CURSOR"); + data.w386cursor = true; + refresh_cursor(); + break; + case VMD_ACTION_SHOW_CURSOR: + dlog_puts("VMD_ACTION_SHOW_CURSOR"); + data.w386cursor = false; + refresh_cursor(); + break; + } +} + +void __declspec(naked) __far windows_mouse_callback() +{ + __asm { + pusha + push ds + push es + push fs + push gs + + mov bp, sp + push cs + pop ds + + call windows_mouse_handler + + pop gs + pop fs + pop es + pop ds + popa + + retf + } +} + +static void int2f_handler(union INTPACK r) +#pragma aux int2f_handler "*" parm caller [] modify [ax bx cx dx es] +{ + switch (r.x.ax) { + case INT2F_NOTIFY_WIN386_STARTUP: + dlog_print("Windows is starting, version="); + dlog_printx(r.x.di); + dlog_endline(); + data.w386_startup.version = 3; + data.w386_startup.next = MK_FP(r.x.es, r.x.bx); + data.w386_startup.device_driver = 0; + data.w386_startup.device_driver_data = 0; + data.w386_startup.instance_data = &data.w386_instance; + data.w386_instance[0].ptr = &data; + data.w386_instance[0].size = sizeof(data); + data.w386_instance[1].ptr = 0; + data.w386_instance[1].size = 0; + r.x.es = FP_SEG(&data.w386_startup); + r.x.bx = FP_OFF(&data.w386_startup); + break; + case INT2F_NOTIFY_DEVICE_CALLOUT: + switch (r.x.bx) { + case VMD_DEVICE_ID: + switch (r.x.cx) { + case VMD_CALLOUT_TEST: + r.x.cx = 1; // Yes, we are here! + break; + case VMD_CALLOUT_GET_DOS_MOUSE_API: + // Windows is asking our mouse driver for the hook function address + r.x.ds = get_cs(); + r.x.si = FP_OFF(windows_mouse_callback); + r.x.ax = 0; // Yes, we are here! + break; + } + break; + } + break; + } +} + +void __declspec(naked) __far int2f_isr(void) +{ + __asm { + pusha + push ds + push es + push fs + push gs + + mov bp, sp + push cs + pop ds + + call int2f_handler + + pop gs + pop fs + pop es + pop ds + popa + + ; Jump to the next handler in the chain + jmp dword ptr cs:[data + 4] ; wasm doesn't support structs, this is data.prev_int2f_handler + } +} +#endif + +static LPTSRDATA int33_get_tsr_data(void); +#pragma aux int33_get_tsr_data = \ + "xor ax, ax" \ + "mov es, ax" \ + "mov di, ax" \ + "mov ax, 0x73" \ + "int 0x33" \ + __value [es di] \ + __modify [ax] + +static LPTSRDATA local_get_tsr_data(void); +#pragma aux local_get_tsr_data = \ + "mov ax, cs" \ + "mov es, ax" \ + "mov di, offset data" \ + __value [es di] \ + __modify [ax] + +LPTSRDATA __far get_tsr_data(bool installed) +{ + if (installed) { + return int33_get_tsr_data(); + } else { + return local_get_tsr_data(); + } +} + +int resident_end; |