1463 lines
50 KiB
C
1463 lines
50 KiB
C
/*
|
|
* BIOS interrupt 10h handler
|
|
*
|
|
* Copyright 1998 Ove Kåven
|
|
* Copyright 1998 Joseph Pranevich
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "vga.h"
|
|
#include "wine/debug.h"
|
|
#include "dosexe.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(int);
|
|
|
|
/*
|
|
* Display combination code for active display.
|
|
*
|
|
* Values (hex):
|
|
* 00 - no display
|
|
* 01 - monochrome adapter w/ monochrome display
|
|
* 02 - CGA w/ color display
|
|
* 03 - reserved
|
|
* 04 - EGA w/ color display
|
|
* 05 - EGA w/ monochrome display
|
|
* 06 - PGA w/ color display
|
|
* 07 - VGA w/ monochrome analog display
|
|
* 08 - VGA w/ color analog display
|
|
* 09 - reserved
|
|
* 0A - MCGA w/ digital color display
|
|
* 0B - MCGA w/ monochrome analog display
|
|
* 0C - MCGA w/ color analog display
|
|
* FF - unknown display type
|
|
*/
|
|
#define INT10_DCC 0x08
|
|
|
|
#include "pshpack1.h"
|
|
|
|
/*
|
|
* Structure for DOS data that can be accessed directly from applications.
|
|
* This structure must be correctly packed.
|
|
*/
|
|
typedef struct _INT10_HEAP {
|
|
BYTE StaticModeSupport[7]; /* modes supported 1..7 */
|
|
BYTE StaticScanlineSupport; /* scan lines supported */
|
|
BYTE StaticNumberCharBlocks; /* total number of char blocks */
|
|
BYTE StaticActiveCharBlocks; /* max number of active char blocks */
|
|
WORD StaticMiscFlags; /* misc function support flags */
|
|
WORD StaticReserved1; /* reserved */
|
|
BYTE StaticSavePointerFlags; /* save pointer function flags */
|
|
BYTE StaticReserved2; /* reserved */
|
|
|
|
WORD VesaCurrentMode;
|
|
WORD VesaModeList[64];
|
|
char VesaOEMName[32];
|
|
char VesaProductName[32];
|
|
char VesaProductRev[32];
|
|
char VesaVendorName[32];
|
|
|
|
WORD WineHeapSegment;
|
|
} INT10_HEAP;
|
|
|
|
/*
|
|
* Structure for VBE Mode Info Block. See the VBE 3.0 standard for details.
|
|
* This structure must be correctly packed.
|
|
*/
|
|
struct _ModeInfoBlock {
|
|
WORD ModeAttributes; /* 0x00 */
|
|
BYTE WinAAttributes; /* 0x02 */
|
|
BYTE WinBAttributes; /* 0x03 */
|
|
WORD WinGranularity; /* 0x04 */
|
|
WORD WinSize; /* 0x06 */
|
|
WORD WinASegment; /* 0x08 */
|
|
WORD WinBSegment; /* 0x0A */
|
|
DWORD WinFuncPtr; /* 0x0C */
|
|
WORD BytesPerScanLine; /* 0x10 */
|
|
/* mandatory for VBE 1.2+ */
|
|
WORD XResolution; /* 0x12 */
|
|
WORD YResolution; /* 0x14 */
|
|
BYTE XCharSize; /* 0x16 */
|
|
BYTE YCharSize; /* 0x17 */
|
|
BYTE NumberOfPlanes; /* 0x18 */
|
|
BYTE BitsPerPixel; /* 0x19 */
|
|
BYTE NumberOfBanks; /* 0x1A */
|
|
BYTE MemoryModel; /* 0x1B */
|
|
BYTE BankSize; /* 0x1C */
|
|
BYTE NumberOfImagePages; /* 0x1D */
|
|
BYTE Reserved1; /* 0x1E */
|
|
BYTE RedMaskSize; /* 0x1F */
|
|
BYTE RedFieldPosition; /* 0x20 */
|
|
BYTE GreenMaskSize; /* 0x21 */
|
|
BYTE GreenFieldPosition; /* 0x22 */
|
|
BYTE BlueMaskSize; /* 0x23 */
|
|
BYTE BlueFieldPosition; /* 0x24 */
|
|
BYTE RsvdMaskSize; /* 0x25 */
|
|
BYTE RsvdFieldPosition; /* 0x26 */
|
|
BYTE DirectColorModeInfo; /* 0x27 */
|
|
/* mandatory for VBE 2.0+ */
|
|
DWORD PhysBasePtr; /* 0x28 */
|
|
DWORD Reserved2; /* 0x2C */
|
|
WORD Reserved3; /* 0x30 */
|
|
/* mandatory for VBE 3.0+ */
|
|
WORD LinBytesPerScanLine; /* 0x32 */
|
|
BYTE BnkNumberOfImagePages;/* 0x34 */
|
|
BYTE LinNumberOfImagePages;/* 0x35 */
|
|
BYTE LinRedMaskSize; /* 0x36 */
|
|
BYTE LinRedFieldPosition; /* 0x37 */
|
|
BYTE LinGreenMaskSize; /* 0x38 */
|
|
BYTE LinGreenFieldPosition;/* 0x39 */
|
|
BYTE LinBlueMaskSize; /* 0x3A */
|
|
BYTE LinBlueFieldPosition; /* 0x3B */
|
|
BYTE LinRsvdMaskSize; /* 0x3C */
|
|
BYTE LinRsvdFieldPosition; /* 0x3D */
|
|
DWORD MaxPixelClock; /* 0x3E */
|
|
BYTE Reserved4[190]; /* 0x42 */
|
|
};
|
|
|
|
#include "poppack.h"
|
|
|
|
/* True if video mode is a vesa mode, false otherwise.
|
|
* More correct would be to use something like (x > 0xff || x == 0x6a)
|
|
* but as long as we have only the standard VGA and VESA modes this is ok too */
|
|
#define IS_VESA_MODE(x) ((x) >= 0x6a)
|
|
|
|
/* Forward declarations. */
|
|
static INT10_HEAP *INT10_GetHeap(void);
|
|
static void INT10_SetCursorPos(BIOSDATA*, unsigned, unsigned, unsigned);
|
|
|
|
/**********************************************************************
|
|
* INT10_FillControllerInformation
|
|
*
|
|
* Fill 256-byte (VBE1.x) or 512-byte buffer (VBE2.0+) with
|
|
* capabilities of the video controller.
|
|
*/
|
|
static void INT10_FillControllerInformation( BYTE *buffer )
|
|
{
|
|
INT10_HEAP *heap = INT10_GetHeap();
|
|
|
|
/* 00 - BYTE[4]: signature */
|
|
memmove( buffer, "VESA", 4 );
|
|
|
|
/* 04 - WORD: version number */
|
|
*(WORD*)(buffer + 4) = 0x0300; /* version 3.0 */
|
|
|
|
/* 06 - DWORD: pointer to OEM name */
|
|
*(SEGPTR*)(buffer + 6) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
VesaOEMName) );
|
|
|
|
/*
|
|
* 10 - DWORD: capabilities flags
|
|
* Bits:
|
|
* 0 - DAC can be switched into 8-bit mode
|
|
* 1 - non-VGA controller
|
|
* 2 - programmed DAC with blank bit
|
|
* 3 - controller supports hardware stereoscopic signalling
|
|
* 4 - =0 stereo signalling via external VESA stereo connector
|
|
* =1 stereo signalling via VESA EVC connector
|
|
* 5 - controller supports hardware mouse cursor
|
|
* 6 - controller supports hardware clipping
|
|
* 7 - controller supports transparent BitBLT
|
|
* 8-31 - reserved (0)
|
|
*/
|
|
*(DWORD*)(buffer + 10) = 0; /* FIXME */
|
|
|
|
/* 14 - DWORD: pointer to list of supported VESA and OEM video modes */
|
|
*(SEGPTR*)(buffer + 14) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
VesaModeList) );
|
|
|
|
/* 18 - WORD: total amount of video memory in 64K blocks */
|
|
*(WORD*)(buffer + 18) = 16; /* FIXME */
|
|
|
|
/* 20 - WORD: OEM software version (BCD, high byte = major) */
|
|
*(WORD*)(buffer + 20) = 0x0100; /* version 1.0 */
|
|
|
|
/* 22 - DWORD: pointer to vendor name */
|
|
*(SEGPTR*)(buffer + 22) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
VesaVendorName) );
|
|
|
|
/* 26 - DWORD: pointer to product name */
|
|
*(SEGPTR*)(buffer + 26) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
VesaProductName) );
|
|
|
|
/* 30 - DWORD: pointer to product revision string */
|
|
*(SEGPTR*)(buffer + 30) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
VesaProductRev) );
|
|
|
|
/* 34 - WORD: VBE/AF version (if capabilities bit 3 set) */
|
|
*(WORD*)(buffer + 34) = 0;
|
|
|
|
/*
|
|
* 36 - DWORD: pointer to list of accelerated modes
|
|
* (if capabilities bit 3 set)
|
|
*/
|
|
*(SEGPTR*)(buffer + 36) = 0;
|
|
|
|
/* 40 - BYTE[216]: reserved for VBE implementation, set to zero */
|
|
memset( buffer + 40, 0, 216 );
|
|
|
|
/*
|
|
* 256 - BYTE[256]: reserved for VBE3.0 implementation,
|
|
* ignored in order to support older programs
|
|
*/
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_FillModeInformation
|
|
*
|
|
* Fill 256-byte buffer with extended information about display mode.
|
|
*
|
|
* Returns FALSE if mode is unknown and TRUE is mode is known
|
|
* even if it is not supported.
|
|
*/
|
|
static BOOL INT10_FillModeInformation( struct _ModeInfoBlock *mib, WORD mode )
|
|
{
|
|
const VGA_MODE *ptr = VGA_GetModeInfo( mode );
|
|
if (!ptr)
|
|
return FALSE;
|
|
|
|
/*
|
|
* 00 - WORD: mode attributes
|
|
* Bits:
|
|
* 0 - Mode supported by present hardware configuration.
|
|
* 1 - Optional information available. Must be =1 for VBE v1.2+.
|
|
* 2 - BIOS output supported.
|
|
* Int10 functions 01, 02, 06, 07, 09, 0a and 0e are supported.
|
|
* 3 - Set if color, clear if monochrome.
|
|
* 4 - Set if graphics mode, clear if text mode.
|
|
* 5 - Mode is not VGA-compatible if set.
|
|
* VGA-compatible modes support standard VGA I/O ports.
|
|
* 6 - Bank-switched (or windowed) mode is not supported if set.
|
|
* 7 - Linear framebuffer mode supported.
|
|
* 8 - Double scanning supported.
|
|
* 9 - Interlaced operation supported.
|
|
* 10 - Triple buffering supported.
|
|
* 11 - Stereoscopic display supported.
|
|
* 12 - Dual display start address supported.
|
|
* 13-15 - Reserved.
|
|
*/
|
|
{
|
|
WORD attr = 0x0002; /* set optional info available */
|
|
/* Enable color mode - if both Colors & Depth are 0, then assume monochrome*/
|
|
if (ptr->Colors || ptr->Depth)
|
|
{
|
|
attr |= 0x0008;
|
|
}
|
|
|
|
/*
|
|
* FIXME: Attribute handling is incomplete.
|
|
*/
|
|
|
|
/* Mode supported? */
|
|
if (ptr->Supported)
|
|
{
|
|
attr |= 0x0001; /* set display mode supported */
|
|
}
|
|
|
|
/* Graphical mode? */
|
|
if (ptr->ModeType != TEXT)
|
|
{
|
|
attr |= 0x0010; /* set graphics mode on (text mode off) */
|
|
}
|
|
|
|
/* Not VGA-compatible? */
|
|
if (IS_VESA_MODE(mode))
|
|
attr |= 0x0020; /* disable VGA ports */
|
|
|
|
mib->ModeAttributes = attr;
|
|
}
|
|
|
|
/*
|
|
* 02 - BYTE[2]: window attributes, window A and window B
|
|
* Bits:
|
|
* 0 - Window exists.
|
|
* 1 - Window is readable.
|
|
* 2 - Window is writable.
|
|
* 3-7 - Reserved.
|
|
*/
|
|
mib->WinAAttributes = 0x07; /* window A exists, readable and writable */
|
|
mib->WinBAttributes = 0x00; /* window B not supported */
|
|
|
|
/* 04 - WORD: window granularity in KB */
|
|
mib->WinGranularity = 64;
|
|
|
|
/* 06 - WORD: window size in KB */
|
|
mib->WinSize = 64;
|
|
|
|
/* 08 - WORD[2]: start segments, window A and window B */
|
|
mib->WinASegment = 0xa000; /* window A segment */
|
|
mib->WinBSegment = 0x0000; /* window B not supported */
|
|
|
|
/* 12 - DWORD: window positioning function */
|
|
mib->WinFuncPtr = 0; /* not supported */
|
|
|
|
/* 16 - WORD: bytes per scan line */
|
|
/* FIXME: is this always correct? */
|
|
mib->BytesPerScanLine = ptr->Width * (ptr->Depth ? (ptr->Depth + 7) / 8 : 1);
|
|
|
|
/* 18 - WORD: width in pixels (graphics) or characters (text) */
|
|
if (ptr->ModeType == TEXT)
|
|
{
|
|
mib->XResolution = ptr->TextCols;
|
|
}
|
|
else
|
|
{
|
|
mib->XResolution = ptr->Width;
|
|
}
|
|
|
|
/* 20 - WORD: height in pixels (graphics) or characters (text) */
|
|
if (ptr->ModeType == TEXT)
|
|
{
|
|
mib->YResolution = ptr->TextRows;
|
|
}
|
|
else
|
|
{
|
|
mib->YResolution = ptr->Height;
|
|
}
|
|
|
|
/* 22 - BYTE: width of character cell in pixels */
|
|
mib->XCharSize = ptr->CharWidth;
|
|
|
|
/* 23 - BYTE: height of character cell in pixels */
|
|
mib->YCharSize = ptr->CharHeight;
|
|
|
|
/* 24 - BYTE: number of memory planes */
|
|
mib->NumberOfPlanes = 1; /* FIXME */
|
|
|
|
/* 25 - BYTE: number of bits per pixel */
|
|
mib->BitsPerPixel = ptr->Depth; /* FIXME: text modes? reserved bits? */
|
|
|
|
/* 26 - BYTE: number of banks */
|
|
mib->NumberOfBanks = 1; /* FIXME */
|
|
|
|
/*
|
|
* 27 - BYTE: memory model type
|
|
* Values (hex):
|
|
* 00 - Text mode
|
|
* 01 - CGA graphics
|
|
* 02 - Hercules graphics
|
|
* 03 - Planar
|
|
* 04 - Packed pixel
|
|
* 05 - Non-chain 4, 256 color
|
|
* 06 - Direct color
|
|
* 07 - YUV
|
|
* 08-0F - Reserved for VESA.
|
|
* 10-FF - OEM memory models.
|
|
*/
|
|
if (ptr->ModeType == TEXT)
|
|
mib->MemoryModel = 0; /* text mode */
|
|
else
|
|
mib->MemoryModel = 3; /* FIXME */
|
|
|
|
/* 28 - BYTE: size of bank in KB */
|
|
mib->BankSize = 0; /* FIXME */
|
|
|
|
/* 29 - BYTE: number of image pages (less one) in video RAM */
|
|
mib->NumberOfImagePages = (ptr->ScreenPages)-1;
|
|
|
|
/* 30 - BYTE: reserved (0x00 for VBE 1.0-2.0, 0x01 for VBE 3.0) */
|
|
mib->Reserved1 = 0x01;
|
|
|
|
/*
|
|
* 31,33,35 - BYTE: red/green/blue mask size
|
|
* Size of red/green/blue color component in bits.
|
|
* 32,34,36 - BYTE: red/green/blue field position
|
|
* Bit position of the least significant bit of red/green/blue color
|
|
* component.
|
|
* Both should be only used when the memory model is direct color or YUV
|
|
* but "Imperium Romanum" uses this field even when the memory model is
|
|
* planar. So always fill this field when we have a depth bigger than 8,
|
|
* otherwise set them to zero.
|
|
*/
|
|
switch (ptr->Depth) {
|
|
case 24:
|
|
mib->RedMaskSize = 8;
|
|
mib->GreenMaskSize = 8;
|
|
mib->BlueMaskSize = 8;
|
|
mib->RsvdMaskSize = 0;
|
|
mib->RedFieldPosition = 16;
|
|
mib->GreenFieldPosition = 8;
|
|
mib->BlueFieldPosition = 0;
|
|
mib->RsvdFieldPosition = 0;
|
|
break;
|
|
case 16:
|
|
mib->RedMaskSize = 5;
|
|
mib->GreenMaskSize = 6;
|
|
mib->BlueMaskSize = 5;
|
|
mib->RsvdMaskSize = 0;
|
|
mib->RedFieldPosition = 11;
|
|
mib->GreenFieldPosition = 5;
|
|
mib->BlueFieldPosition = 0;
|
|
mib->RsvdFieldPosition = 0;
|
|
break;
|
|
case 15:
|
|
mib->RedMaskSize = 5;
|
|
mib->GreenMaskSize = 5;
|
|
mib->BlueMaskSize = 5;
|
|
mib->RsvdMaskSize = 1;
|
|
mib->RedFieldPosition = 10;
|
|
mib->GreenFieldPosition = 5;
|
|
mib->BlueFieldPosition = 0;
|
|
mib->RsvdFieldPosition = 15;
|
|
break;
|
|
default:
|
|
mib->RedMaskSize = 0;
|
|
mib->GreenMaskSize = 0;
|
|
mib->BlueMaskSize = 0;
|
|
mib->RsvdMaskSize = 0;
|
|
mib->RedFieldPosition = 0;
|
|
mib->GreenFieldPosition = 0;
|
|
mib->BlueFieldPosition = 0;
|
|
mib->RsvdFieldPosition = 0;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* 39 - BYTE: direct color mode info
|
|
* Bits:
|
|
* 0 - Set if color ramp is programmable.
|
|
* 1 - Set if bytes in reserved field may be used by application.
|
|
*/
|
|
mib->DirectColorModeInfo = 0; /* not supported */
|
|
|
|
/* 40 - DWORD: physical address of linear video buffer */
|
|
mib->PhysBasePtr = 0; /* not supported */
|
|
|
|
/* 44 - DWORD: reserved, always zero */
|
|
mib->Reserved2 = 0;
|
|
|
|
/* 48 - WORD: reserved, always zero */
|
|
mib->Reserved3 = 0;
|
|
|
|
/* 50 - WORD: bytes per scan line in linear modes */
|
|
mib->LinBytesPerScanLine = mib->BytesPerScanLine;
|
|
|
|
/* 52 - BYTE: number of images (less one) for banked video modes */
|
|
mib->BnkNumberOfImagePages = 0; /* FIXME */
|
|
|
|
/* 53 - BYTE: number of images (less one) for linear video modes */
|
|
mib->LinNumberOfImagePages = mib->BnkNumberOfImagePages;
|
|
|
|
/* 54 - BYTE: red mask size (linear modes) */
|
|
mib->LinRedMaskSize = mib->RedMaskSize;
|
|
|
|
/* 55 - BYTE: red field position (linear modes) */
|
|
mib->LinRedFieldPosition = mib->RedFieldPosition;
|
|
|
|
/* 56 - BYTE: green mask size (linear modes) */
|
|
mib->LinGreenMaskSize = mib->GreenMaskSize;
|
|
|
|
/* 57 - BYTE: green field size (linear modes) */
|
|
mib->LinGreenFieldPosition = mib->GreenFieldPosition;
|
|
|
|
/* 58 - BYTE: blue mask size (linear modes) */
|
|
mib->LinBlueMaskSize = mib->BlueMaskSize;
|
|
|
|
/* 59 - BYTE: blue field position (linear modes) */
|
|
mib->LinBlueFieldPosition = mib->BlueFieldPosition;
|
|
|
|
/* 60 - BYTE: reserved mask size (linear modes) */
|
|
mib->LinRsvdMaskSize = mib->RsvdMaskSize;
|
|
|
|
/* 61 - BYTE: reserved mask position (linear modes) */
|
|
mib->LinRsvdFieldPosition = mib->RsvdFieldPosition;
|
|
|
|
/* 62 - DWORD: maximum pixel clock for graphics video mode, in Hz */
|
|
mib->MaxPixelClock = 0; /* FIXME */
|
|
|
|
/* 66 - BYTE[190]: reserved, set to zero */
|
|
memset( mib->Reserved4, 0, 190 );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_FillStateInformation
|
|
*
|
|
* Fill 64-byte buffer with VGA state and functionality information.
|
|
*/
|
|
static void INT10_FillStateInformation( BYTE *buffer, BIOSDATA *data )
|
|
{
|
|
INT10_HEAP *heap = INT10_GetHeap();
|
|
|
|
/* 00 - DWORD: address of static functionality table */
|
|
*(SEGPTR*)(buffer + 0) = MAKESEGPTR( heap->WineHeapSegment,
|
|
offsetof(INT10_HEAP,
|
|
StaticModeSupport) );
|
|
|
|
/* 04 - BYTE[30]: copy of BIOS data starting from 0x49 (VideoMode) */
|
|
memmove( buffer + 4, &data->VideoMode, 30 );
|
|
|
|
/* 34 - BYTE: number of rows - 1 */
|
|
buffer[34] = data->RowsOnScreenMinus1;
|
|
|
|
/* 35 - WORD: bytes/character */
|
|
*(WORD*)(buffer + 35) = data->BytesPerChar;
|
|
|
|
/* 37 - BYTE: display combination code of active display */
|
|
buffer[37] = INT10_DCC;
|
|
|
|
/* 38 - BYTE: DCC of alternate display */
|
|
buffer[38] = 0; /* no secondary display */
|
|
|
|
/* 39 - WORD: number of colors supported in current mode (0000h = mono) */
|
|
*(WORD*)(buffer + 39) = 16; /* FIXME */
|
|
|
|
/* 41 - BYTE: number of pages supported in current mode */
|
|
buffer[41] = 1; /* FIXME */
|
|
|
|
/*
|
|
* 42 - BYTE: number of scan lines active
|
|
* Values (hex):
|
|
* 00 = 200
|
|
* 01 = 350
|
|
* 02 = 400
|
|
* 03 = 480
|
|
*/
|
|
buffer[42] = 3; /* FIXME */
|
|
|
|
/* 43 - BYTE: primary character block */
|
|
buffer[43] = 0; /* FIXME */
|
|
|
|
/* 44 - BYTE: secondary character block */
|
|
buffer[44] = 0; /* FIXME */
|
|
|
|
/*
|
|
* 45 - BYTE: miscellaneous flags
|
|
* Bits:
|
|
* 0 - all modes on all displays on
|
|
* 1 - gray summing on
|
|
* 2 - monochrome display attached
|
|
* 3 - default palette loading disabled
|
|
* 4 - cursor emulation enabled
|
|
* 5 - 0 = intensity; 1 = blinking
|
|
* 6 - flat-panel display is active
|
|
* 7 - unused (0)
|
|
*/
|
|
/* FIXME: Correct value? */
|
|
buffer[45] =
|
|
(data->VGASettings & 0x0f) |
|
|
((data->ModeOptions & 1) << 4); /* cursor emulation */
|
|
|
|
/*
|
|
* 46 - BYTE: non-VGA mode support
|
|
* Bits:
|
|
* 0 - BIOS supports information return for adapter interface
|
|
* 1 - adapter interface driver required
|
|
* 2 - 16-bit VGA graphics present
|
|
* 3 - =1 MFI attributes enabled
|
|
* =0 VGA attributes enabled
|
|
* 4 - 132-column mode supported
|
|
* 5-7 - reserved
|
|
*/
|
|
buffer[46] = 0; /* FIXME: correct value? */
|
|
|
|
/* 47 - BYTE[2]: reserved, set to zero */
|
|
memset( buffer + 47, 0, 2 );
|
|
|
|
/*
|
|
* 49 - BYTE: video memory available
|
|
* Values (hex):
|
|
* 00 - 64K
|
|
* 01 - 128K
|
|
* 02 - 192K
|
|
* 03 - 256K
|
|
*/
|
|
buffer[49] = (data->ModeOptions & 0x60) >> 5; /* FIXME */
|
|
|
|
/*
|
|
* 50 - BYTE: save pointer state flags
|
|
* Bits:
|
|
* 0 - 512 character set active
|
|
* 1 - dynamic save area present
|
|
* 2 - alpha font override active
|
|
* 3 - graphics font override active
|
|
* 4 - palette override active
|
|
* 5 - DCC override active
|
|
* 6-7 - unused (0)
|
|
*/
|
|
buffer[50] = heap->StaticSavePointerFlags;
|
|
|
|
/*
|
|
* 51 - BYTE: display information and status
|
|
* Bits:
|
|
* 0 - flat-panel display attached
|
|
* 1 - flat-panel display active
|
|
* 2 - color display
|
|
* 3-6 - reserved
|
|
* 7 - 640x480 flat-panel can be used simultaneously with CRT
|
|
*/
|
|
buffer[51] = 4; /* FIXME: correct value? */
|
|
|
|
/* 52 - BYTE[12]: reserved, set to zero */
|
|
memset( buffer + 52, 0, 12 );
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_GetHeap
|
|
*/
|
|
static INT10_HEAP *INT10_GetHeap( void )
|
|
{
|
|
static INT10_HEAP *heap_pointer = 0;
|
|
|
|
if (!heap_pointer)
|
|
{
|
|
WORD segment;
|
|
int i;
|
|
|
|
heap_pointer = DOSVM_AllocDataUMB( sizeof(INT10_HEAP),
|
|
&segment,
|
|
0 );
|
|
|
|
for (i = 0; i < 7; i++)
|
|
heap_pointer->StaticModeSupport[i] = 0xff; /* FIXME */
|
|
|
|
heap_pointer->StaticScanlineSupport = 7; /* FIXME */
|
|
heap_pointer->StaticNumberCharBlocks = 0; /* FIXME */
|
|
heap_pointer->StaticActiveCharBlocks = 0; /* FIXME */
|
|
heap_pointer->StaticMiscFlags = 0x8ff; /* FIXME */
|
|
heap_pointer->StaticReserved1 = 0;
|
|
heap_pointer->StaticSavePointerFlags = 0x3f; /* FIXME */
|
|
heap_pointer->StaticReserved2 = 0;
|
|
|
|
for (i=0; TRUE; i++)
|
|
{
|
|
heap_pointer->VesaModeList[i] = VGA_modelist[i].Mode;
|
|
if (VGA_modelist[i].Mode == 0xffff)
|
|
break;
|
|
}
|
|
|
|
strcpy( heap_pointer->VesaOEMName, "WINE SVGA BOARD" );
|
|
strcpy( heap_pointer->VesaVendorName, "WINE" );
|
|
strcpy( heap_pointer->VesaProductName, "WINE SVGA" );
|
|
strcpy( heap_pointer->VesaProductRev, "2008" );
|
|
|
|
heap_pointer->VesaCurrentMode = 0; /* Initialized later. */
|
|
heap_pointer->WineHeapSegment = segment;
|
|
}
|
|
|
|
return heap_pointer;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_SetVideoMode
|
|
*
|
|
* Change current video mode to any VGA or VESA mode.
|
|
* Returns TRUE if mode is supported.
|
|
*
|
|
* Mode bitfields:
|
|
* 0-6: .. Mode number (combined with bit 8).
|
|
* 7: =0 Clear screen.
|
|
* =1 Preserve display memory on mode change (VGA modes).
|
|
* 8: =0 VGA mode.
|
|
* =1 VESA mode.
|
|
* 9: .. Reserved, must be zero.
|
|
* 10: .. Reserved, must be zero.
|
|
* 11: =0 Use default refresh rate.
|
|
* =1 Use user specified refresh rate.
|
|
* 12: .. Reserved, must be zero.
|
|
* 13: .. Reserved, must be zero.
|
|
* 14: =0 Use windowed frame buffer model.
|
|
* =1 Use linear frame buffer model.
|
|
* 15: =0 Clear screen.
|
|
* =1 Preserve display memory on mode change (VESA modes).
|
|
*/
|
|
static BOOL INT10_SetVideoMode( BIOSDATA *data, WORD mode )
|
|
{
|
|
const VGA_MODE *ptr = VGA_GetModeInfo( mode );
|
|
INT10_HEAP *heap = INT10_GetHeap();
|
|
BOOL clearScreen = TRUE;
|
|
|
|
if (!ptr)
|
|
return FALSE;
|
|
|
|
/*
|
|
* Linear framebuffer is not supported.
|
|
* FIXME - not sure this is valid since mode 19 is 256 color & linear
|
|
* of course only 1 window is addressable.
|
|
*/
|
|
if (mode & 0x4000)
|
|
return FALSE;
|
|
|
|
/*
|
|
* Check for VGA and VESA preserve video memory flag.
|
|
*/
|
|
if ((mode & 0x0080) || (mode & 0x8000))
|
|
clearScreen = FALSE;
|
|
|
|
/*
|
|
* Note that we do not mask out flags here on purpose.
|
|
*/
|
|
heap->VesaCurrentMode = mode;
|
|
if (mode <= 0xff)
|
|
data->VideoMode = mode;
|
|
else
|
|
data->VideoMode = 0;
|
|
|
|
if (ptr->ModeType == TEXT)
|
|
{
|
|
/* Text mode. */
|
|
TRACE( "Setting %s %dx%d text mode (screen %s)\n",
|
|
IS_VESA_MODE(mode) ? "VESA" : "VGA",
|
|
ptr->TextCols, ptr->TextRows,
|
|
clearScreen ? "cleared" : "preserved" );
|
|
|
|
/*
|
|
* FIXME: We should check here if alpha mode could be set.
|
|
*/
|
|
VGA_SetAlphaMode( ptr->TextCols, ptr->TextRows );
|
|
|
|
data->VideoColumns = ptr->TextCols;
|
|
data->RowsOnScreenMinus1 = ptr->TextRows - 1;
|
|
|
|
if (clearScreen)
|
|
{
|
|
VGA_ClearText( 0, 0, ptr->TextCols-1, ptr->TextRows-1, 0x07 );
|
|
INT10_SetCursorPos( data, 0, 0, 0 );
|
|
VGA_SetCursorPos( 0, 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Graphics mode. */
|
|
TRACE( "Setting %s %dx%dx%d graphics mode (screen %s)\n",
|
|
IS_VESA_MODE(mode) ? "VESA" : "VGA",
|
|
ptr->Width, ptr->Height, ptr->Depth,
|
|
clearScreen ? "cleared" : "preserved" );
|
|
|
|
if ( VGA_SetMode(mode) )
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_GetCursorPos
|
|
*/
|
|
static void INT10_GetCursorPos(BIOSDATA*data,unsigned page,unsigned*X,unsigned*Y)
|
|
{
|
|
*X = data->VideoCursorPos[page*2]; /* column */
|
|
*Y = data->VideoCursorPos[page*2+1]; /* row */
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_SetCursorPos
|
|
*/
|
|
static void INT10_SetCursorPos(BIOSDATA*data,unsigned page,unsigned X,unsigned Y)
|
|
{
|
|
data->VideoCursorPos[page*2] = X;
|
|
data->VideoCursorPos[page*2+1] = Y;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_InitializeVideoMode
|
|
*
|
|
* The first time this function is called VGA emulation is set to the
|
|
* default text mode.
|
|
*/
|
|
static void INT10_InitializeVideoMode( BIOSDATA *data )
|
|
{
|
|
static BOOL already_initialized = FALSE;
|
|
unsigned width;
|
|
unsigned height;
|
|
|
|
if(already_initialized)
|
|
return;
|
|
already_initialized = TRUE;
|
|
|
|
VGA_InitAlphaMode(&width, &height);
|
|
|
|
/*
|
|
* FIXME: Add more mappings between initial size and
|
|
* text modes.
|
|
*/
|
|
if (width >= 80 && height >= 25)
|
|
INT10_SetVideoMode( data, 0x03 );
|
|
else
|
|
INT10_SetVideoMode( data, 0x01 );
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* INT10_HandleVESA
|
|
*
|
|
* Handler for VESA functions (int10 function 0x4f).
|
|
*/
|
|
static void INT10_HandleVESA( CONTEXT *context )
|
|
{
|
|
BIOSDATA *data = DOSVM_BiosData();
|
|
|
|
switch(AL_reg(context)) {
|
|
|
|
case 0x00: /* RETURN CONTROLLER INFORMATION */
|
|
TRACE( "VESA RETURN CONTROLLER INFORMATION\n" );
|
|
{
|
|
BYTE *ptr = CTX_SEG_OFF_TO_LIN(context,
|
|
context->SegEs,
|
|
context->Edi);
|
|
INT10_FillControllerInformation( ptr );
|
|
SET_AL( context, 0x4f );
|
|
SET_AH( context, 0x00 ); /* 0x00 = successful 0x01 = failed */
|
|
}
|
|
break;
|
|
|
|
case 0x01: /* RETURN MODE INFORMATION */
|
|
TRACE( "VESA RETURN MODE INFORMATION %04x\n", CX_reg(context) );
|
|
{
|
|
struct _ModeInfoBlock *ptr = CTX_SEG_OFF_TO_LIN(context,
|
|
context->SegEs,
|
|
context->Edi);
|
|
SET_AL( context, 0x4f );
|
|
if (INT10_FillModeInformation( ptr, CX_reg(context) ))
|
|
SET_AH( context, 0x00 ); /* status: success */
|
|
else
|
|
SET_AH( context, 0x01 ); /* status: failed */
|
|
}
|
|
break;
|
|
|
|
case 0x02: /* SET SuperVGA VIDEO MODE */
|
|
TRACE( "Set VESA video mode %04x\n", BX_reg(context) );
|
|
SET_AL( context, 0x4f ); /* function supported */
|
|
if (INT10_SetVideoMode( data, BX_reg(context) ))
|
|
SET_AH( context, 0x00 ); /* success */
|
|
else
|
|
SET_AH( context, 0x01 ); /* failed */
|
|
break;
|
|
|
|
case 0x03: /* VESA SuperVGA BIOS - GET CURRENT VIDEO MODE */
|
|
SET_AL( context, 0x4f );
|
|
SET_AH( context, 0x00 );
|
|
SET_BX( context, INT10_GetHeap()->VesaCurrentMode );
|
|
break;
|
|
|
|
case 0x04: /* VESA SuperVGA BIOS - SAVE/RESTORE SuperVGA VIDEO STATE */
|
|
ERR("VESA SAVE/RESTORE Video State - Not Implemented\n");
|
|
/* AL_reg(context) = 0x4f; = supported so not set since not implemented */
|
|
/* maybe we should do this instead ? */
|
|
/* AH_reg(context = 0x01; not implemented so just fail */
|
|
break;
|
|
|
|
case 0x05: /* VESA SuperVGA BIOS - CPU VIDEO MEMORY CONTROL */
|
|
/*
|
|
* This subfunction supports only Window A (BL_reg == 0) and
|
|
* it assumes that window granularity is 64k.
|
|
*/
|
|
switch(BH_reg(context)) {
|
|
case 0x00: /* select video memory window */
|
|
SET_AL( context, 0x4f ); /* function supported */
|
|
if(BL_reg(context) == 0) {
|
|
VGA_SetWindowStart(DX_reg(context) * 64 * 1024);
|
|
SET_AH( context, 0x00 ); /* status: successful */
|
|
} else
|
|
SET_AH( context, 0x01 ); /* status: failed */
|
|
break;
|
|
case 0x01: /* get video memory window */
|
|
SET_AL( context, 0x4f ); /* function supported */
|
|
if(BL_reg(context) == 0) {
|
|
SET_DX( context, VGA_GetWindowStart() / 64 / 1024 );
|
|
SET_AH( context, 0x00 ); /* status: successful */
|
|
} else
|
|
SET_AH( context, 0x01 ); /* status: failed */
|
|
break;
|
|
default:
|
|
INT_BARF( context, 0x10 );
|
|
}
|
|
break;
|
|
|
|
case 0x06: /* VESA GET/SET LOGICAL SCAN LINE LENGTH */
|
|
ERR("VESA GET/SET LOGICAL SCAN LINE LENGTH - Not Implemented\n");
|
|
/* AL_reg(context) = 0x4f; = supported so not set since not implemented */
|
|
/* maybe we should do this instead ? */
|
|
/* AH_reg(context = 0x001; not implemented so just fail */
|
|
break;
|
|
|
|
case 0x07: /* GET/SET DISPLAY START */
|
|
ERR("VESA GET/SET DISPLAY START - Not Implemented\n");
|
|
/* AL_reg(context) = 0x4f; = supported so not set since not implemented */
|
|
/* maybe we should do this instead ? */
|
|
/* AH_reg(context = 0x001; not implemented so just fail */
|
|
break;
|
|
|
|
case 0x08: /* GET/SET DAC PALETTE CONTROL */
|
|
ERR("VESA GET/SET DAC PALETTE CONTROL- Not Implemented\n");
|
|
/* AL_reg(context) = 0x4f; = supported so not set since not implemented */
|
|
/* maybe we should do this instead ? */
|
|
/* AH_reg(context = 0x001; not implemented so just fail */
|
|
break;
|
|
|
|
case 0x09: /* SET PALETTE ENTRIES */
|
|
FIXME("VESA Set palette entries - not implemented\n");
|
|
break;
|
|
|
|
case 0x0a: /* GET PROTECTED-MODE CODE */
|
|
FIXME("VESA Get protected-mode code - not implemented\n");
|
|
break;
|
|
|
|
case 0x10: /* Display Power Management Extensions */
|
|
FIXME("VESA Display Power Management Extensions - not implemented\n");
|
|
break;
|
|
|
|
case 0xef: /* get video mode for hercules-compatibles */
|
|
/* There's no reason to really support this */
|
|
/* is there?....................(A.C.) */
|
|
TRACE("Just report the video not hercules compatible\n");
|
|
SET_DX( context, 0xffff );
|
|
break;
|
|
|
|
case 0xff: /* Turn VESA ON/OFF */
|
|
/* I don't know what to do */
|
|
break;
|
|
|
|
default:
|
|
FIXME("VESA Function (0x%x) - Not Supported\n", AH_reg(context));
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* DOSVM_Int10Handler
|
|
*
|
|
* Handler for int 10h (video).
|
|
*
|
|
* NOTE:
|
|
* Most INT 10 functions for text-mode, CGA, EGA, and VGA cards
|
|
* are present in this list. (SVGA and XGA are not) That is not
|
|
* to say that all these functions should be supported, but if
|
|
* anyone is brain-damaged enough to want to emulate one of these
|
|
* beasts then this should get you started.
|
|
*
|
|
* NOTE:
|
|
* Several common graphical extensions used by Microsoft hook
|
|
* off of here. I have *not* added them to this list (yet). They
|
|
* include:
|
|
*
|
|
* MSHERC.COM - More functionality for Hercules cards.
|
|
* EGA.SYS (also MOUSE.COM) - More for EGA cards.
|
|
*
|
|
* Yes, MS also added this support into their mouse driver. Don't
|
|
* ask me, I don't work for them.
|
|
*
|
|
* Joseph Pranevich - 9/98
|
|
*
|
|
* Jess Haas 2/99
|
|
* Added support for Vesa. It is not complete but is a start.
|
|
* NOTE: Im not sure if I did all this right or if any of it works.
|
|
* Currently I don't have a program that uses Vesa that actually gets far
|
|
* enough without crashing to do vesa stuff.
|
|
*
|
|
* Added additional vga graphic support - 3/99
|
|
*/
|
|
void WINAPI DOSVM_Int10Handler( CONTEXT *context )
|
|
{
|
|
BIOSDATA *data = DOSVM_BiosData();
|
|
|
|
INT10_InitializeVideoMode( data );
|
|
|
|
switch(AH_reg(context)) {
|
|
|
|
case 0x00: /* SET VIDEO MODE */
|
|
TRACE( "Set VGA video mode %02x\n", AL_reg(context) );
|
|
if (!INT10_SetVideoMode( data, AL_reg(context) ))
|
|
FIXME( "Unsupported VGA video mode requested: %#x\n",
|
|
AL_reg(context) );
|
|
break;
|
|
|
|
case 0x01: /* SET CURSOR SHAPE */
|
|
TRACE("Set Cursor Shape start %d end %d options %d\n",
|
|
CH_reg(context) & 0x1f,
|
|
CL_reg(context) & 0x1f,
|
|
CH_reg(context) & 0xe0);
|
|
data->VideoCursorType = CX_reg(context); /* direct copy */
|
|
VGA_SetCursorShape(CH_reg(context), CL_reg(context));
|
|
break;
|
|
|
|
case 0x02: /* SET CURSOR POSITION */
|
|
/* BH = Page Number */ /* Not supported */
|
|
/* DH = Row */ /* 0 is left */
|
|
/* DL = Column */ /* 0 is top */
|
|
INT10_SetCursorPos(data,BH_reg(context),DL_reg(context),DH_reg(context));
|
|
if (BH_reg(context))
|
|
{
|
|
FIXME("Set Cursor Position: Cannot set to page %d\n",
|
|
BH_reg(context));
|
|
}
|
|
else
|
|
{
|
|
VGA_SetCursorPos(DL_reg(context), DH_reg(context));
|
|
TRACE("Set Cursor Position: %d/%d\n", DL_reg(context),
|
|
DH_reg(context));
|
|
}
|
|
break;
|
|
|
|
case 0x03: /* GET CURSOR POSITION AND SIZE */
|
|
{
|
|
unsigned row, col;
|
|
|
|
TRACE("Get cursor position and size (page %d)\n", BH_reg(context));
|
|
SET_CX( context, data->VideoCursorType );
|
|
INT10_GetCursorPos(data,BH_reg(context),&col,&row);
|
|
SET_DH( context, row );
|
|
SET_DL( context, col );
|
|
TRACE("Cursor Position: %d/%d\n", DL_reg(context), DH_reg(context));
|
|
}
|
|
break;
|
|
|
|
case 0x04: /* READ LIGHT PEN POSITION */
|
|
FIXME("Read Light Pen Position - Not Supported\n");
|
|
SET_AH( context, 0x00 ); /* Not down */
|
|
break;
|
|
|
|
case 0x05: /* SELECT ACTIVE DISPLAY PAGE */
|
|
FIXME("Select Active Display Page (%d) - Not Supported\n", AL_reg(context));
|
|
data->VideoCurPage = AL_reg(context);
|
|
break;
|
|
|
|
case 0x06: /* SCROLL UP WINDOW */
|
|
/* AL = Lines to scroll */
|
|
/* BH = Attribute */
|
|
/* CH,CL = row, col upper-left */
|
|
/* DH,DL = row, col lower-right */
|
|
TRACE("Scroll Up Window %d\n", AL_reg(context));
|
|
|
|
if (AL_reg(context) == 0)
|
|
VGA_ClearText( CH_reg(context), CL_reg(context),
|
|
DH_reg(context), DL_reg(context),
|
|
BH_reg(context) );
|
|
else
|
|
VGA_ScrollUpText( CH_reg(context), CL_reg(context),
|
|
DH_reg(context), DL_reg(context),
|
|
AL_reg(context), BH_reg(context) );
|
|
break;
|
|
|
|
case 0x07: /* SCROLL DOWN WINDOW */
|
|
/* AL = Lines to scroll */
|
|
/* BH = Attribute */
|
|
/* CH,CL = row, col upper-left */
|
|
/* DH,DL = row, col lower-right */
|
|
TRACE("Scroll Down Window %d\n", AL_reg(context));
|
|
|
|
if (AL_reg(context) == 0)
|
|
VGA_ClearText( CH_reg(context), CL_reg(context),
|
|
DH_reg(context), DL_reg(context),
|
|
BH_reg(context) );
|
|
else
|
|
VGA_ScrollDownText( CH_reg(context), CL_reg(context),
|
|
DH_reg(context), DL_reg(context),
|
|
AL_reg(context), BH_reg(context) );
|
|
break;
|
|
|
|
case 0x08: /* READ CHARACTER AND ATTRIBUTE AT CURSOR POSITION */
|
|
{
|
|
if (BH_reg(context)) /* Write to different page */
|
|
{
|
|
FIXME("Read character and attribute at cursor position -"
|
|
" Can't read from non-0 page\n");
|
|
SET_AL( context, ' ' ); /* That page is blank */
|
|
SET_AH( context, 7 );
|
|
}
|
|
else
|
|
{
|
|
BYTE ascii, attr;
|
|
TRACE("Read Character and Attribute at Cursor Position\n");
|
|
VGA_GetCharacterAtCursor(&ascii, &attr);
|
|
SET_AL( context, ascii );
|
|
SET_AH( context, attr );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x09: /* WRITE CHARACTER AND ATTRIBUTE AT CURSOR POSITION */
|
|
case 0x0a: /* WRITE CHARACTER ONLY AT CURSOR POSITION */
|
|
/* AL = Character to display. */
|
|
/* BH = Page Number */ /* We can't write to non-0 pages, yet. */
|
|
/* BL = Attribute / Color */
|
|
/* CX = Times to Write Char */
|
|
/* Note here that the cursor is not advanced. */
|
|
{
|
|
unsigned row, col;
|
|
|
|
INT10_GetCursorPos(data,BH_reg(context),&col,&row);
|
|
VGA_WriteChars(col, row,
|
|
AL_reg(context),
|
|
(AH_reg(context) == 0x09) ? BL_reg(context) : -1,
|
|
CX_reg(context));
|
|
if (CX_reg(context) > 1)
|
|
TRACE("Write Character%s at Cursor Position (Rep. %d): %c\n",
|
|
(AH_reg(context) == 0x09) ? " and Attribute" : "",
|
|
CX_reg(context), AL_reg(context));
|
|
else
|
|
TRACE("Write Character%s at Cursor Position: %c\n",
|
|
(AH_reg(context) == 0x09) ? " and Attribute" : "",
|
|
AL_reg(context));
|
|
}
|
|
break;
|
|
|
|
case 0x0b:
|
|
switch (BH_reg(context)) {
|
|
case 0x00: /* SET BACKGROUND/BORDER COLOR */
|
|
/* In text modes, this sets only the border... */
|
|
/* According to the interrupt list and one of my books. */
|
|
/* Funny though that Beyond Zork seems to indicate that it
|
|
also sets up the default background attributes for clears
|
|
and scrolls... */
|
|
/* Bear in mind here that we do not want to change,
|
|
apparently, the foreground or attribute of the background
|
|
with this call, so we should check first to see what the
|
|
foreground already is... FIXME */
|
|
|
|
/* For CGA modes, background color change is the same as writing
|
|
to I/O address 0x3d9 bit 4 */
|
|
if(data->VideoMode >= 4 && data->VideoMode <= 6)
|
|
{
|
|
VGA_SetBright((BL_reg(context) & 0x10) != 0);
|
|
VGA_UpdatePalette();
|
|
}
|
|
else FIXME("Set Background/Border Color: %d/%d\n",
|
|
BH_reg(context), BL_reg(context));
|
|
break;
|
|
case 0x01: /* SET PALETTE */
|
|
|
|
/* For CGA modes, palette color change is the same as writing
|
|
to I/O address 0x3d9 bit 5 */
|
|
if(data->VideoMode >= 4 && data->VideoMode <= 6)
|
|
{
|
|
VGA_SetPaletteIndex(BL_reg(context) & 1);
|
|
VGA_UpdatePalette();
|
|
}
|
|
else FIXME("Set Palette - Not Supported: %02X\n", BL_reg(context));
|
|
break;
|
|
default:
|
|
FIXME("INT 10 AH = 0x0b BH = 0x%x - Unknown\n",
|
|
BH_reg(context));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 0x0c: /* WRITE GRAPHICS PIXEL */
|
|
|
|
/* Only supported in CGA mode for now */
|
|
if(data->VideoMode >= 4 && data->VideoMode <= 6)
|
|
{
|
|
VGA_WritePixel(AL_reg(context), BH_reg(context), CX_reg(context), DX_reg(context));
|
|
}
|
|
else FIXME("Write pixel not implemented for current mode\n");
|
|
break;
|
|
|
|
case 0x0d: /* READ GRAPHICS PIXEL */
|
|
/* Not in graphics mode, can ignore w/o error */
|
|
FIXME("Read Graphics Pixel - Not Supported\n");
|
|
break;
|
|
|
|
case 0x0e: /* TELETYPE OUTPUT */
|
|
TRACE("Teletype Output\n");
|
|
DOSVM_PutChar(AL_reg(context));
|
|
break;
|
|
|
|
case 0x0f: /* GET CURRENT VIDEO MODE */
|
|
TRACE("Get current video mode: -> mode %d, columns %d\n", data->VideoMode, data->VideoColumns);
|
|
/* Note: This should not be a constant value. */
|
|
SET_AL( context, data->VideoMode );
|
|
SET_AH( context, data->VideoColumns );
|
|
SET_BH( context, 0 ); /* Display page 0 */
|
|
break;
|
|
|
|
case 0x10:
|
|
switch (AL_reg(context)) {
|
|
case 0x00: /* SET SINGLE PALETTE REGISTER - A.C. */
|
|
TRACE("Set Single Palette Register - Reg 0x0%x Value 0x0%x\n",
|
|
BL_reg(context),BH_reg(context));
|
|
/* BH is the value BL is the register */
|
|
VGA_SetColor16((int)BL_reg(context),(int)BH_reg(context));
|
|
break;
|
|
case 0x01: /* SET BORDER (OVERSCAN) */
|
|
/* Text terminals have no overscan */
|
|
/* I'm setting it anyway. - A.C. */
|
|
TRACE("Set Border (Overscan) - Ignored but set.\n");
|
|
VGA_SetColor16(16,(int)BH_reg(context));
|
|
break;
|
|
case 0x02: /* SET ALL PALETTE REGISTERS - A.C.*/
|
|
TRACE("Set all palette registers\n");
|
|
/* ES:DX points to a 17 byte table of colors */
|
|
/* No return data listed */
|
|
/* I'll have to update my table and the default palette */
|
|
VGA_Set16Palette(CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edx));
|
|
break;
|
|
case 0x03: /* TOGGLE INTENSITY/BLINKING BIT */
|
|
FIXME("Toggle Intensity/Blinking Bit - Not Supported\n");
|
|
break;
|
|
case 0x07: /* GET INDIVIDUAL PALETTE REGISTER - A.C.*/
|
|
TRACE("Get Individual Palette Register 0x0%x\n",BL_reg(context));
|
|
/* BL is register to read [ 0-15 ] BH is return value */
|
|
SET_BH( context, VGA_GetColor16((int)BL_reg(context)) );
|
|
break;
|
|
case 0x08: /* READ OVERSCAN (BORDER COLOR) REGISTER - A.C. */
|
|
TRACE("Read Overscan (Border Color) Register\n");
|
|
SET_BH( context, VGA_GetColor16(16) );
|
|
break;
|
|
case 0x09: /* READ ALL PALETTE REGISTERS AND OVERSCAN REGISTER - A.C.*/
|
|
TRACE("Read All Palette Registers and Overscan Register\n");
|
|
/* ES:DX points to a 17 byte table where the results */
|
|
/* of this call should be stored. */
|
|
VGA_Get16Palette(CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edx));
|
|
break;
|
|
case 0x10: /* SET INDIVIDUAL DAC REGISTER */
|
|
{
|
|
PALETTEENTRY paldat;
|
|
|
|
TRACE("Set Individual DAC register\n");
|
|
paldat.peRed = DH_reg(context);
|
|
paldat.peGreen = CH_reg(context);
|
|
paldat.peBlue = CL_reg(context);
|
|
paldat.peFlags = 0;
|
|
VGA_SetPalette(&paldat,BX_reg(context)&0xFF,1);
|
|
}
|
|
break;
|
|
case 0x12: /* SET BLOCK OF DAC REGISTERS */
|
|
{
|
|
int i;
|
|
PALETTEENTRY paldat;
|
|
BYTE *pt;
|
|
|
|
TRACE("Set Block of DAC registers\n");
|
|
pt = CTX_SEG_OFF_TO_LIN(context,context->SegEs,context->Edx);
|
|
for (i=0;i<CX_reg(context);i++)
|
|
{
|
|
paldat.peRed = (*(pt+i*3+0)) << 2;
|
|
paldat.peGreen = (*(pt+i*3+1)) << 2;
|
|
paldat.peBlue = (*(pt+i*3+2)) << 2;
|
|
paldat.peFlags = 0;
|
|
VGA_SetPalette(&paldat,(BX_reg(context)+i)&0xFF,1);
|
|
}
|
|
}
|
|
break;
|
|
case 0x13: /* SELECT VIDEO DAC COLOR PAGE */
|
|
FIXME("Select video DAC color page - Not Supported\n");
|
|
break;
|
|
case 0x15: /* READ INDIVIDUAL DAC REGISTER */
|
|
FIXME("Read individual DAC register - Not Supported\n");
|
|
break;
|
|
case 0x17: /* READ BLOCK OF DAC REGISTERS */
|
|
FIXME("Read block of DAC registers - Not Supported\n");
|
|
break;
|
|
case 0x18: /* SET PEL MASK */
|
|
FIXME("Set PEL mask - Not Supported\n");
|
|
break;
|
|
case 0x19: /* READ PEL MASK */
|
|
FIXME("Read PEL mask - Not Supported\n");
|
|
break;
|
|
case 0x1a: /* GET VIDEO DAC COLOR PAGE STATE */
|
|
FIXME("Get video DAC color page state - Not Supported\n");
|
|
break;
|
|
case 0x1b: /* PERFORM GRAY-SCALE SUMMING */
|
|
FIXME("Perform Gray-scale summing - Not Supported\n");
|
|
break;
|
|
default:
|
|
FIXME("INT 10 AH = 0x10 AL = 0x%x - Unknown\n",
|
|
AL_reg(context));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 0x11: /* TEXT MODE CHARGEN */
|
|
/* Note that second subfunction is *almost* identical. */
|
|
/* See INTERRUPT.A for details. */
|
|
switch (AL_reg(context)) {
|
|
case 0x00: /* LOAD USER SPECIFIED PATTERNS */
|
|
case 0x10:
|
|
FIXME("Load User Specified Patterns - Not Supported\n");
|
|
break;
|
|
case 0x01: /* LOAD ROM MONOCHROME PATTERNS */
|
|
case 0x11:
|
|
FIXME("Load ROM Monochrome Patterns - Not Supported\n");
|
|
break;
|
|
case 0x02: /* LOAD ROM 8x8 DOUBLE-DOT PATTERNS */
|
|
case 0x12:
|
|
FIXME(
|
|
"Load ROM 8x8 Double Dot Patterns - Not Supported\n");
|
|
break;
|
|
case 0x03: /* SET BLOCK SPECIFIER */
|
|
FIXME("Set Block Specifier - Not Supported\n");
|
|
break;
|
|
case 0x04: /* LOAD ROM 8x16 CHARACTER SET */
|
|
case 0x14:
|
|
FIXME("Load ROM 8x16 Character Set - Not Supported\n");
|
|
break;
|
|
case 0x20: /* SET USER 8x16 GRAPHICS CHARS */
|
|
FIXME("Set User 8x16 Graphics Chars - Not Supported\n");
|
|
break;
|
|
case 0x21: /* SET USER GRAPICS CHARACTERS */
|
|
FIXME("Set User Graphics Characters - Not Supported\n");
|
|
break;
|
|
case 0x22: /* SET ROM 8x14 GRAPHICS CHARS */
|
|
FIXME("Set ROM 8x14 Graphics Chars - Not Supported\n");
|
|
break;
|
|
case 0x23: /* SET ROM 8x8 DBL DOT CHARS */
|
|
FIXME(
|
|
"Set ROM 8x8 Dbl Dot Chars (Graphics) - Not Supported\n");
|
|
break;
|
|
case 0x24: /* LOAD 8x16 GRAPHIC CHARS */
|
|
FIXME("Load 8x16 Graphic Chars - Not Supported\n");
|
|
break;
|
|
case 0x30: /* GET FONT INFORMATION */
|
|
FIXME("Get Font Information - Not Supported\n");
|
|
break;
|
|
default:
|
|
FIXME("INT 10 AH = 0x11 AL = 0x%x - Unknown\n",
|
|
AL_reg(context));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 0x12: /* ALTERNATE FUNCTION SELECT */
|
|
switch (BL_reg(context)) {
|
|
case 0x10: /* GET EGA INFO */
|
|
TRACE("EGA info requested\n");
|
|
SET_BH( context, 0x00 ); /* Color screen */
|
|
SET_BL( context, data->ModeOptions >> 5 ); /* EGA memory size */
|
|
SET_CX( context, data->FeatureBitsSwitches );
|
|
break;
|
|
case 0x20: /* ALTERNATE PRTSC */
|
|
FIXME("Install Alternate Print Screen - Not Supported\n");
|
|
break;
|
|
case 0x30: /* SELECT VERTICAL RESOLUTION */
|
|
FIXME("Select vertical resolution - not supported\n");
|
|
break;
|
|
case 0x31: /* ENABLE/DISABLE DEFAULT PALETTE LOADING */
|
|
FIXME("Default palette loading - not supported\n");
|
|
data->VGASettings =
|
|
(data->VGASettings & 0xf7) |
|
|
((AL_reg(context) == 1) << 3);
|
|
break;
|
|
case 0x32: /* ENABLE/DISABLE VIDEO ADDRESSING */
|
|
FIXME("Video Addressing - Not Supported\n");
|
|
break;
|
|
case 0x33: /* ENABLE/DISABLE GRAY SCALE SUMMING */
|
|
FIXME("Gray Scale Summing - Not Supported\n");
|
|
break;
|
|
case 0x34: /* ENABLE/DISABLE CURSOR EMULATION */
|
|
TRACE("Set cursor emulation to %d\n", AL_reg(context));
|
|
data->ModeOptions =
|
|
(data->ModeOptions & 0xfe)|(AL_reg(context) == 1);
|
|
break;
|
|
case 0x36: /* VIDEO ADDRESS CONTROL */
|
|
FIXME("Video Address Control - Not Supported\n");
|
|
break;
|
|
default:
|
|
FIXME("INT 10 AH = 0x11 AL = 0x%x - Unknown\n",
|
|
AL_reg(context));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 0x13: /* WRITE STRING */
|
|
/* This one does not imply that string be at cursor. */
|
|
FIXME("Write String - Not Supported\n");
|
|
break;
|
|
|
|
case 0x1a:
|
|
switch (AL_reg(context)) {
|
|
case 0x00: /* GET DISPLAY COMBINATION CODE */
|
|
TRACE("Get Display Combination Code\n");
|
|
SET_AL( context, 0x1a ); /* Function supported */
|
|
SET_BL( context, INT10_DCC ); /* Active display */
|
|
SET_BH( context, 0x00 ); /* No alternate display */
|
|
break;
|
|
case 0x01: /* SET DISPLAY COMBINATION CODE */
|
|
FIXME("Set Display Combination Code - Not Supported\n");
|
|
break;
|
|
default:
|
|
FIXME("INT 10 AH = 0x1a AL = 0x%x - Unknown\n",
|
|
AL_reg(context));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 0x1b: /* FUNCTIONALITY/STATE INFORMATION */
|
|
TRACE("Get functionality/state information\n");
|
|
if (BX_reg(context) == 0x0000)
|
|
{
|
|
BYTE *ptr = CTX_SEG_OFF_TO_LIN(context,
|
|
context->SegEs,
|
|
context->Edi);
|
|
SET_AL( context, 0x1b ); /* Function is supported */
|
|
INT10_FillStateInformation( ptr, data );
|
|
}
|
|
break;
|
|
|
|
case 0x1c: /* SAVE/RESTORE VIDEO STATE */
|
|
FIXME("Save/Restore Video State - Not Supported\n");
|
|
break;
|
|
|
|
case 0xef: /* get video mode for hercules-compatibles */
|
|
/* There's no reason to really support this */
|
|
/* is there?....................(A.C.) */
|
|
TRACE("Just report the video not hercules compatible\n");
|
|
SET_DX( context, 0xffff );
|
|
break;
|
|
|
|
case 0x4f: /* VESA */
|
|
INT10_HandleVESA(context);
|
|
break;
|
|
|
|
case 0xfe: /* GET SHADOW BUFFER */
|
|
TRACE( "GET SHADOW BUFFER %x:%x - ignored\n",
|
|
context->SegEs, DI_reg(context) );
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unknown - 0x%x\n", AH_reg(context));
|
|
INT_BARF( context, 0x10 );
|
|
}
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* DOSVM_PutChar
|
|
*
|
|
* Write single character to VGA console at the current
|
|
* cursor position and updates the BIOS cursor position.
|
|
*/
|
|
void DOSVM_PutChar( BYTE ascii )
|
|
{
|
|
BIOSDATA *data = DOSVM_BiosData();
|
|
unsigned xpos, ypos;
|
|
|
|
TRACE("char: 0x%02x(%c)\n", ascii, ascii);
|
|
|
|
INT10_InitializeVideoMode( data );
|
|
|
|
VGA_PutChar( ascii );
|
|
VGA_GetCursorPos( &xpos, &ypos );
|
|
INT10_SetCursorPos( data, 0, xpos, ypos );
|
|
}
|