Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-08 05:35:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/subsystems/mvdm/ntvdm/dos/mouse32.c
Timo Kreuzer 807331436e [MVDM] Fix 64 bit issues
2018-08-04 19:19:34 +02:00

1315 lines
40 KiB
C
Raw Blame History

/*
* COPYRIGHT: GPL - See COPYING in the top level directory
* PROJECT: ReactOS Virtual DOS Machine
* FILE: subsystems/mvdm/ntvdm/dos/mouse32.c
* PURPOSE: VDM 32-bit compatible PS/2 MOUSE.COM driver
* PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
*/
/* INCLUDES *******************************************************************/
#include "ntvdm.h"
#define NDEBUG
#include <debug.h>
/* Driver Version number and Copyright */
#include <reactos/buildno.h>
#include <reactos/version.h>
#include "emulator.h"
#include "cpu/cpu.h"
#include "int32.h"
#include "hardware/mouse.h"
#include "hardware/ps2.h"
#include "hardware/pic.h"
#include "hardware/video/svga.h"
/**/
#include "../console/video.h"
/**/
#include "mouse32.h"
#include "bios/bios.h"
#include "bios/bios32/bios32p.h"
#include "memory.h"
#include "io.h"
#include "dos32krnl/memory.h"
/* PRIVATE VARIABLES **********************************************************/
static const CHAR MouseCopyright[] =
"ReactOS PS/2 16/32-bit Mouse Driver Compatible MS-MOUSE 6.26\r\n"
"Version "KERNEL_VERSION_STR" (Build "KERNEL_VERSION_BUILD_STR")\r\n"
"Copyright (C) ReactOS Team 1996-"COPYRIGHT_YEAR"\0";
#pragma pack(push, 1)
typedef struct _MOUSE_DRIVER
{
CHAR Copyright[sizeof(MouseCopyright)];
WORD Version;
BYTE MouseContextScratch[TRAMPOLINE_SIZE];
BYTE MouseDosInt16Stub[Int16To32StubSize];
BYTE MouseIrqInt16Stub[Int16To32StubSize];
} MOUSE_DRIVER, *PMOUSE_DRIVER;
#pragma pack(pop)
/* Global data contained in guest memory */
static WORD MouseDataSegment;
static PMOUSE_DRIVER MouseData;
static CALLBACK16 MouseContext;
#define MICKEYS_PER_CELL_HORIZ 8
#define MICKEYS_PER_CELL_VERT 16
static BOOLEAN DriverEnabled = FALSE;
static MOUSE_DRIVER_STATE DriverState;
static DWORD OldIrqHandler;
static DWORD OldIntHandler;
static WORD DefaultGfxScreenMask[16] =
{
0xE7FF, // 1110011111111111
0xE3FF, // 1110001111111111
0xE1FF, // 1110000111111111
0xE0FF, // 1110000011111111
0xE07F, // 1110000001111111
0xE03F, // 1110000000111111
0xE01F, // 1110000000011111
0xE00F, // 1110000000001111
0xE007, // 1110000000000111
0xE007, // 1110000000000111
0xE03F, // 1110000000111111
0xE21F, // 1110001000011111
0xE61F, // 1110011000011111
0xFF0F, // 1111111100001111
0xFF0F, // 1111111100001111
0xFF8F, // 1111111110001111
};
static WORD DefaultGfxCursorMask[16] =
{
0x0000, // 0000000000000000
0x0800, // 0000100000000000
0x0C00, // 0000110000000000
0x0E00, // 0000111000000000
0x0F00, // 0000111100000000
0x0F80, // 0000111110000000
0x0FC0, // 0000111111000000
0x0FE0, // 0000111111100000
0x0FF0, // 0000111111110000
0x0F80, // 0000111110000000
0x0D80, // 0000110110000000
0x08C0, // 0000100011000000
0x00C0, // 0000000011000000
0x0060, // 0000000001100000
0x0060, // 0000000001100000
0x0000, // 0000000000000000
};
/* PRIVATE FUNCTIONS **********************************************************/
/* static */
VOID BiosPs2Service(UCHAR Function)
{
/* Save AX and BX */
USHORT AX = getAX();
// USHORT BX = getBX();
/*
* Set the parameters:
* AL contains the character to print (already set),
* BL contains the character attribute,
* BH contains the video page to use.
*/
// setBL(DOS_CHAR_ATTRIBUTE);
// setBH(Bda->VideoPage);
setAL(Function);
/* Call the BIOS INT 15h, AH=C2h "Pointing Device BIOS Interface (PS)" */
setAH(0xC2);
Int32Call(&MouseContext, BIOS_MISC_INTERRUPT);
/* Restore AX and BX */
// setBX(BX);
setAX(AX);
}
static VOID DosMouseEnable(VOID);
static VOID DosMouseDisable(VOID);
static VOID PaintMouseCursor(VOID)
{
if (Bda->VideoMode <= 3)
{
WORD Character;
WORD CellX = DriverState.Position.X / 8;
WORD CellY = DriverState.Position.Y / 8;
DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize);
EmulatorReadMemory(&EmulatorContext,
VideoAddress
+ (CellY * Bda->ScreenColumns + CellX) * sizeof(WORD),
(LPVOID)&Character,
sizeof(WORD));
DriverState.Character = Character;
Character &= DriverState.TextCursor.ScreenMask;
Character ^= DriverState.TextCursor.CursorMask;
EmulatorWriteMemory(&EmulatorContext,
VideoAddress
+ (CellY * Bda->ScreenColumns + CellX) * sizeof(WORD),
(LPVOID)&Character,
sizeof(WORD));
}
else if (Bda->VideoMode == 0x12)
{
INT i, j;
BYTE OldMask;
BYTE OldMap;
/* Save the write mask */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
OldMask = IOReadB(VGA_SEQ_DATA);
/* And the selected reading plane */
IOWriteB(VGA_GC_INDEX, VGA_GC_READ_MAP_SEL_REG);
OldMap = IOReadB(VGA_GC_DATA);
for (i = 0; i < 16; i++)
{
WORD CursorLine[4];
DWORD VideoAddress = TO_LINEAR(GRAPHICS_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize)
+ ((DriverState.Position.Y + i) * 640 + DriverState.Position.X) / 8;
for (j = 0; j < 4; j++)
{
/* Select the reading plane */
IOWriteB(VGA_GC_INDEX, VGA_GC_READ_MAP_SEL_REG);
IOWriteB(VGA_GC_DATA, j);
/* Read a part of the scanline */
EmulatorReadMemory(&EmulatorContext, VideoAddress, &CursorLine[j], sizeof(CursorLine[j]));
}
/* Save the data below the cursor */
for (j = 0; j < 16; j++)
{
DriverState.GraphicsData[i * 16 + j] = 0;
if (CursorLine[0] & (1 << j)) DriverState.GraphicsData[i * 16 + j] |= 1 << 0;
if (CursorLine[1] & (1 << j)) DriverState.GraphicsData[i * 16 + j] |= 1 << 1;
if (CursorLine[2] & (1 << j)) DriverState.GraphicsData[i * 16 + j] |= 1 << 2;
if (CursorLine[3] & (1 << j)) DriverState.GraphicsData[i * 16 + j] |= 1 << 3;
}
for (j = 0; j < 4; j++)
{
/* Apply the screen mask */
CursorLine[j] &= MAKEWORD(HIBYTE(DriverState.GraphicsCursor.ScreenMask[i]),
LOBYTE(DriverState.GraphicsCursor.ScreenMask[i]));
/* And the cursor mask */
CursorLine[j] ^= MAKEWORD(HIBYTE(DriverState.GraphicsCursor.CursorMask[i]),
LOBYTE(DriverState.GraphicsCursor.CursorMask[i]));
/* Select the writing plane */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
IOWriteB(VGA_SEQ_DATA, 1 << j);
/* Write the cursor data for this scanline */
EmulatorWriteMemory(&EmulatorContext, VideoAddress, &CursorLine[j], sizeof(CursorLine[j]));
}
}
/* Restore the old mask */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
IOWriteB(VGA_SEQ_DATA, OldMask);
/* And the old reading plane */
IOWriteB(VGA_GC_INDEX, VGA_GC_READ_MAP_SEL_REG);
IOWriteB(VGA_GC_DATA, OldMap);
}
else if (Bda->VideoMode == 0x13)
{
INT i, j;
for (i = 0; i < 16; i++)
{
BYTE CursorLine[16];
DWORD VideoAddress = TO_LINEAR(GRAPHICS_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize)
+ (DriverState.Position.Y + i) * 320 + DriverState.Position.X;
/* Read a part of the scanline */
EmulatorReadMemory(&EmulatorContext,
VideoAddress,
&DriverState.GraphicsData[i * 16],
sizeof(CursorLine));
for (j = 0; j < 16; j++)
{
/* Apply the screen mask by leaving only the masked pixels intact */
CursorLine[j] = (DriverState.GraphicsCursor.ScreenMask[i] & (1 << j))
? DriverState.GraphicsData[i * 16]
: 0x00;
/* Apply the cursor mask... */
if (DriverState.GraphicsCursor.CursorMask[i] & (1 << j))
{
/* ... by inverting the color of each masked pixel */
CursorLine[j] ^= 0x0F;
}
}
/* Write the cursor data for this scanline */
EmulatorWriteMemory(&EmulatorContext, VideoAddress, &CursorLine, sizeof(CursorLine));
}
}
else
{
// TODO: NOT IMPLEMENTED
UNIMPLEMENTED;
}
}
static VOID EraseMouseCursor(VOID)
{
if (Bda->VideoMode <= 3)
{
WORD CellX = DriverState.Position.X / 8;
WORD CellY = DriverState.Position.Y / 8;
DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize);
EmulatorWriteMemory(&EmulatorContext,
VideoAddress
+ (CellY * Bda->ScreenColumns + CellX) * sizeof(WORD),
(LPVOID)&DriverState.Character,
sizeof(WORD));
}
else if (Bda->VideoMode == 0x12)
{
INT i, j;
BYTE OldMask;
/* Save the write mask */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
OldMask = IOReadB(VGA_SEQ_DATA);
for (i = 0; i < 16; i++)
{
WORD CursorLine[4] = {0};
DWORD VideoAddress = TO_LINEAR(GRAPHICS_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize)
+ ((DriverState.Position.Y + i) * 640 + DriverState.Position.X) / 8;
/* Restore the data that was below the cursor */
for (j = 0; j < 16; j++)
{
if (DriverState.GraphicsData[i * 16 + j] & (1 << 0)) CursorLine[0] |= 1 << j;
if (DriverState.GraphicsData[i * 16 + j] & (1 << 1)) CursorLine[1] |= 1 << j;
if (DriverState.GraphicsData[i * 16 + j] & (1 << 2)) CursorLine[2] |= 1 << j;
if (DriverState.GraphicsData[i * 16 + j] & (1 << 3)) CursorLine[3] |= 1 << j;
}
for (j = 0; j < 4; j++)
{
/* Select the writing plane */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
IOWriteB(VGA_SEQ_DATA, 1 << j);
/* Write the original data for this scanline */
EmulatorWriteMemory(&EmulatorContext, VideoAddress, &CursorLine[j], sizeof(CursorLine[j]));
}
}
/* Restore the old mask */
IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_MASK_REG);
IOWriteB(VGA_SEQ_DATA, OldMask);
}
else if (Bda->VideoMode == 0x13)
{
INT i;
for (i = 0; i < 16; i++)
{
DWORD VideoAddress = TO_LINEAR(GRAPHICS_VIDEO_SEG, Bda->VideoPage * Bda->VideoPageSize)
+ (DriverState.Position.Y + i) * 320 + DriverState.Position.X;
/* Write the original data for this scanline */
EmulatorWriteMemory(&EmulatorContext,
VideoAddress,
&DriverState.GraphicsData[i * 16],
16 * sizeof(BYTE));
}
}
else
{
// TODO: NOT IMPLEMENTED
UNIMPLEMENTED;
}
}
static VOID ToMouseCoordinates(PCOORD Position)
{
COORD Resolution = VgaGetDisplayResolution();
DWORD Width = DriverState.MaxX - DriverState.MinX + 1;
DWORD Height = DriverState.MaxY - DriverState.MinY + 1;
if (!VgaGetDoubleVisionState(NULL, NULL))
{
Resolution.X *= 8;
Resolution.Y *= 8;
}
Position->X = DriverState.MinX + ((Position->X * Width) / Resolution.X);
Position->Y = DriverState.MinY + ((Position->Y * Height) / Resolution.Y);
}
static VOID FromMouseCoordinates(PCOORD Position)
{
COORD Resolution = VgaGetDisplayResolution();
DWORD Width = DriverState.MaxX - DriverState.MinX + 1;
DWORD Height = DriverState.MaxY - DriverState.MinY + 1;
if (!VgaGetDoubleVisionState(NULL, NULL))
{
Resolution.X *= 8;
Resolution.Y *= 8;
}
Position->X = ((Position->X - DriverState.MinX) * Resolution.X) / Width;
Position->Y = ((Position->Y - DriverState.MinY) * Resolution.Y) / Height;
}
static VOID CallMouseUserHandlers(USHORT CallMask)
{
USHORT i;
USHORT AX, BX, CX, DX, BP, SI, DI, DS, ES;
COORD Position = DriverState.Position;
ToMouseCoordinates(&Position);
/* Call handler 0 */
if ((DriverState.Handler0.CallMask & CallMask) != 0 &&
DriverState.Handler0.Callback != NULL32)
{
/*
* Set the parameters for the callback.
* NOTE: In text modes, the row and column will be reported
* as a multiple of the cell size, typically 8x8 pixels.
*/
AX = getAX();
BX = getBX();
CX = getCX();
DX = getDX();
BP = getBP();
SI = getSI();
DI = getDI();
DS = getDS();
ES = getES();
setAX(CallMask);
setBX(DriverState.ButtonState);
setCX(Position.X);
setDX(Position.Y);
setSI(MICKEYS_PER_CELL_HORIZ);
setDI(MICKEYS_PER_CELL_VERT);
DPRINT("Calling Handler0 %04X:%04X with CallMask 0x%04X\n",
HIWORD(DriverState.Handler0.Callback),
LOWORD(DriverState.Handler0.Callback),
CallMask);
/* Call the callback */
RunCallback16(&MouseContext, DriverState.Handler0.Callback);
setAX(AX);
setBX(BX);
setCX(CX);
setDX(DX);
setBP(BP);
setSI(SI);
setDI(DI);
setDS(DS);
setES(ES);
}
for (i = 0; i < ARRAYSIZE(DriverState.Handlers); ++i)
{
/* Call the suitable handlers */
if ((DriverState.Handlers[i].CallMask & CallMask) != 0 &&
DriverState.Handlers[i].Callback != NULL32)
{
/*
* Set the parameters for the callback.
* NOTE: In text modes, the row and column will be reported
* as a multiple of the cell size, typically 8x8 pixels.
*/
AX = getAX();
BX = getBX();
CX = getCX();
DX = getDX();
BP = getBP();
SI = getSI();
DI = getDI();
DS = getDS();
ES = getES();
setAX(CallMask);
setBX(DriverState.ButtonState);
setCX(Position.X);
setDX(Position.Y);
setSI(MICKEYS_PER_CELL_HORIZ);
setDI(MICKEYS_PER_CELL_VERT);
DPRINT1("Calling Handler[%d] %04X:%04X with CallMask 0x%04X\n",
i,
HIWORD(DriverState.Handlers[i].Callback),
LOWORD(DriverState.Handlers[i].Callback),
CallMask);
/* Call the callback */
RunCallback16(&MouseContext, DriverState.Handlers[i].Callback);
setAX(AX);
setBX(BX);
setCX(CX);
setDX(DX);
setBP(BP);
setSI(SI);
setDI(DI);
setDS(DS);
setES(ES);
}
}
}
static inline VOID DosUpdatePosition(PCOORD NewPosition)
{
COORD Resolution = VgaGetDisplayResolution();
/* Check for text mode */
if (!VgaGetDoubleVisionState(NULL, NULL))
{
Resolution.X *= 8;
Resolution.Y *= 8;
}
if (DriverState.ShowCount > 0) EraseMouseCursor();
DriverState.Position = *NewPosition;
if (DriverState.ShowCount > 0) PaintMouseCursor();
/* Call the mouse handlers */
CallMouseUserHandlers(0x0001); // We use MS MOUSE v1.0+ format
}
static inline VOID DosUpdateButtons(BYTE ButtonState) // WORD ButtonState
{
USHORT i;
USHORT CallMask = 0x0000; // We use MS MOUSE v1.0+ format
for (i = 0; i < NUM_MOUSE_BUTTONS; i++)
{
BOOLEAN OldState = (DriverState.ButtonState >> i) & 1;
BOOLEAN NewState = (ButtonState >> i) & 1;
if (NewState > OldState)
{
/* Mouse press */
DriverState.PressCount[i]++;
DriverState.LastPress[i] = DriverState.Position;
CallMask |= (1 << (2 * i + 1));
}
else if (NewState < OldState)
{
/* Mouse release */
DriverState.ReleaseCount[i]++;
DriverState.LastRelease[i] = DriverState.Position;
CallMask |= (1 << (2 * i + 2));
}
}
DriverState.ButtonState = ButtonState;
/* Call the mouse handlers */
CallMouseUserHandlers(CallMask);
}
static VOID WINAPI DosMouseIrq(LPWORD Stack)
{
BYTE Flags;
SHORT DeltaX, DeltaY;
COORD Position;
BYTE ButtonState;
/* Read the whole packet at once */
Flags = IOReadB(PS2_DATA_PORT);
PS2PortQueueRead(1); // NOTE: Should be a IOReadB! But see r67231
DeltaX = IOReadB(PS2_DATA_PORT);
PS2PortQueueRead(1); // NOTE: Should be a IOReadB! But see r67231
DeltaY = IOReadB(PS2_DATA_PORT);
/* Adjust the sign */
if (Flags & MOUSE_X_SIGN) DeltaX = -DeltaX;
if (Flags & MOUSE_Y_SIGN) DeltaY = -DeltaY;
/* Update the counters */
DriverState.HorizCount += DeltaX;
DriverState.VertCount += DeltaY;
/*
* Get the absolute position directly from the mouse, this is the only
* way to perfectly synchronize the host and guest mouse pointer.
*/
MouseGetDataFast(&Position, &ButtonState);
/* Call the update subroutines */
DosUpdatePosition(&Position);
DosUpdateButtons(ButtonState);
/* Complete the IRQ */
PicIRQComplete(LOBYTE(Stack[STACK_INT_NUM]));
}
static VOID WINAPI DosMouseService(LPWORD Stack)
{
switch (getAX())
{
/* Reset Driver */
case 0x00:
{
SHORT i;
DriverState.ShowCount = 0;
DriverState.ButtonState = 0;
/* Initialize the default clipping range */
DriverState.MinX = 0;
DriverState.MaxX = MOUSE_MAX_HORIZ - 1;
DriverState.MinY = 0;
DriverState.MaxY = MOUSE_MAX_VERT - 1;
/* Set the default text cursor */
DriverState.TextCursor.ScreenMask = 0xFFFF; /* Display everything */
DriverState.TextCursor.CursorMask = 0xFF00; /* ... but with inverted attributes */
/* Set the default graphics cursor */
DriverState.GraphicsCursor.HotSpot.X = 3;
DriverState.GraphicsCursor.HotSpot.Y = 1;
RtlCopyMemory(DriverState.GraphicsCursor.ScreenMask,
DefaultGfxScreenMask,
sizeof(DriverState.GraphicsCursor.ScreenMask));
RtlCopyMemory(DriverState.GraphicsCursor.CursorMask,
DefaultGfxCursorMask,
sizeof(DriverState.GraphicsCursor.CursorMask));
/* Initialize the counters */
DriverState.HorizCount = DriverState.VertCount = 0;
for (i = 0; i < NUM_MOUSE_BUTTONS; i++)
{
DriverState.PressCount[i] = DriverState.ReleaseCount[i] = 0;
}
/* Return mouse information */
setAX(0xFFFF); // Hardware & driver installed
setBX(NUM_MOUSE_BUTTONS);
break;
}
/* Show Mouse Cursor */
case 0x01:
{
DriverState.ShowCount++;
if (DriverState.ShowCount == 1) PaintMouseCursor();
break;
}
/* Hide Mouse Cursor */
case 0x02:
{
DriverState.ShowCount--;
if (DriverState.ShowCount == 0) EraseMouseCursor();
break;
}
/* Return Position and Button Status */
case 0x03:
{
COORD Position = DriverState.Position;
ToMouseCoordinates(&Position);
setBX(DriverState.ButtonState);
setCX(Position.X);
setDX(Position.Y);
break;
}
/* Position Mouse Cursor */
case 0x04:
{
COORD Position = { getCX(), getDX() };
FromMouseCoordinates(&Position);
DriverState.Position = Position;
break;
}
/* Return Button Press Data */
case 0x05:
{
WORD Button = getBX();
COORD LastPress = DriverState.LastPress[Button];
ToMouseCoordinates(&LastPress);
setAX(DriverState.ButtonState);
setBX(DriverState.PressCount[Button]);
setCX(LastPress.X);
setDX(LastPress.Y);
/* Reset the counter */
DriverState.PressCount[Button] = 0;
break;
}
/* Return Button Release Data */
case 0x06:
{
WORD Button = getBX();
COORD LastRelease = DriverState.LastRelease[Button];
ToMouseCoordinates(&LastRelease);
setAX(DriverState.ButtonState);
setBX(DriverState.ReleaseCount[Button]);
setCX(LastRelease.X);
setDX(LastRelease.Y);
/* Reset the counter */
DriverState.ReleaseCount[Button] = 0;
break;
}
/* Define Horizontal Cursor Range */
case 0x07:
{
WORD Min = getCX();
WORD Max = getDX();
if (!VgaGetDoubleVisionState(NULL, NULL))
{
/* Text mode */
Min &= ~0x07;
Max |= 0x07;
}
DPRINT("Setting mouse horizontal range: %u - %u\n", Min, Max);
DriverState.MinX = Min;
DriverState.MaxX = Max;
break;
}
/* Define Vertical Cursor Range */
case 0x08:
{
WORD Min = getCX();
WORD Max = getDX();
if (!VgaGetDoubleVisionState(NULL, NULL))
{
/* Text mode */
Min &= ~0x07;
Max |= 0x07;
}
DPRINT("Setting mouse vertical range: %u - %u\n", Min, Max);
DriverState.MinY = Min;
DriverState.MaxY = Max;
break;
}
/* Define Graphics Cursor */
case 0x09:
{
PWORD MaskBitmap = (PWORD)SEG_OFF_TO_PTR(getES(), getDX());
DriverState.GraphicsCursor.HotSpot.X = getBX();
DriverState.GraphicsCursor.HotSpot.Y = getCX();
RtlCopyMemory(DriverState.GraphicsCursor.ScreenMask,
MaskBitmap,
sizeof(DriverState.GraphicsCursor.ScreenMask));
RtlCopyMemory(DriverState.GraphicsCursor.CursorMask,
&MaskBitmap[16],
sizeof(DriverState.GraphicsCursor.CursorMask));
break;
}
/* Define Text Cursor */
case 0x0A:
{
USHORT BX = getBX();
if (BX == 0x0000)
{
/* Define software cursor */
DriverState.TextCursor.ScreenMask = getCX();
DriverState.TextCursor.CursorMask = getDX();
}
else if (BX == 0x0001)
{
/* Define hardware cursor */
DPRINT1("Defining hardware cursor is unimplemented\n");
UNIMPLEMENTED;
// CX == start scan line
// DX == end scan line
}
else
{
DPRINT1("Invalid BX value 0x%04X\n", BX);
}
break;
}
/* Read Motion Counters */
case 0x0B:
{
setCX(DriverState.HorizCount);
setDX(DriverState.VertCount);
/* Reset the counters */
DriverState.HorizCount = DriverState.VertCount = 0;
break;
}
/* Define Interrupt Subroutine Parameters, compatible MS MOUSE v1.0+ */
case 0x0C:
{
DriverState.Handler0.CallMask = getCX();
DriverState.Handler0.Callback = MAKELONG(getDX(), getES()); // Far pointer to the callback
DPRINT1("Define callback 0x%04X, %04X:%04X\n",
DriverState.Handler0.CallMask,
HIWORD(DriverState.Handler0.Callback),
LOWORD(DriverState.Handler0.Callback));
break;
}
/* Define Mickey/Pixel Ratio */
case 0x0F:
{
/* This call should be completely ignored */
break;
}
/* Set Exclusion Area */
// http://www.ctyme.com/intr/rb-5972.htm
// http://www.techhelpmanual.com/849-int_33h_0010h__set_exclusion_area.html
//case 0x10:
//{
//}
/* Define Double-Speed Threshold */
case 0x13:
{
DPRINT1("INT 33h, AH=13h: Mouse double-speed threshold is UNSUPPORTED\n");
break;
}
/* Exchange Interrupt Subroutines, compatible MS MOUSE v3.0+ (see function 0x0C) */
case 0x14:
{
USHORT OldCallMask = DriverState.Handler0.CallMask;
ULONG OldCallback = DriverState.Handler0.Callback;
DriverState.Handler0.CallMask = getCX();
DriverState.Handler0.Callback = MAKELONG(getDX(), getES()); // Far pointer to the callback
DPRINT1("Exchange old callback 0x%04X, %04X:%04X with new callback 0x%04X, %04X:%04X\n",
OldCallMask,
HIWORD(OldCallback),
LOWORD(OldCallback),
DriverState.Handler0.CallMask,
HIWORD(DriverState.Handler0.Callback),
LOWORD(DriverState.Handler0.Callback));
/* Return old callmask in CX and callback vector in ES:DX */
setCX(OldCallMask);
setES(HIWORD(OldCallback));
setDX(LOWORD(OldCallback));
break;
}
/* Return Driver Storage Requirements */
case 0x15:
{
setBX(sizeof(MOUSE_DRIVER_STATE));
break;
}
/* Save Driver State */
case 0x16:
{
/* Check whether the user buffer has correct size and fail if not */
if (getBX() != sizeof(MOUSE_DRIVER_STATE)) break;
*((PMOUSE_DRIVER_STATE)SEG_OFF_TO_PTR(getES(), getDX())) = DriverState;
break;
}
/* Restore Driver State */
case 0x17:
{
/* Check whether the user buffer has correct size and fail if not */
if (getBX() != sizeof(MOUSE_DRIVER_STATE)) break;
DriverState = *((PMOUSE_DRIVER_STATE)SEG_OFF_TO_PTR(getES(), getDX()));
break;
}
/* Set Alternate Mouse User Handler, compatible MS MOUSE v6.0+ */
case 0x18:
{
/*
* Up to three handlers can be defined by separate calls to this
* function, each with a different combination of shift states in
* the call mask; calling this function again with a call mask of
* 0000h undefines the specified handler (official documentation);
* specifying the same call mask and an address of 0000h:0000h
* undefines the handler (real life).
* See Ralf Brown: http://www.ctyme.com/intr/rb-5981.htm
* for more information.
*/
USHORT i;
USHORT CallMask = getCX();
ULONG Callback = MAKELONG(getDX(), getES()); // Far pointer to the callback
BOOLEAN Success = FALSE;
DPRINT1("Define v6.0+ callback 0x%04X, %04X:%04X\n",
CallMask, HIWORD(Callback), LOWORD(Callback));
if (CallMask == 0x0000)
{
/*
* Find the handler entry corresponding to the given
* callback and undefine it.
*/
for (i = 0; i < ARRAYSIZE(DriverState.Handlers); ++i)
{
if (DriverState.Handlers[i].Callback == Callback)
{
/* Found it, undefine the handler */
DriverState.Handlers[i].CallMask = 0x0000;
DriverState.Handlers[i].Callback = NULL32;
Success = TRUE;
break;
}
}
}
else if (Callback == NULL32)
{
/*
* Find the handler entry corresponding to the given
* callmask and undefine it.
*/
for (i = 0; i < ARRAYSIZE(DriverState.Handlers); ++i)
{
if (DriverState.Handlers[i].CallMask == CallMask)
{
/* Found it, undefine the handler */
DriverState.Handlers[i].CallMask = 0x0000;
DriverState.Handlers[i].Callback = NULL32;
Success = TRUE;
break;
}
}
}
else
{
/*
* Try to find a handler entry corresponding to the given
* callmask to redefine it, otherwise find an empty handler
* entry and set the new handler in there.
*/
USHORT EmptyHandler = 0xFFFF; // Invalid handler
for (i = 0; i < ARRAYSIZE(DriverState.Handlers); ++i)
{
/* Find the first empty handler */
if (EmptyHandler == 0xFFFF &&
DriverState.Handlers[i].CallMask == 0x0000 &&
DriverState.Handlers[i].Callback == NULL32)
{
EmptyHandler = i;
}
if (DriverState.Handlers[i].CallMask == CallMask)
{
/* Found it, redefine the handler */
DriverState.Handlers[i].CallMask = CallMask;
DriverState.Handlers[i].Callback = Callback;
Success = TRUE;
break;
}
}
/*
* If we haven't found anything and we found
* an empty handler, set it.
*/
if (!Success && EmptyHandler != 0xFFFF
/* && EmptyHandler < ARRAYSIZE(DriverState.Handlers) */)
{
DriverState.Handlers[EmptyHandler].CallMask = CallMask;
DriverState.Handlers[EmptyHandler].Callback = Callback;
Success = TRUE;
}
}
/* If we failed, set error code */
if (!Success) setAX(0xFFFF);
break;
}
/* Return User Alternate Interrupt Vector, compatible MS MOUSE v6.0+ */
case 0x19:
{
USHORT i;
USHORT CallMask = getCX();
ULONG Callback;
BOOLEAN Success = FALSE;
/*
* Find the handler entry corresponding to the given callmask.
*/
for (i = 0; i < ARRAYSIZE(DriverState.Handlers); ++i)
{
if (DriverState.Handlers[i].CallMask == CallMask)
{
/* Found it */
Callback = DriverState.Handlers[i].Callback;
Success = TRUE;
break;
}
}
if (Success)
{
/* Return the callback vector in BX:DX */
setBX(HIWORD(Callback));
setDX(LOWORD(Callback));
}
else
{
/* We failed, set error code */
setCX(0x0000);
}
break;
}
/* Set Mouse Sensitivity */
case 0x1A:
{
DPRINT1("INT 33h, AH=1Ah: Mouse sensitivity is UNSUPPORTED\n");
// FIXME: Do that at runtime!
// UCHAR BH = getBH();
// setBH(0x00);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
break;
}
/* Return Mouse Sensitivity */
case 0x1B:
{
DPRINT1("INT 33h, AH=1Bh: Mouse sensitivity is UNSUPPORTED\n");
/* Return default values */
setBX(50); // Horizontal speed
setCX(50); // Vertical speed
setDX(50); // Double speed threshold
// FIXME: Get that at runtime!
// UCHAR BH = getBH();
// setBH(0x00);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
break;
}
/* Disable Mouse Driver */
case 0x1F:
{
/* INT 33h vector before the mouse driver was first installed */
setES(HIWORD(OldIntHandler));
setBX(LOWORD(OldIntHandler));
DosMouseDisable();
// UCHAR BH = getBH();
// setBH(0x00);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
break;
}
/* Enable Mouse Driver */
case 0x20:
{
DosMouseEnable();
// UCHAR BH = getBH();
// setBH(0x01);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
break;
}
/* Software Reset */
case 0x21:
{
/*
* See: http://www.htl-steyr.ac.at/~morg/pcinfo/hardware/interrupts/inte3sq8.htm
* for detailed information and differences with respect to subfunction 0x00:
* http://www.htl-steyr.ac.at/~morg/pcinfo/hardware/interrupts/inte3j74.htm
*/
SHORT i;
DriverState.ShowCount = 0;
DriverState.ButtonState = 0;
/* Initialize the default clipping range */
DriverState.MinX = 0;
DriverState.MaxX = MOUSE_MAX_HORIZ - 1;
DriverState.MinY = 0;
DriverState.MaxY = MOUSE_MAX_VERT - 1;
/* Initialize the counters */
DriverState.HorizCount = DriverState.VertCount = 0;
for (i = 0; i < NUM_MOUSE_BUTTONS; i++)
{
DriverState.PressCount[i] = DriverState.ReleaseCount[i] = 0;
}
/* Return mouse information */
setAX(0xFFFF); // Hardware & driver installed
setBX(NUM_MOUSE_BUTTONS);
break;
}
/* Get Software Version, Mouse Type, and IRQ Number, compatible MS MOUSE v6.26+ */
case 0x24:
{
setBX(MOUSE_VERSION); // Version Number
/*
* See Ralf Brown: http://www.ctyme.com/intr/rb-5993.htm
* for the list of possible values.
*/
// FIXME: To be determined at runtime!
setCH(0x04); // PS/2 Type
setCL(0x00); // PS/2 Interrupt
break;
}
// BIOS Function INT 33h, AX = 0x0025 NOT IMPLEMENTED
case 0x25:
{
setAX(0);
setBX(0);
setCX(0);
setDX(0);
UNIMPLEMENTED;
break;
}
/* Get Maximum Virtual Coordinates */
case 0x26:
{
setBX(!DriverEnabled);
// FIXME: In fact the MaxX and MaxY here are
// theoretical values for the current video mode.
// They therefore can be different from the current
// min/max values.
// See http://www.ctyme.com/intr/rb-5995.htm
// for more details.
setCX(DriverState.MaxX);
setDX(DriverState.MaxY);
break;
}
/* Get Current Minimum/Maximum Virtual Coordinates */
case 0x31:
{
setAX(DriverState.MinX);
setBX(DriverState.MinY);
setCX(DriverState.MaxX);
setDX(DriverState.MaxY);
break;
}
#if 0
case 0x33:
{
/*
* Related to http://www.ctyme.com/intr/rb-5985.htm
* INT 33h, AX=001Ch "SET INTERRUPT RATE":
* Values for mouse interrupt rate:
* BX = rate
00h no interrupts allowed
01h 30 per second
02h 50 per second
03h 100 per second
04h 200 per second
*/
}
#endif
/* Return Pointer to Copyright String */
case 0x4D:
{
setES(MouseDataSegment);
setDI(FIELD_OFFSET(MOUSE_DRIVER, Copyright));
break;
}
/* Get Version String (pointer) */
case 0x6D:
{
/*
* The format of the version "string" is:
* Offset Size Description
* 00h BYTE major version
* 01h BYTE minor version (BCD)
*/
setES(MouseDataSegment);
setDI(FIELD_OFFSET(MOUSE_DRIVER, Version));
break;
}
default:
{
DPRINT1("BIOS Function INT 33h, AX = 0x%04X NOT IMPLEMENTED\n", getAX());
}
}
}
/* PUBLIC FUNCTIONS ***********************************************************/
static
VOID DosMouseEnable(VOID)
{
if (DriverEnabled) return;
DriverEnabled = TRUE;
/* Get the old IRQ handler */
OldIrqHandler = ((PDWORD)BaseAddress)[MOUSE_IRQ_INT];
/* Set the IRQ handler */
RegisterInt32(MAKELONG(FIELD_OFFSET(MOUSE_DRIVER, MouseIrqInt16Stub), MouseDataSegment),
MOUSE_IRQ_INT, DosMouseIrq, NULL);
}
static
VOID DosMouseDisable(VOID)
{
if (!DriverEnabled) return;
/* Restore the old IRQ handler */
((PDWORD)BaseAddress)[MOUSE_IRQ_INT] = OldIrqHandler;
DriverEnabled = FALSE;
}
BOOLEAN DosMouseInitialize(VOID)
{
/* Initialize some memory for storing our data that should be available to DOS */
MouseDataSegment = DosAllocateMemory(sizeof(MOUSE_DRIVER), NULL);
if (MouseDataSegment == 0) return FALSE;
MouseData = (PMOUSE_DRIVER)SEG_OFF_TO_PTR(MouseDataSegment, 0x0000);
/* Initialize the callback context */
InitializeContext(&MouseContext, MouseDataSegment, FIELD_OFFSET(MOUSE_DRIVER, MouseContextScratch));
/* Clear the state */
RtlZeroMemory(&DriverState, sizeof(DriverState));
/* Mouse Driver Copyright */
RtlCopyMemory(MouseData->Copyright, MouseCopyright, sizeof(MouseCopyright)-1);
/* Mouse Driver Version in BCD format, compatible MS-MOUSE */
MouseData->Version = MAKEWORD(MOUSE_VERSION/0x0100, MOUSE_VERSION%0x0100);
/* Get the old mouse service interrupt handler */
OldIntHandler = ((PDWORD)BaseAddress)[DOS_MOUSE_INTERRUPT];
/* Initialize the interrupt handler */
RegisterInt32(MAKELONG(FIELD_OFFSET(MOUSE_DRIVER, MouseDosInt16Stub), MouseDataSegment),
DOS_MOUSE_INTERRUPT, DosMouseService, NULL);
DosMouseEnable();
// UCHAR BH = getBH();
// setBH(0x01);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
return TRUE;
}
VOID DosMouseCleanup(VOID)
{
if (DriverState.ShowCount > 0) EraseMouseCursor();
DosMouseDisable();
// UCHAR BH = getBH();
// setBH(0x00);
// BiosPs2Service(0x00);
// FIXME: Check for return status in AH and CF
// setBH(BH);
/* Restore the old mouse service interrupt handler */
((PDWORD)BaseAddress)[DOS_MOUSE_INTERRUPT] = OldIntHandler;
DosFreeMemory(MouseDataSegment);
MouseDataSegment = 0;
MouseData = 0;
}
/* EOF */
Reference in a new issue View git blame Copy permalink