Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-04 12:39:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Bootvid rewrite by Filip Navara (with some fixes by myself)

Browse source 
- HAL DMA enhancements by Filip Navara.
- CSRSS Console enhancements by Filip Navara.
- Win32k Primitive Queue/Input/Painting/Focus enhancements by Filip Navara.
- Other misc win32k/CSR bug fixes by Filip Navara.
- The new bootvid code has some bugs, but try out a GUI Boot!

svn path=/trunk/; revision=24464
This commit is contained in:
Alex Ionescu 2006-10-09 04:00:34 +00:00
parent 3012ee8072
commit 6951a4887c
42 changed files with 1886 additions and 1963 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
reactos/base/setup/usetup/bootsup.c
View file

@ -140,21 +140,21 @@ CreateCommonFreeLoaderSections(PINICACHE IniCache)
NULL,
INSERT_LAST,
L"MenuTextColor",
L"White");
L"Gray");
/* MenuColor=Blue */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"MenuColor",
L"Blue");
L"Black");
/* TextColor=Yellow */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"TextColor",
L"Yellow");
L"Gray");
/* SelectedTextColor=Black */
IniCacheInsertKey(IniSection,
@ -169,6 +169,41 @@ CreateCommonFreeLoaderSections(PINICACHE IniCache)
INSERT_LAST,
L"SelectedColor",
L"Gray");
/* SelectedColor=Gray */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"ShowTime",
L"No");
/* SelectedColor=Gray */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"MenuBox",
L"No");
/* SelectedColor=Gray */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"CenterMenu",
L"No");
/* SelectedColor=Gray */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"MinimalUI",
L"Yes");
/* SelectedColor=Gray */
IniCacheInsertKey(IniSection,
NULL,
INSERT_LAST,
L"TimeText",
L"Seconds until highlighted choice will be started automatically: ");
}

1
reactos/boot/bootdata/txtsetup.sif
View file

@ -16,6 +16,7 @@ Signature = "$ReactOS$"
atapi.sys = 3
buslogic.sys = 3
blue.sys = 3
bootvid.sys = 3
c_437.nls = 2
c_1252.nls = 2
cdfs.sys = 3

180
reactos/drivers/base/blue/blue.c
View file

@ -18,6 +18,7 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES;
#include <wincon.h>
#include <blue/ntddblue.h>
#include <ndk/inbvfuncs.h>
#define NDEBUG
#include <debug.h>
@ -52,6 +53,18 @@ HalQueryDisplayOwnership(
#define TAB_WIDTH 8
#define MISC (PUCHAR)0x3c2
#define SEQ (PUCHAR)0x3c4
#define SEQDATA (PUCHAR)0x3c5
#define CRTC (PUCHAR)0x3d4
#define CRTCDATA (PUCHAR)0x3d5
#define GRAPHICS (PUCHAR)0x3ce
#define GRAPHICSDATA (PUCHAR)0x3cf
#define ATTRIB (PUCHAR)0x3c0
#define STATUS (PUCHAR)0x3da
#define PELMASK (PUCHAR)0x3c6
#define PELINDEX (PUCHAR)0x3c8
#define PELDATA (PUCHAR)0x3c9
/* NOTES ******************************************************************/
/*
@ -73,26 +86,130 @@ typedef struct _DEVICE_EXTENSION
USHORT Columns; /* Number of columns */
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
typedef struct _VGA_REGISTERS
{
UCHAR CRT[24];
UCHAR Attribute[21];
UCHAR Graphics[9];
UCHAR Sequencer[5];
UCHAR Misc;
} VGA_REGISTERS, *PVGA_REGISTERS;
static const VGA_REGISTERS VidpMode3Regs =
{
/* CRT Controller Registers */
{0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 0x47, 0x1E, 0x00,
0x00, 0x00, 0x05, 0xF0, 0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3},
/* Attribute Controller Registers */
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x00, 0x0F, 0x08, 0x00},
/* Graphics Controller Registers */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x00, 0xFF},
/* Sequencer Registers */
{0x03, 0x00, 0x03, 0x00, 0x02},
/* Misc Output Register */
0xE3
};
static const UCHAR DefaultPalette[] =
{
0, 0, 0,
0, 0, 0xC0,
0, 0xC0, 0,
0, 0xC0, 0xC0,
0xC0, 0, 0,
0xC0, 0, 0xC0,
0xC0, 0xC0, 0,
0xC0, 0xC0, 0xC0,
0x80, 0x80, 0x80,
0, 0, 0xFF,
0, 0xFF, 0,
0, 0xFF, 0xFF,
0xFF, 0, 0,
0xFF, 0, 0xFF,
0xFF, 0xFF, 0,
0xFF, 0xFF, 0xFF
};
/* FUNCTIONS **************************************************************/
NTSTATUS STDCALL
DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
static NTSTATUS STDCALL
ScrCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
static VOID FASTCALL
ScrSetRegisters(const VGA_REGISTERS *Registers)
{
UINT i;
/* Update misc output register */
WRITE_PORT_UCHAR(MISC, Registers->Misc);
/* Synchronous reset on */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x01);
/* Write sequencer registers */
for (i = 1; i < sizeof(Registers->Sequencer); i++)
{
WRITE_PORT_UCHAR(SEQ, i);
WRITE_PORT_UCHAR(SEQDATA, Registers->Sequencer[i]);
}
/* Synchronous reset off */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x03);
/* Deprotect CRT registers 0-7 */
WRITE_PORT_UCHAR(CRTC, 0x11);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[0x11] & 0x7f);
/* Write CRT registers */
for (i = 0; i < sizeof(Registers->CRT); i++)
{
WRITE_PORT_UCHAR(CRTC, i);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[i]);
}
/* Write graphics controller registers */
for (i = 0; i < sizeof(Registers->Graphics); i++)
{
WRITE_PORT_UCHAR(GRAPHICS, i);
WRITE_PORT_UCHAR(GRAPHICSDATA, Registers->Graphics[i]);
}
/* Write attribute controller registers */
for (i = 0; i < sizeof(Registers->Attribute); i++)
{
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, i);
WRITE_PORT_UCHAR(ATTRIB, Registers->Attribute[i]);
}
/* Set the PEL mask. */
WRITE_PORT_UCHAR(PELMASK, 0xff);
}
static VOID FASTCALL
ScrAcquireOwnership(PDEVICE_EXTENSION DeviceExtension)
{
PDEVICE_EXTENSION DeviceExtension;
PHYSICAL_ADDRESS BaseAddress;
NTSTATUS Status;
unsigned int offset;
UCHAR data, value;
ULONG Index;
DeviceExtension = DeviceObject->DeviceExtension;
ScrSetRegisters(&VidpMode3Regs);
/* disable interrupts */
_disable();
/* Disable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x00);
for (Index = 0; Index < sizeof(DefaultPalette) / 3; Index++)
{
WRITE_PORT_UCHAR(PELINDEX, Index);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3] >> 2);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3 + 1] >> 2);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3 + 2] >> 2);
}
/* Enable screen and disable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x20);
/* get current output position */
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
@ -122,8 +239,13 @@ ScrCreate(PDEVICE_OBJECT DeviceObject,
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_SCANLINES);
DeviceExtension->ScanLines = (READ_PORT_UCHAR (CRTC_DATA) & 0x1F) + 1;
/* enable interrupts */
_enable();
/* show blinking cursor */
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
WRITE_PORT_UCHAR (CRTC_DATA, (DeviceExtension->ScanLines - 1) & 0x1F);
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
data = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
WRITE_PORT_UCHAR (CRTC_DATA,
data | ((DeviceExtension->ScanLines - 1) & 0x1F));
/* calculate number of text rows */
DeviceExtension->Rows =
@ -132,10 +254,26 @@ ScrCreate(PDEVICE_OBJECT DeviceObject,
DeviceExtension->Rows = 30;
#endif
DPRINT ("%d Columns %d Rows %d Scanlines\n",
DPRINT1 ("%d Columns %d Rows %d Scanlines\n",
DeviceExtension->Columns,
DeviceExtension->Rows,
DeviceExtension->ScanLines);
}
NTSTATUS STDCALL
DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
static NTSTATUS STDCALL
ScrCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension;
PHYSICAL_ADDRESS BaseAddress;
NTSTATUS Status;
DeviceExtension = DeviceObject->DeviceExtension;
ScrAcquireOwnership(DeviceExtension);
/* get pointer to video memory */
BaseAddress.QuadPart = VIDMEM_BASE;
@ -150,16 +288,6 @@ ScrCreate(PDEVICE_OBJECT DeviceObject,
DeviceExtension->Mode = ENABLE_PROCESSED_OUTPUT |
ENABLE_WRAP_AT_EOL_OUTPUT;
/* show blinking cursor */
_disable();
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
WRITE_PORT_UCHAR (CRTC_DATA, (DeviceExtension->ScanLines - 1) & 0x1F);
WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
data = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
WRITE_PORT_UCHAR (CRTC_DATA,
data | ((DeviceExtension->ScanLines - 1) & 0x1F));
_enable();
Status = STATUS_SUCCESS;
Irp->IoStatus.Status = Status;
@ -184,7 +312,7 @@ ScrWrite(PDEVICE_OBJECT DeviceObject,
int rows, columns;
int processed = DeviceExtension->Mode & ENABLE_PROCESSED_OUTPUT;
if (HalQueryDisplayOwnership())
if (0 && InbvCheckDisplayOwnership())
{
/* Display is in graphics mode, we're not allowed to touch it */
Status = STATUS_SUCCESS;

BIN
reactos/drivers/base/bootvid/bar.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 262 B

BIN
reactos/drivers/base/bootvid/bootimage.bmp
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 95 KiB

After

Width:  |  Height:  |  Size: 20 KiB

771
reactos/drivers/base/bootvid/bootvid.c
View file

@ -2,7 +2,7 @@
* ReactOS Boot video driver
*
* Copyright (C) 2003 Casper S. Hornstroup
* Copyright (C) 2004 Filip Navara
* Copyright (C) 2004, 2005 Filip Navara
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -23,550 +23,211 @@
/* INCLUDES ******************************************************************/
#include <ntddk.h>
#include <windef.h>
#include <ndk/ldrfuncs.h>
#include "bootvid.h"
#include "ntbootvid.h"
#include "resource.h"
#define NDEBUG
#include <debug.h>
//#define USE_PROGRESS_BAR
/* GLOBALS *******************************************************************/
/*
* NOTE:
* This is based on SvgaLib 640x480x16 mode definition with the
* following changes:
* - Graphics: Data Rotate (Index 3)
* Set to zero to indicate that the data written to video memory by
* CPU should be processed unmodified.
* - Graphics: Mode Register (Index 5)
* Set to Write Mode 2 and Read Mode 0.
*/
static const VGA_REGISTERS Mode12Regs =
{
/* CRT Controller Registers */
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 0x40, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xEA, 0x8C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3},
/* Attribute Controller Registers */
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F, 0x81, 0x00, 0x0F, 0x00, 0x00},
/* Graphics Controller Registers */
{0x00, 0x0F, 0x00, 0x00, 0x00, 0x02, 0x05, 0x0F, 0xFF},
/* Sequencer Registers */
{0x03, 0x01, 0x0F, 0x00, 0x06},
/* Misc Output Register */
0xE3
};
PUCHAR VideoMemory;
/* Must be 4 bytes per entry */
long maskbit[640];
static CLIENT_ID BitmapThreadId;
static PUCHAR BootimageBitmap;
static LONG ShutdownNotify;
static KEVENT ShutdownCompleteEvent;
/* DATA **********************************************************************/
static PDRIVER_OBJECT BootVidDriverObject = NULL;
static RGBQUAD _MainPalette[16];
static UCHAR _Square1[9 * 4];
static UCHAR _Square2[9 * 4];
static UCHAR _Square3[9 * 4];
/* FUNCTIONS *****************************************************************/
static BOOLEAN FASTCALL
InbvFindBootimage()
static VOID NTAPI
BootVidAnimationThread(PVOID Ignored)
{
PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
LDR_RESOURCE_INFO ResourceInfo;
NTSTATUS Status;
PVOID BaseAddress = BootVidDriverObject->DriverStart;
ULONG Size;
ResourceInfo.Type = RT_BITMAP;
ResourceInfo.Name = IDB_BOOTIMAGE;
ResourceInfo.Language = 0x09;
Status = LdrFindResource_U(
BaseAddress,
&ResourceInfo,
RESOURCE_DATA_LEVEL,
&ResourceDataEntry);
if (!NT_SUCCESS(Status))
{
DPRINT("LdrFindResource_U() failed with status 0x%.08x\n", Status);
return FALSE;
}
Status = LdrAccessResource(
BaseAddress,
ResourceDataEntry,
(PVOID*)&BootimageBitmap,
&Size);
if (!NT_SUCCESS(Status))
{
DPRINT("LdrAccessResource() failed with status 0x%.08x\n", Status);
return FALSE;
}
return TRUE;
}
static BOOLEAN FASTCALL
InbvMapVideoMemory(VOID)
{
PHYSICAL_ADDRESS PhysicalAddress;
PhysicalAddress.QuadPart = 0xA0000;
VideoMemory = MmMapIoSpace(PhysicalAddress, 0x10000, MmNonCached);
return VideoMemory != NULL;
}
static BOOLEAN FASTCALL
InbvUnmapVideoMemory(VOID)
{
MmUnmapIoSpace(VideoMemory, 0x10000);
return TRUE;
}
static VOID FASTCALL
vgaPreCalc()
{
ULONG j;
for (j = 0; j < 80; j++)
{
maskbit[j * 8 + 0] = 128;
maskbit[j * 8 + 1] = 64;
maskbit[j * 8 + 2] = 32;
maskbit[j * 8 + 3] = 16;
maskbit[j * 8 + 4] = 8;
maskbit[j * 8 + 5] = 4;
maskbit[j * 8 + 6] = 2;
maskbit[j * 8 + 7] = 1;
}
}
static VOID FASTCALL
vgaSetRegisters(const VGA_REGISTERS *Registers)
{
UINT i;
/* Update misc output register */
WRITE_PORT_UCHAR(MISC, Registers->Misc);
/* Synchronous reset on */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x01);
/* Write sequencer registers */
for (i = 1; i < sizeof(Registers->Sequencer); i++)
{
WRITE_PORT_UCHAR(SEQ, i);
WRITE_PORT_UCHAR(SEQDATA, Registers->Sequencer[i]);
}
/* Synchronous reset off */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x03);
/* Deprotect CRT registers 0-7 */
WRITE_PORT_UCHAR(CRTC, 0x11);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[0x11] & 0x7f);
/* Write CRT registers */
for (i = 0; i < sizeof(Registers->CRT); i++)
{
WRITE_PORT_UCHAR(CRTC, i);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[i]);
}
/* Write graphics controller registers */
for (i = 0; i < sizeof(Registers->Graphics); i++)
{
WRITE_PORT_UCHAR(GRAPHICS, i);
WRITE_PORT_UCHAR(GRAPHICSDATA, Registers->Graphics[i]);
}
/* Write attribute controller registers */
for (i = 0; i < sizeof(Registers->Attribute); i++)
{
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, i);
WRITE_PORT_UCHAR(ATTRIB, Registers->Attribute[i]);
}
}
static VOID
InbvInitVGAMode(VOID)
{
/* Zero out video memory (clear a possibly trashed screen) */
RtlZeroMemory(VideoMemory, 0x10000);
vgaSetRegisters(&Mode12Regs);
/* Set the PEL mask. */
WRITE_PORT_UCHAR(PELMASK, 0xff);
vgaPreCalc();
}
static BOOLEAN STDCALL
VidResetDisplay(VOID)
{
/*
* We are only using standard VGA facilities so we can rely on the
* HAL 'int10mode3' reset to cleanup the hardware state.
*/
return FALSE;
}
static VOID STDCALL
VidCleanUp(VOID)
{
InbvUnmapVideoMemory();
InterlockedIncrement(&ShutdownNotify);
KeWaitForSingleObject(&ShutdownCompleteEvent, Executive, KernelMode,
FALSE, NULL);
}
static VOID FASTCALL
InbvSetColor(INT Index, UCHAR Red, UCHAR Green, UCHAR Blue)
{
WRITE_PORT_UCHAR(PELINDEX, Index);
WRITE_PORT_UCHAR(PELDATA, Red >> 2);
WRITE_PORT_UCHAR(PELDATA, Green >> 2);
WRITE_PORT_UCHAR(PELDATA, Blue >> 2);
}
static VOID FASTCALL
InbvSetBlackPalette()
{
register ULONG r = 0;
/* Disable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x00);
for (r = 0; r < 16; r++)
{
InbvSetColor(r, 0, 0, 0);
}
/* Enable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x20);
}
static VOID FASTCALL
InbvDisplayBitmap(ULONG Width, ULONG Height, PCHAR ImageData)
{
ULONG j, k, y;
register ULONG i;
register ULONG x;
register ULONG c;
k = 0;
for (y = 0; y < Height; y++)
{
for (j = 0; j < 8; j++)
{
x = j;
/*
* Loop through the line and process every 8th pixel.
* This way we can get a way with using the same bit mask
* for several pixels and thus not need to do as much I/O
* communication.
*/
while (x < 640)
{
c = 0;
if (x < Width)
{
c = ImageData[k + x];
for (i = 1; i < 4; i++)
{
if (x + i * 8 < Width)
{
c |= (ImageData[k + x + i * 8] << i * 8);
}
}
}
InbvPutPixels(x, 479 - y, c);
x += 8 * 4;
}
}
k += Width;
}
}
static VOID FASTCALL
InbvDisplayCompressedBitmap()
{
PBITMAPV5HEADER bminfo;
ULONG i,j,k;
ULONG x,y;
ULONG curx,cury;
ULONG bfOffBits;
ULONG clen;
PCHAR ImageData;
UCHAR ClrUsed;
bminfo = (PBITMAPV5HEADER) &BootimageBitmap[0];
DPRINT("bV5Size = %d\n", bminfo->bV5Size);
DPRINT("bV5Width = %d\n", bminfo->bV5Width);
DPRINT("bV5Height = %d\n", bminfo->bV5Height);
DPRINT("bV5Planes = %d\n", bminfo->bV5Planes);
DPRINT("bV5BitCount = %d\n", bminfo->bV5BitCount);
DPRINT("bV5Compression = %d\n", bminfo->bV5Compression);
DPRINT("bV5SizeImage = %d\n", bminfo->bV5SizeImage);
DPRINT("bV5XPelsPerMeter = %d\n", bminfo->bV5XPelsPerMeter);
DPRINT("bV5YPelsPerMeter = %d\n", bminfo->bV5YPelsPerMeter);
DPRINT("bV5ClrUsed = %d\n", bminfo->bV5ClrUsed);
DPRINT("bV5ClrImportant = %d\n", bminfo->bV5ClrImportant);
if (bminfo->bV5ClrUsed)
ClrUsed = bminfo->bV5ClrUsed;
else
ClrUsed = 1 << bminfo->bV5BitCount;
bfOffBits = bminfo->bV5Size + ClrUsed * sizeof(RGBQUAD);
DPRINT("bfOffBits = %d\n", bfOffBits);
DPRINT("size of color indices = %d\n", ClrUsed * sizeof(RGBQUAD));
DPRINT("first byte of data = %d\n", BootimageBitmap[bfOffBits]);
InbvSetBlackPalette();
ImageData = ExAllocatePool(NonPagedPool, bminfo->bV5Width * bminfo->bV5Height);
RtlZeroMemory(ImageData, bminfo->bV5Width * bminfo->bV5Height);
/*
* ImageData has 1 pixel per byte.
* bootimage has 2 pixels per byte.
*/
if (bminfo->bV5Compression == 2)
{
k = 0;
j = 0;
while ((j < bminfo->bV5SizeImage) && (k < (ULONG) (bminfo->bV5Width * bminfo->bV5Height)))
{
unsigned char b;
clen = BootimageBitmap[bfOffBits + j];
j++;
if (clen > 0)
{
/* Encoded mode */
b = BootimageBitmap[bfOffBits + j];
j++;
for (i = 0; i < (clen / 2); i++)
{
ImageData[k] = (b & 0xf0) >> 4;
k++;
ImageData[k] = b & 0xf;
k++;
}
if ((clen & 1) > 0)
{
ImageData[k] = (b & 0xf0) >> 4;
k++;
}
}
else
{
/* Absolute mode */
b = BootimageBitmap[bfOffBits + j];
j++;
if (b == 0)
{
/* End of line */
if (k % bminfo->bV5Width)
{
cury = k / bminfo->bV5Width;
k = (cury + 1) * bminfo->bV5Width;
}
}
else if (b == 1)
{
/* End of image */
break;
}
else if (b == 2)
{
x = BootimageBitmap[bfOffBits + j];
j++;
y = BootimageBitmap[bfOffBits + j];
j++;
curx = k % bminfo->bV5Width;
cury = k / bminfo->bV5Width;
k = (cury + y) * bminfo->bV5Width + (curx + x);
}
else
{
if ((j & 1) > 0)
{
DPRINT("Unaligned copy!\n");
}
clen = b;
for (i = 0; i < (clen / 2); i++)
{
b = BootimageBitmap[bfOffBits + j];
j++;
ImageData[k] = (b & 0xf0) >> 4;
k++;
ImageData[k] = b & 0xf;
k++;
}
if ((clen & 1) > 0)
{
b = BootimageBitmap[bfOffBits + j];
j++;
ImageData[k] = (b & 0xf0) >> 4;
k++;
}
/* Word align */
j += (j & 1);
}
}
}
InbvDisplayBitmap(bminfo->bV5Width, bminfo->bV5Height, ImageData);
}
else
{
DbgPrint("Warning boot image need to be compressed using RLE4\n");
}
ExFreePool(ImageData);
}
static VOID FASTCALL
InbvFadeUpPalette()
{
PBITMAPV5HEADER bminfo;
PRGBQUAD Palette;
ULONG i;
unsigned char r, g, b;
register ULONG c;
UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) + sizeof(_MainPalette)];
PBITMAPINFOHEADER PaletteBitmap = (PBITMAPINFOHEADER)PaletteBitmapBuffer;
LPRGBQUAD Palette = (LPRGBQUAD)(PaletteBitmapBuffer + sizeof(BITMAPINFOHEADER));
ULONG Iteration, Index, ClrUsed;
UINT AnimBarPos;
LARGE_INTEGER Interval;
FADER_PALETTE_ENTRY FaderPalette[16];
FADER_PALETTE_ENTRY FaderPaletteDelta[16];
UCHAR ClrUsed;
/*
* Build a bitmap containing the fade in palette. The palette entries
* are then processed in a loop and set using VidBitBlt function.
*/
ClrUsed = sizeof(_MainPalette) / sizeof(_MainPalette[0]);
RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
PaletteBitmap->biBitCount = 4;
PaletteBitmap->biClrUsed = ClrUsed;
RtlZeroMemory(&FaderPalette, sizeof(FaderPalette));
RtlZeroMemory(&FaderPaletteDelta, sizeof(FaderPaletteDelta));
/*
* Main animation loop.
*/
bminfo = (PBITMAPV5HEADER)&BootimageBitmap[0];
Palette = (PRGBQUAD)&BootimageBitmap[bminfo->bV5Size];
if (bminfo->bV5ClrUsed)
ClrUsed = bminfo->bV5ClrUsed;
else
ClrUsed = 1 << bminfo->bV5BitCount;
for (i = 0; i < 16 && i < ClrUsed; i++)
for (Iteration = 0, AnimBarPos = 0; !ShutdownNotify; Iteration++)
{
FaderPaletteDelta[i].r = ((Palette[i].rgbRed << 8) / PALETTE_FADE_STEPS);
FaderPaletteDelta[i].g = ((Palette[i].rgbGreen << 8) / PALETTE_FADE_STEPS);
FaderPaletteDelta[i].b = ((Palette[i].rgbBlue << 8) / PALETTE_FADE_STEPS);
}
for (i = 0; i < PALETTE_FADE_STEPS && !ShutdownNotify; i++)
{
/* Disable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x00);
for (c = 0; c < ClrUsed; c++)
if (Iteration <= PALETTE_FADE_STEPS)
{
/* Add the delta */
FaderPalette[c].r += FaderPaletteDelta[c].r;
FaderPalette[c].g += FaderPaletteDelta[c].g;
FaderPalette[c].b += FaderPaletteDelta[c].b;
for (Index = 0; Index < ClrUsed; Index++)
{
Palette[Index].rgbRed =
_MainPalette[Index].rgbRed * Iteration / PALETTE_FADE_STEPS;
Palette[Index].rgbGreen =
_MainPalette[Index].rgbGreen * Iteration / PALETTE_FADE_STEPS;
Palette[Index].rgbBlue =
_MainPalette[Index].rgbBlue * Iteration / PALETTE_FADE_STEPS;
}
/* Get the integer values */
r = FaderPalette[c].r >> 8;
g = FaderPalette[c].g >> 8;
b = FaderPalette[c].b >> 8;
/* Don't go too far */
if (r > Palette[c].rgbRed)
r = Palette[c].rgbRed;
if (g > Palette[c].rgbGreen)
g = Palette[c].rgbGreen;
if (b > Palette[c].rgbBlue)
b = Palette[c].rgbBlue;
/* Update the hardware */
InbvSetColor(c, r, g, b);
VidBitBlt(PaletteBitmapBuffer, 0, 0);
}
#ifdef USE_PROGRESS_BAR
else
{
break;
}
/* Enable screen and disable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x20);
Interval.QuadPart = -PALETTE_FADE_TIME;
#else
if (AnimBarPos == 0)
{
VidSolidColorFill(0x173, 354, 0x178, 354 + 9, 0);
}
else if (AnimBarPos > 3)
{
VidSolidColorFill(0xe3 + AnimBarPos * 8, 354,
0xe8 + AnimBarPos * 8, 354 + 9,
0);
}
if (AnimBarPos >= 3)
VidBufferToScreenBlt(_Square1, 0xeb + AnimBarPos * 8, 354, 6, 9, 4);
if (AnimBarPos >= 2 && AnimBarPos <= 16)
VidBufferToScreenBlt(_Square2, 0xf3 + AnimBarPos * 8, 354, 6, 9, 4);
if (AnimBarPos >= 1 && AnimBarPos <= 15)
VidBufferToScreenBlt(_Square3, 0xfb + AnimBarPos * 8, 354, 6, 9, 4);
if (Iteration <= PALETTE_FADE_STEPS)
{
Interval.QuadPart = -PALETTE_FADE_TIME;
if ((Iteration % 5) == 0)
AnimBarPos++;
}
else
{
Interval.QuadPart = -PALETTE_FADE_TIME * 5;
AnimBarPos++;
}
AnimBarPos = Iteration % 18;
#endif
/* Wait for a bit. */
Interval.QuadPart = -PALETTE_FADE_TIME;
KeDelayExecutionThread(KernelMode, FALSE, &Interval);
}
}
static VOID STDCALL
InbvBitmapThreadMain(PVOID Ignored)
{
if (InbvFindBootimage())
{
InbvDisplayCompressedBitmap();
InbvFadeUpPalette();
}
else
{
DbgPrint("Warning: Cannot find boot image\n");
}
DPRINT("Finishing bootvid thread.\n");
KeSetEvent(&ShutdownCompleteEvent, 0, FALSE);
PsTerminateSystemThread(0);
}
static BOOLEAN STDCALL
VidInitialize(VOID)
NTSTATUS NTAPI
BootVidDisplayBootLogo(PVOID ImageBase)
{
NTSTATUS Status;
PBITMAPINFOHEADER BitmapInfoHeader;
LPRGBQUAD Palette;
static const ULONG BitmapIds[2] = {IDB_BOOTIMAGE, IDB_BAR};
PUCHAR BitmapData[2];
ULONG Index;
HANDLE BitmapThreadHandle;
CLIENT_ID BitmapThreadId;
NTSTATUS Status;
InbvMapVideoMemory();
InbvInitVGAMode();
KeInitializeEvent(&ShutdownCompleteEvent, NotificationEvent, FALSE);
/*
* Get the bitmaps from the executable.
*/
for (Index = 0; Index < sizeof(BitmapIds) / sizeof(BitmapIds[0]); Index++)
{
PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
LDR_RESOURCE_INFO ResourceInfo;
ULONG Size;
ResourceInfo.Type = /* RT_BITMAP */ 2;
ResourceInfo.Name = BitmapIds[Index];
ResourceInfo.Language = 0x09;
Status = LdrFindResource_U(
ImageBase,
&ResourceInfo,
RESOURCE_DATA_LEVEL,
&ResourceDataEntry);
if (!NT_SUCCESS(Status))
{
DPRINT("LdrFindResource_U() failed with status 0x%.08x\n", Status);
return Status;
}
Status = LdrAccessResource(
ImageBase,
ResourceDataEntry,
(PVOID*)&BitmapData[Index],
&Size);
if (!NT_SUCCESS(Status))
{
DPRINT("LdrAccessResource() failed with status 0x%.08x\n", Status);
return Status;
}
}
/*
* Initialize the graphics output.
*/
if (!VidInitialize(TRUE))
{
return STATUS_UNSUCCESSFUL;
}
/*
* Load the bar bitmap and get the square data from it.
*/
VidBitBlt(BitmapData[1], 0, 0);
VidScreenToBufferBlt(_Square1, 0, 0, 6, 9, 4);
VidScreenToBufferBlt(_Square2, 8, 0, 6, 9, 4);
VidScreenToBufferBlt(_Square3, 16, 0, 6, 9, 4);
/*
* Save the main image palette and replace it with black palette, so
* we can do fade in effect later.
*/
BitmapInfoHeader = (PBITMAPINFOHEADER)BitmapData[0];
Palette = (LPRGBQUAD)(BitmapData[0] + BitmapInfoHeader->biSize);
RtlCopyMemory(_MainPalette, Palette, sizeof(_MainPalette));
RtlZeroMemory(Palette, sizeof(_MainPalette));
/*
* Display the main image.
*/
VidBitBlt(BitmapData[0], 0, 0);
/*
* Start a thread that handles the fade in and bar animation effects.
*/
Status = PsCreateSystemThread(
&BitmapThreadHandle,
@ -574,99 +235,47 @@ VidInitialize(VOID)
NULL,
NULL,
&BitmapThreadId,
InbvBitmapThreadMain,
BootVidAnimationThread,
NULL);
if (!NT_SUCCESS(Status))
{
return FALSE;
VidCleanUp();
return Status;
}
ZwClose(BitmapThreadHandle);
return TRUE;
return STATUS_SUCCESS;
}
static NTSTATUS STDCALL
VidDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI
BootVidUpdateProgress(ULONG Progress)
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
NTBOOTVID_FUNCTION_TABLE* FunctionTable;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Status = STATUS_SUCCESS;
switch(IrpSp->MajorFunction)
#ifdef USE_PROGRESS_BAR
if (ShutdownNotify == 0)
{
/* Opening and closing handles to the device */
case IRP_MJ_CREATE:
case IRP_MJ_CLOSE:
break;
case IRP_MJ_DEVICE_CONTROL:
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_BOOTVID_INITIALIZE:
VidInitialize();
FunctionTable = (NTBOOTVID_FUNCTION_TABLE *)
Irp->AssociatedIrp.SystemBuffer;
FunctionTable->ResetDisplay = VidResetDisplay;
Irp->IoStatus.Information = sizeof(NTBOOTVID_FUNCTION_TABLE);
break;
case IOCTL_BOOTVID_CLEANUP:
VidCleanUp();
break;
default:
Status = STATUS_NOT_IMPLEMENTED;
break;
}
break;
/* Unsupported operations */
default:
Status = STATUS_NOT_IMPLEMENTED;
VidSolidColorFill(0x103, 354, 0x103 + (Progress * 120 / 100), 354 + 9, 1);
}
#endif
}
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
VOID NTAPI
BootVidFinalizeBootLogo(VOID)
{
InterlockedIncrement(&ShutdownNotify);
DPRINT1("Waiting for bootvid thread to finish.\n");
KeWaitForSingleObject(&ShutdownCompleteEvent, Executive, KernelMode,
FALSE, NULL);
DPRINT1("Bootvid thread to finish.\n");
VidResetDisplay();
}
NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT BootVidDevice;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\BootVid");
NTSTATUS Status;
BootVidDriverObject = DriverObject;
ShutdownNotify = 0;
KeInitializeEvent(&ShutdownCompleteEvent, NotificationEvent, FALSE);
/* Register driver routines */
DriverObject->MajorFunction[IRP_MJ_CLOSE] = VidDispatch;
DriverObject->MajorFunction[IRP_MJ_CREATE] = VidDispatch;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VidDispatch;
DriverObject->DriverUnload = NULL;
DriverObject->Flags |= DO_BUFFERED_IO;
/* Create device */
Status = IoCreateDevice(
DriverObject,
0,
&DeviceName,
FILE_DEVICE_BOOTVID,
0,
FALSE,
&BootVidDevice);
return Status;
return STATUS_SUCCESS;
}

14
reactos/drivers/base/bootvid/bootvid.def Normal file
View file

@ -0,0 +1,14 @@
LIBRARY bootvid.sys
EXPORTS
VidInitialize@4
VidCleanUp@0
VidResetDisplay@0
VidBufferToScreenBlt@24
VidScreenToBufferBlt@24
VidBitBlt@12
VidSolidColorFill@20
VidDisplayString@4
BootVidDisplayBootLogo@4
BootVidUpdateProgress@4
BootVidFinalizeBootLogo@0

128
reactos/drivers/base/bootvid/bootvid.h
View file

@ -2,7 +2,7 @@
* ReactOS Boot video driver
*
* Copyright (C) 2003 Casper S. Hornstroup
* Copyright (C) 2004 Filip Navara
* Copyright (C) 2004, 2005 Filip Navara
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -24,104 +24,42 @@
#ifndef _BOOTVID_H
#define _BOOTVID_H
#define PALETTE_FADE_STEPS 20
#include <ntddk.h>
#include <windef.h>
#include <wingdi.h>
#include <ndk/ldrfuncs.h>
#define PALETTE_FADE_STEPS 15
#define PALETTE_FADE_TIME 20 * 10000 /* 20ms */
/*
* Windows Bitmap structures
*/
BOOLEAN NTAPI VidInitialize(BOOLEAN);
VOID NTAPI VidCleanUp(VOID);
VOID NTAPI VidResetDisplay(VOID);
VOID NTAPI VidBufferToScreenBlt(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
VOID NTAPI VidScreenToBufferBlt(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
VOID NTAPI VidBitBlt(PUCHAR, ULONG, ULONG);
VOID NTAPI VidSolidColorFill(ULONG, ULONG, ULONG, ULONG, ULONG);
VOID NTAPI VidDisplayString(PUCHAR);
#define RT_BITMAP 2
typedef BOOLEAN (NTAPI *PVID_INITIALIZE)(BOOLEAN);
typedef VOID (NTAPI *PVID_CLEAN_UP)(VOID);
typedef VOID (NTAPI *PVID_RESET_DISPLAY)(VOID);
typedef VOID (NTAPI *PVID_BUFFER_TO_SCREEN_BLT)(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
typedef VOID (NTAPI *PVID_SCREEN_TO_BUFFER_BLT)(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
typedef VOID (NTAPI *PVID_BITBLT)(PUCHAR, ULONG, ULONG);
typedef VOID (NTAPI *PVID_SOLID_COLOR_FILL)(ULONG, ULONG, ULONG, ULONG, ULONG);
typedef VOID (NTAPI *PVID_DISPLAY_STRING)(PUCHAR);
typedef struct tagRGBQUAD
typedef struct _VID_FUNCTION_TABLE
{
unsigned char rgbBlue;
unsigned char rgbGreen;
unsigned char rgbRed;
unsigned char rgbReserved;
} RGBQUAD, *PRGBQUAD;
typedef long FXPT2DOT30;
typedef struct tagCIEXYZ
{
FXPT2DOT30 ciexyzX;
FXPT2DOT30 ciexyzY;
FXPT2DOT30 ciexyzZ;
} CIEXYZ, *LPCIEXYZ;
typedef struct tagCIEXYZTRIPLE
{
CIEXYZ ciexyzRed;
CIEXYZ ciexyzGreen;
CIEXYZ ciexyzBlue;
} CIEXYZTRIPLE, *LPCIEXYZTRIPLE;
typedef struct {
DWORD bV5Size;
LONG bV5Width;
LONG bV5Height;
WORD bV5Planes;
WORD bV5BitCount;
DWORD bV5Compression;
DWORD bV5SizeImage;
LONG bV5XPelsPerMeter;
LONG bV5YPelsPerMeter;
DWORD bV5ClrUsed;
DWORD bV5ClrImportant;
DWORD bV5RedMask;
DWORD bV5GreenMask;
DWORD bV5BlueMask;
DWORD bV5AlphaMask;
DWORD bV5CSType;
CIEXYZTRIPLE bV5Endpoints;
DWORD bV5GammaRed;
DWORD bV5GammaGreen;
DWORD bV5GammaBlue;
DWORD bV5Intent;
DWORD bV5ProfileData;
DWORD bV5ProfileSize;
DWORD bV5Reserved;
} BITMAPV5HEADER, *PBITMAPV5HEADER;
/*
* Private driver structures
*/
typedef struct {
ULONG r;
ULONG g;
ULONG b;
} FADER_PALETTE_ENTRY;
typedef struct _VGA_REGISTERS
{
UCHAR CRT[24];
UCHAR Attribute[21];
UCHAR Graphics[9];
UCHAR Sequencer[5];
UCHAR Misc;
} VGA_REGISTERS, *PVGA_REGISTERS;
/* VGA registers */
#define MISC (PUCHAR)0x3c2
#define SEQ (PUCHAR)0x3c4
#define SEQDATA (PUCHAR)0x3c5
#define CRTC (PUCHAR)0x3d4
#define CRTCDATA (PUCHAR)0x3d5
#define GRAPHICS (PUCHAR)0x3ce
#define GRAPHICSDATA (PUCHAR)0x3cf
#define ATTRIB (PUCHAR)0x3c0
#define STATUS (PUCHAR)0x3da
#define PELMASK (PUCHAR)0x3c6
#define PELINDEX (PUCHAR)0x3c8
#define PELDATA (PUCHAR)0x3c9
/* In pixelsups.S */
extern VOID
InbvPutPixels(int x, int y, unsigned long c);
NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
PVID_INITIALIZE Initialize;
PVID_CLEAN_UP CleanUp;
PVID_RESET_DISPLAY ResetDisplay;
PVID_BUFFER_TO_SCREEN_BLT BufferToScreenBlt;
PVID_SCREEN_TO_BUFFER_BLT ScreenToBufferBlt;
PVID_BITBLT BitBlt;
PVID_SOLID_COLOR_FILL SolidColorFill;
PVID_DISPLAY_STRING DisplayString;
} VID_FUNCTION_TABLE, *PVID_FUNCTION_TABLE;
#endif /* _BOOTVID_H */

11
reactos/drivers/base/bootvid/bootvid.rbuild
View file

@ -1,9 +1,14 @@
<module name="bootvid" type="kernelmodedriver" installbase="system32/drivers" installname="bootvid.sys">
<include base="bootvid">.</include>
<module name="bootvid" type="kernelmodedll" entrypoint="DriverEntry@8" installbase="system32/drivers" installname="bootvid.sys">
<importlibrary definition="bootvid.def"></importlibrary>
<bootstrap base="reactos" nameoncd="bootvid.sys" />
<include base="bootvid">.</include>
<define name="__USE_W32API" />
<library>ntoskrnl</library>
<library>hal</library>
<file>bootvid.c</file>
<file>pixelsup_i386.S</file>
<file>vid.c</file>
<file>vid_vga.c</file>
<file>vid_vgatext.c</file>
<file>vid_xbox.c</file>
<file>bootvid.rc</file>
</module>

2
reactos/drivers/base/bootvid/bootvid.rc
View file

@ -9,4 +9,6 @@
#include <reactos/version.rc>
IDB_BOOTIMAGE BITMAP DISCARDABLE "bootimage.bmp"
IDB_BAR BITMAP DISCARDABLE "bar.bmp"

13
reactos/drivers/base/bootvid/ntbootvid.h
View file

@ -1,13 +0,0 @@
/* FIXME: Bootvid will eventually become a DLL and this will be deprecated */
#define FILE_DEVICE_BOOTVID 53335
#define IOCTL_BOOTVID_INITIALIZE \
CTL_CODE(FILE_DEVICE_BOOTVID, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_BOOTVID_CLEANUP \
CTL_CODE(FILE_DEVICE_BOOTVID, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
typedef struct
{
BOOLEAN (NTAPI *ResetDisplay)(VOID);
} NTBOOTVID_FUNCTION_TABLE;

108
reactos/drivers/base/bootvid/pixelsup_i386.S
View file

@ -1,108 +0,0 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/inbv/i386/pixelsup.S
* PURPOSE: Boot video support
* PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
*/
/*
* VOID
* InbvPutPixels(int x, int y, unsigned long c);
*
* Will put 4 pixels on the screen at
* (x+0*8,y), (x+1*8,y), (x+2*8,y), and (x+3*8,y)
* c will contain:
* bits 0- 3: Palette index for pixel at (x+0*8,y)
* bits 8-11: Palette index for pixel at (x+1*8,y)
* bits 16-19: Palette index for pixel at (x+2*8,y)
* bits 24-27: Palette index for pixel at (x+3*8,y)
*
* Parameters:
* [EBP+08h] - x X-coordinate of first pixel
* [ESP+0Ch] - y Y-coordinate of first pixel
* [ESP+10h] - c 4*4-bit color indices
*/
.globl _InbvPutPixels
_InbvPutPixels:
pushl %ebp
movl %esp, %ebp
pushl %esi
pushl %ebx
/* Compute mask and put it in EBX
mask = maskbit[x] */
movl 0x8(%ebp), %esi
movl _maskbit(,%esi, 4), %ebx
/* Don't set bit mask if it is already set */
cmpl (inbv_last_mask),%ebx
je .nomask
/* Set Mask Bit Register
WRITE_PORT_UCHAR((PUCHAR)0x3ce,0x08);
WRITE_PORT_UCHAR((PUCHAR)0x3cf,mask); */
movl %ebx,(inbv_last_mask)
movw $0x3ce,%dx
movb $0x08,%al
outb %al,%dx
movw $0x3cf,%dx
movb %bl,%al
outb %al,%dx
.nomask:
/* Compute offset in video memory and put it in EBX
offset = (x >> 3) + (y << 4) + (y << 6); */
movl 0xC(%ebp), %esi /* y */
movl %esi, %ebx
shll $0x6, %ebx
shll $0x4, %esi
addl %esi, %ebx
movl 0x8(%ebp), %eax /* x */
shrl $0x3, %eax
addl %eax, %ebx
/* Latch first byte
(UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+0); */
movl (_VideoMemory), %esi
addl %ebx, %esi
movb 0x0(%esi), %bl
/* Write color index for first pixel
*((PUCHAR)(VideoMemory + offset+0)) = (c >> 0*8) & 0xff; */
movl 0x10(%ebp), %eax
movb %al, 0x0(%esi)
/* Latch second byte
(UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+1); */
movb 0x1(%esi), %bl
/* Write color index for second pixel
*((PUCHAR)(VideoMemory + offset+1)) = (c >> 1*8) & 0xff; */
shrl $0x8, %eax
movb %al, 0x1(%esi)
/* Latch third byte
(UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+2); */
movb 0x2(%esi), %bl
/* Write color index for third pixel
*((PUCHAR)(VideoMemory + offset+2)) = (c >> 2*8) & 0xff; */
shrl $0x8, %eax
movb %al, 0x2(%esi)
/* Latch fourth byte
(UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+3); */
movb 0x3(%esi), %bl
/* Write color index for fourth pixel
*((PUCHAR)(VideoMemory + offset+3)) = (c >> 3*8) & 0xff; */
shrl $0x8, %eax
movb %al, 0x3(%esi)
popl %ebx
popl %esi
popl %ebp
ret
.bss
inbv_last_mask:
.short 0

4
reactos/drivers/base/bootvid/resource.h
View file

@ -1,4 +1,6 @@
/* $Id$ */
/* Bitmaps */
#define IDB_BOOTIMAGE 100
#define IDB_BOOTIMAGE 1
#define IDB_BAR 8

119
reactos/drivers/base/bootvid/vid.c Normal file
View file

@ -0,0 +1,119 @@
/*
* ReactOS Boot video driver
*
* Copyright (C) 2005 Filip Navara
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* INCLUDES ******************************************************************/
#include "bootvid.h"
#define NDEBUG
#include <debug.h>
/* GLOBALS *******************************************************************/
static PVID_FUNCTION_TABLE VidTable;
extern VID_FUNCTION_TABLE VidVgaTable;
extern VID_FUNCTION_TABLE VidVgaTextTable;
extern VID_FUNCTION_TABLE VidXboxTable;
/* FUNCTIONS *****************************************************************/
BOOLEAN NTAPI
VidInitialize(
IN BOOLEAN SetMode)
{
ULONG PciId;
/*
* Check for Xbox by identifying device at PCI 0:0:0, if it's
* 0x10de/0x02a5 then we're running on an Xbox.
*/
CHECKPOINT1;
WRITE_PORT_ULONG((PULONG)0xcf8, 0x80000000);
PciId = READ_PORT_ULONG((PULONG)0xcfc);
if (0x02a510de == PciId)
VidTable = &VidXboxTable;
else if (SetMode)
VidTable = &VidVgaTable;
else
VidTable = &VidVgaTextTable;
return VidTable->Initialize(SetMode);
}
VOID STDCALL
VidResetDisplay(VOID)
{
VidTable->ResetDisplay();
}
VOID NTAPI
VidCleanUp(VOID)
{
VidTable->CleanUp();
}
VOID NTAPI
VidBufferToScreenBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
VidTable->BufferToScreenBlt(Buffer, Left, Top, Width, Height, Delta);
}
VOID NTAPI
VidScreenToBufferBlt(
OUT PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
VidTable->ScreenToBufferBlt(Buffer, Left, Top, Width, Height, Delta);
}
VOID NTAPI
VidBitBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top)
{
VidTable->BitBlt(Buffer, Left, Top);
}
VOID NTAPI
VidSolidColorFill(
IN ULONG Left,
IN ULONG Top,
IN ULONG Right,
IN ULONG Bottom,
IN ULONG Color)
{
VidTable->SolidColorFill(Left, Top, Right, Bottom, Color);
}
VOID NTAPI
VidDisplayString(
IN PUCHAR String)
{
VidTable->DisplayString(String);
}

512
reactos/drivers/base/bootvid/vid_vga.c Normal file
View file

@ -0,0 +1,512 @@
/*
* ReactOS Boot video driver
*
* Copyright (C) 2005 Filip Navara
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* INCLUDES ******************************************************************/
#include "bootvid.h"
#define NDEBUG
#include <debug.h>
/* TYPES AND DEFINITIONS *****************************************************/
typedef struct _VGA_REGISTERS
{
UCHAR CRT[24];
UCHAR Attribute[21];
UCHAR Graphics[9];
UCHAR Sequencer[5];
UCHAR Misc;
} VGA_REGISTERS, *PVGA_REGISTERS;
/* VGA registers */
#define MISC (PUCHAR)0x3c2
#define SEQ (PUCHAR)0x3c4
#define SEQDATA (PUCHAR)0x3c5
#define CRTC (PUCHAR)0x3d4
#define CRTCDATA (PUCHAR)0x3d5
#define GRAPHICS (PUCHAR)0x3ce
#define GRAPHICSDATA (PUCHAR)0x3cf
#define ATTRIB (PUCHAR)0x3c0
#define STATUS (PUCHAR)0x3da
#define PELMASK (PUCHAR)0x3c6
#define PELINDEX (PUCHAR)0x3c8
#define PELDATA (PUCHAR)0x3c9
/* GLOBALS *******************************************************************/
/*
* NOTE:
* This is based on SvgaLib 640x480x16 mode definition with the
* following changes:
* - Graphics: Data Rotate (Index 3)
* Set to zero to indicate that the data written to video memory by
* CPU should be processed unmodified.
* - Graphics: Mode Register (Index 5)
* Set to Write Mode 2 and Read Mode 0.
*/
static const VGA_REGISTERS VidpMode12Regs =
{
/* CRT Controller Registers */
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 0x40, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xEA, 0x8C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3},
/* Attribute Controller Registers */
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F, 0x81, 0x00, 0x0F, 0x00, 0x00},
/* Graphics Controller Registers */
{0x00, 0x0F, 0x00, 0x00, 0x00, 0x02, 0x05, 0x0F, 0xFF},
/* Sequencer Registers */
{0x03, 0x01, 0x0F, 0x00, 0x06},
/* Misc Output Register */
0xE3
};
static const RGBQUAD DefaultPalette[] =
{
{0, 0, 0},
{0, 0, 0x80},
{0, 0x80, 0},
{0, 0x80, 0x80},
{0x80, 0, 0},
{0x80, 0, 0x80},
{0x80, 0x80, 0},
{0x80, 0x80, 0x80},
{0xC0, 0xC0, 0xC0},
{0, 0, 0xFF},
{0, 0xFF, 0},
{0, 0xFF, 0xFF},
{0xFF, 0, 0},
{0xFF, 0, 0xFF},
{0xFF, 0xFF, 0},
{0xFF, 0xFF, 0xFF}
};
static BOOLEAN VidpInitialized = FALSE;
static PUCHAR VidpMemory;
static CHAR VidpMaskBit[640];
static ULONG VidpCurrentX;
static ULONG VidpCurrentY;
/* FUNCTIONS *****************************************************************/
static VOID FASTCALL
VidpSetRegisters(const VGA_REGISTERS *Registers)
{
UINT i;
/* Update misc output register */
WRITE_PORT_UCHAR(MISC, Registers->Misc);
/* Synchronous reset on */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x01);
/* Write sequencer registers */
for (i = 1; i < sizeof(Registers->Sequencer); i++)
{
WRITE_PORT_UCHAR(SEQ, i);
WRITE_PORT_UCHAR(SEQDATA, Registers->Sequencer[i]);
}
/* Synchronous reset off */
WRITE_PORT_UCHAR(SEQ, 0x00);
WRITE_PORT_UCHAR(SEQDATA, 0x03);
/* Deprotect CRT registers 0-7 */
WRITE_PORT_UCHAR(CRTC, 0x11);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[0x11] & 0x7f);
/* Write CRT registers */
for (i = 0; i < sizeof(Registers->CRT); i++)
{
WRITE_PORT_UCHAR(CRTC, i);
WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[i]);
}
/* Write graphics controller registers */
for (i = 0; i < sizeof(Registers->Graphics); i++)
{
WRITE_PORT_UCHAR(GRAPHICS, i);
WRITE_PORT_UCHAR(GRAPHICSDATA, Registers->Graphics[i]);
}
/* Write attribute controller registers */
for (i = 0; i < sizeof(Registers->Attribute); i++)
{
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, i);
WRITE_PORT_UCHAR(ATTRIB, Registers->Attribute[i]);
}
/* Set the PEL mask. */
WRITE_PORT_UCHAR(PELMASK, 0xff);
}
static BOOLEAN NTAPI
VidVgaInitialize(
IN BOOLEAN SetMode)
{
ULONG Index;
PHYSICAL_ADDRESS PhysicalAddress;
if (!VidpInitialized)
{
PhysicalAddress.QuadPart = 0xA0000;
VidpMemory = MmMapIoSpace(PhysicalAddress, 0x10000, MmNonCached);
if (VidpMemory == NULL)
return FALSE;
for (Index = 0; Index < 80; Index++)
{
VidpMaskBit[Index * 8 + 0] = 128;
VidpMaskBit[Index * 8 + 1] = 64;
VidpMaskBit[Index * 8 + 2] = 32;
VidpMaskBit[Index * 8 + 3] = 16;
VidpMaskBit[Index * 8 + 4] = 8;
VidpMaskBit[Index * 8 + 5] = 4;
VidpMaskBit[Index * 8 + 6] = 2;
VidpMaskBit[Index * 8 + 7] = 1;
}
VidpInitialized = TRUE;
}
if (SetMode)
{
VidpSetRegisters(&VidpMode12Regs);
VidpCurrentX = VidpCurrentY = 0;
/* Disable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x00);
for (Index = 0; Index < sizeof(DefaultPalette) / sizeof(RGBQUAD); Index++)
{
WRITE_PORT_UCHAR(PELINDEX, Index);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index].rgbRed >> 2);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index].rgbGreen >> 2);
WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index].rgbBlue >> 2);
}
/* Enable screen and disable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x20);
}
return TRUE;
}
static VOID STDCALL
VidVgaResetDisplay(VOID)
{
VidVgaInitialize(TRUE);
}
static VOID NTAPI
VidVgaCleanUp(VOID)
{
if (VidpInitialized)
{
MmUnmapIoSpace(VidpMemory, 0x10000);
VidpInitialized = FALSE;
}
}
static VOID NTAPI
VidVgaBufferToScreenBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
ULONG x, y;
PUCHAR BufferPtr;
ULONG VidOffset;
for (x = Left; x < Left + Width; x++)
{
WRITE_PORT_UCHAR(GRAPHICS, 0x08);
WRITE_PORT_UCHAR(GRAPHICSDATA, VidpMaskBit[x]);
BufferPtr = Buffer;
VidOffset = (x >> 3) + (Top * 80);
if (((x - Left) % 2) == 0)
{
for (y = Top; y < Top + Height; y++)
{
READ_REGISTER_UCHAR(VidpMemory + VidOffset);
WRITE_REGISTER_UCHAR(VidpMemory + VidOffset, *BufferPtr >> 4);
VidOffset += 80;
BufferPtr += Delta;
}
}
else
{
for (y = Top; y < Top + Height; y++)
{
READ_REGISTER_UCHAR(VidpMemory + VidOffset);
WRITE_REGISTER_UCHAR(VidpMemory + VidOffset, *BufferPtr & 0xf);
VidOffset += 80;
BufferPtr += Delta;
}
Buffer++;
}
}
}
static VOID NTAPI
VidVgaScreenToBufferBlt(
OUT PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
UCHAR Plane;
UCHAR b;
ULONG x, y;
/* Reset the destination. */
RtlZeroMemory(Buffer, (Delta > 0 ? Delta : -Delta) * Height);
for (Plane = 0; Plane < 4; Plane++)
{
WRITE_PORT_UCHAR(GRAPHICS, 0x04);
WRITE_PORT_UCHAR(GRAPHICSDATA, Plane);
for (y = Top; y < Top + Height; y++)
{
for (x = Left; x < Left + Width; x++)
{
b = READ_REGISTER_UCHAR(VidpMemory + (y * 80 + (x >> 3)));
b >>= 7 - (x & 7);
b &= 1;
b <<= Plane + ((~(x - Left) & 1) << 2);
Buffer[(y - Top) * Delta + ((x - Left) >> 1)] |= b;
}
}
}
}
static VOID NTAPI
VidVgaBitBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top)
{
PBITMAPINFOHEADER BitmapInfoHeader;
LPRGBQUAD Palette;
ULONG bfOffBits;
UCHAR ClrUsed;
ULONG Index;
ULONG Delta;
BitmapInfoHeader = (PBITMAPINFOHEADER)Buffer;
Palette = (LPRGBQUAD)(Buffer + BitmapInfoHeader->biSize);
if (BitmapInfoHeader->biClrUsed)
ClrUsed = BitmapInfoHeader->biClrUsed;
else
ClrUsed = 1 << BitmapInfoHeader->biBitCount;
bfOffBits = BitmapInfoHeader->biSize + ClrUsed * sizeof(RGBQUAD);
/* Disable screen and enable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x00);
for (Index = 0; Index < ClrUsed; Index++)
{
WRITE_PORT_UCHAR(PELINDEX, Index);
WRITE_PORT_UCHAR(PELDATA, Palette[Index].rgbRed >> 2);
WRITE_PORT_UCHAR(PELDATA, Palette[Index].rgbGreen >> 2);
WRITE_PORT_UCHAR(PELDATA, Palette[Index].rgbBlue >> 2);
}
/* Enable screen and disable palette access. */
READ_PORT_UCHAR(STATUS);
WRITE_PORT_UCHAR(ATTRIB, 0x20);
if (BitmapInfoHeader->biCompression == 2)
{
PUCHAR OutputBuffer;
ULONG InputPos, OutputPos;
ULONG x, y;
UCHAR b;
ULONG Length;
Delta = (BitmapInfoHeader->biWidth + 1) >> 1;
OutputBuffer = ExAllocatePool(NonPagedPool, Delta * BitmapInfoHeader->biHeight);
RtlZeroMemory(OutputBuffer, Delta * BitmapInfoHeader->biHeight);
OutputPos = InputPos = 0;
Buffer += bfOffBits;
while (InputPos < BitmapInfoHeader->biSizeImage &&
OutputPos < Delta * BitmapInfoHeader->biHeight * 2)
{
Length = Buffer[InputPos++];
if (Length > 0)
{
/* Encoded mode */
b = Buffer[InputPos++];
if (OutputPos % 2)
{
OutputBuffer[OutputPos >> 1] |= b & 0xf;
b = (b >> 4) | (b << 4);
Length--;
OutputPos++;
}
memset(OutputBuffer + (OutputPos >> 1), b, Length / 2);
OutputPos += Length;
if (Length & 1)
{
OutputBuffer[OutputPos >> 1] |= b & 0xf;
OutputPos++;
}
}
else
{
/* Absolute mode */
b = Buffer[InputPos++];
if (b == 0)
{
/* End of line */
if (OutputPos % Delta)
OutputPos = ((OutputPos / Delta) + 1) * Delta;
}
else if (b == 1)
{
/* End of image */
break;
}
else if (b == 2)
{
x = Buffer[InputPos++];
y = Buffer[InputPos++];
OutputPos = ((OutputPos / Delta) + y) * Delta +
((OutputPos % Delta) + x);
}
else
{
Length = b;
if (Length)
{
if (OutputPos % 2)
{
ASSERT(FALSE);
}
for (Index = 0; Index < (Length / 2); Index++)
{
b = Buffer[InputPos++];
OutputBuffer[OutputPos >> 1] = b;
OutputPos += 2;
}
if (Length & 1)
{
b = Buffer[InputPos++];
OutputBuffer[OutputPos >> 1] |= b >> 4;
OutputPos++;
}
}
/* Word align */
InputPos += (InputPos & 1);
}
}
}
VidBufferToScreenBlt(OutputBuffer +
(Delta * (BitmapInfoHeader->biHeight - 1)),
0, 0, BitmapInfoHeader->biWidth,
BitmapInfoHeader->biHeight, -Delta);
ExFreePool(OutputBuffer);
}
else
{
Delta = ((BitmapInfoHeader->biWidth + 31) & ~31) >> 1;
if (BitmapInfoHeader->biHeight < 0)
{
VidBufferToScreenBlt(Buffer + bfOffBits,
0, 0, BitmapInfoHeader->biWidth,
-BitmapInfoHeader->biHeight, Delta);
}
else
{
VidBufferToScreenBlt(Buffer + bfOffBits +
(Delta * (BitmapInfoHeader->biHeight - 1)),
0, 0, BitmapInfoHeader->biWidth,
BitmapInfoHeader->biHeight, -Delta);
}
}
}
static VOID NTAPI
VidVgaSolidColorFill(
IN ULONG Left,
IN ULONG Top,
IN ULONG Right,
IN ULONG Bottom,
IN ULONG Color)
{
ULONG x, y;
ULONG VidOffset;
for (x = Left; x <= Right; x++)
{
WRITE_PORT_UCHAR(GRAPHICS, 0x08);
WRITE_PORT_UCHAR(GRAPHICSDATA, VidpMaskBit[x]);
VidOffset = (x >> 3) + (Top * 80);
for (y = Top; y <= Bottom; y++)
{
READ_REGISTER_UCHAR(VidpMemory + VidOffset);
WRITE_REGISTER_UCHAR(VidpMemory + VidOffset, Color & 0xF);
VidOffset += 80;
}
}
}
static VOID NTAPI
VidVgaDisplayString(
IN PUCHAR String)
{
}
VID_FUNCTION_TABLE VidVgaTable =
{
VidVgaInitialize,
VidVgaCleanUp,
VidVgaResetDisplay,
VidVgaBufferToScreenBlt,
VidVgaScreenToBufferBlt,
VidVgaBitBlt,
VidVgaSolidColorFill,
VidVgaDisplayString
};

251
reactos/drivers/base/bootvid/vid_vgatext.c Normal file
View file

@ -0,0 +1,251 @@
/*
* ReactOS Boot video driver
*
* Copyright (C) 2005 Filip Navara
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* INCLUDES ******************************************************************/
#include "bootvid.h"
#define NDEBUG
#include <debug.h>
/* TYPES AND DEFINITIONS *****************************************************/
/* VGA registers */
#define MISC (PUCHAR)0x3c2
#define SEQ (PUCHAR)0x3c4
#define SEQDATA (PUCHAR)0x3c5
#define CRTC (PUCHAR)0x3d4
#define CRTCDATA (PUCHAR)0x3d5
#define GRAPHICS (PUCHAR)0x3ce
#define GRAPHICSDATA (PUCHAR)0x3cf
#define ATTRIB (PUCHAR)0x3c0
#define STATUS (PUCHAR)0x3da
#define PELMASK (PUCHAR)0x3c6
#define PELINDEX (PUCHAR)0x3c8
#define PELDATA (PUCHAR)0x3c9
#define CRTC_COLUMNS 0x01
#define CRTC_OVERFLOW 0x07
#define CRTC_ROWS 0x12
#define CRTC_SCANLINES 0x09
#define CRTC_CURHI 0x0e
#define CRTC_CURLO 0x0f
#define CHAR_ATTRIBUTE_BLACK 0x00 /* black on black */
#define CHAR_ATTRIBUTE 0x1F /* grey on blue */
/* GLOBALS *******************************************************************/
static BOOLEAN VidpInitialized = FALSE;
static PUCHAR VidpMemory;
static ULONG SizeX, SizeY;
/* FUNCTIONS *****************************************************************/
static VOID NTAPI
VidpVgaTextClearDisplay(VOID)
{
WORD *ptr = (WORD*)VidpMemory;
ULONG i;
for (i = 0; i < SizeX * SizeY; i++, ptr++)
*ptr = (0x1700 + ' ');
}
static BOOLEAN NTAPI
VidVgaTextInitialize(
IN BOOLEAN SetMode)
{
ULONG ScanLines;
PHYSICAL_ADDRESS PhysicalAddress;
UCHAR Data;
if (!VidpInitialized)
{
PhysicalAddress.QuadPart = 0xB8000;
VidpMemory = MmMapIoSpace(PhysicalAddress, 0x2000, MmNonCached);
if (VidpMemory == NULL)
return FALSE;
VidpInitialized = TRUE;
WRITE_PORT_UCHAR(CRTC, CRTC_COLUMNS);
SizeX = READ_PORT_UCHAR(CRTCDATA) + 1;
WRITE_PORT_UCHAR(CRTC, CRTC_ROWS);
SizeY = READ_PORT_UCHAR(CRTCDATA);
WRITE_PORT_UCHAR(CRTC, CRTC_OVERFLOW);
Data = READ_PORT_UCHAR(CRTCDATA);
SizeY |= (((Data & 0x02) << 7) | ((Data & 0x40) << 3));
SizeY++;
WRITE_PORT_UCHAR(CRTC, CRTC_SCANLINES);
ScanLines = (READ_PORT_UCHAR(CRTCDATA) & 0x1F) + 1;
SizeY = SizeY / ScanLines;
VidpVgaTextClearDisplay();
WRITE_PORT_UCHAR(CRTC, CRTC_CURLO);
WRITE_PORT_UCHAR(CRTCDATA, 0);
WRITE_PORT_UCHAR(CRTC, CRTC_CURHI);
WRITE_PORT_UCHAR(CRTCDATA, 0);
}
return TRUE;
}
static VOID NTAPI
VidVgaTextResetDisplay(VOID)
{
VidVgaTextInitialize(TRUE);
}
static VOID NTAPI
VidVgaTextCleanUp(VOID)
{
if (VidpInitialized)
{
MmUnmapIoSpace(VidpMemory, 0x10000);
VidpInitialized = FALSE;
}
}
static VOID NTAPI
VidVgaTextBufferToScreenBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
}
static VOID NTAPI
VidVgaTextScreenToBufferBlt(
OUT PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
}
static VOID NTAPI
VidVgaTextBitBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top)
{
}
static VOID NTAPI
VidVgaTextSolidColorFill(
IN ULONG Left,
IN ULONG Top,
IN ULONG Right,
IN ULONG Bottom,
IN ULONG Color)
{
}
static VOID NTAPI
VidpVgaTextScrollDisplay(VOID)
{
PUSHORT ptr;
int i;
ptr = (PUSHORT)VidpMemory + SizeX;
RtlMoveMemory(VidpMemory, ptr, SizeX * (SizeY - 1) * 2);
ptr = (PUSHORT)VidpMemory + (SizeX * (SizeY - 1));
for (i = 0; i < (int)SizeX; i++, ptr++)
*ptr = (CHAR_ATTRIBUTE << 8) + ' ';
}
static VOID NTAPI
VidVgaTextDisplayString(
IN PUCHAR String)
{
PCH pch;
int offset;
ULONG CursorX;
ULONG CursorY;
pch = String;
WRITE_PORT_UCHAR(CRTC, CRTC_CURHI);
offset = READ_PORT_UCHAR(CRTCDATA) << 8;
WRITE_PORT_UCHAR(CRTC, CRTC_CURLO);
offset += READ_PORT_UCHAR(CRTCDATA);
CursorY = offset / SizeX;
CursorX = offset % SizeX;
while (*pch != 0)
{
if (*pch == '\n')
{
CursorY++;
CursorX = 0;
}
else if (*pch == '\b')
{
if (CursorX > 0)
CursorX--;
}
else if (*pch != '\r')
{
PUSHORT ptr;
ptr = (PUSHORT)VidpMemory + ((CursorY * SizeX) + CursorX);
*ptr = (CHAR_ATTRIBUTE << 8) + *pch;
CursorX++;
if (CursorX >= SizeX)
{
CursorY++;
CursorX = 0;
}
}
if (CursorY >= SizeY)
{
VidpVgaTextScrollDisplay();
CursorY = SizeY - 1;
}
pch++;
}
offset = (CursorY * SizeX) + CursorX;
WRITE_PORT_UCHAR(CRTC, CRTC_CURLO);
WRITE_PORT_UCHAR(CRTCDATA, (UCHAR)(offset & 0xff));
WRITE_PORT_UCHAR(CRTC, CRTC_CURHI);
WRITE_PORT_UCHAR(CRTCDATA, (UCHAR)((offset >> 8) & 0xff));
}
VID_FUNCTION_TABLE VidVgaTextTable = {
VidVgaTextInitialize,
VidVgaTextCleanUp,
VidVgaTextResetDisplay,
VidVgaTextBufferToScreenBlt,
VidVgaTextScreenToBufferBlt,
VidVgaTextBitBlt,
VidVgaTextSolidColorFill,
VidVgaTextDisplayString
};

101
reactos/drivers/base/bootvid/vid_xbox.c Normal file
View file

@ -0,0 +1,101 @@
/*
* ReactOS Boot video driver
*
* Copyright (C) 2005 Filip Navara
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* INCLUDES ******************************************************************/
#include "bootvid.h"
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
static BOOLEAN NTAPI
VidXboxInitialize(
IN BOOLEAN SetMode)
{
return TRUE;
}
static VOID NTAPI
VidXboxResetDisplay(VOID)
{
}
static VOID NTAPI
VidXboxCleanUp(VOID)
{
}
static VOID NTAPI
VidXboxBufferToScreenBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
}
static VOID NTAPI
VidXboxScreenToBufferBlt(
OUT PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Delta)
{
}
static VOID NTAPI
VidXboxBitBlt(
IN PUCHAR Buffer,
IN ULONG Left,
IN ULONG Top)
{
}
static VOID NTAPI
VidXboxSolidColorFill(
IN ULONG Left,
IN ULONG Top,
IN ULONG Right,
IN ULONG Bottom,
IN ULONG Color)
{
}
static VOID NTAPI
VidXboxDisplayString(
IN PUCHAR String)
{
}
VID_FUNCTION_TABLE VidXboxTable = {
VidXboxInitialize,
VidXboxCleanUp,
VidXboxResetDisplay,
VidXboxBufferToScreenBlt,
VidXboxScreenToBufferBlt,
VidXboxBitBlt,
VidXboxSolidColorFill,
VidXboxDisplayString
};

15
reactos/drivers/video/videoprt/dispatch.c
View file

@ -22,8 +22,6 @@
#include "videoprt.h"
/* EXTERNAL FUNCTIONS *********************************************************/
/* GLOBAL VARIABLES ***********************************************************/
PVIDEO_PORT_DEVICE_EXTENSION ResetDisplayParametersDeviceExtension = NULL;
@ -174,8 +172,10 @@ IntVideoPortDispatchClose(
if (DeviceExtension->DeviceOpened >= 1 &&
InterlockedDecrement((PLONG)&DeviceExtension->DeviceOpened) == 0)
{
ResetDisplayParametersDeviceExtension = NULL;
InbvNotifyDisplayOwnershipLost(NULL);
ResetDisplayParametersDeviceExtension = DeviceExtension;
HalReleaseDisplayOwnership();
IntVideoPortResetDisplayParameters(80, 50);
}
Irp->IoStatus.Status = STATUS_SUCCESS;
@ -290,15 +290,18 @@ IntVideoPortDispatchWrite(
/*
* Storing the device extension pointer in a static variable is an
* ugly hack. Unfortunately, we need it in VideoPortResetDisplayParameters
* and HalAcquireDisplayOwnership doesn't allow us to pass a userdata
* ugly hack. Unfortunately, we need it in IntVideoPortResetDisplayParameters
* and InbvNotifyDisplayOwnershipLost doesn't allow us to pass a userdata
* parameter. On the bright side, the DISPLAY device is opened
* exclusively, so there can be only one device extension active at
* any point in time.
*
* FIXME: We should process all opened display devices in
* IntVideoPortResetDisplayParameters.
*/
ResetDisplayParametersDeviceExtension = DeviceExtension;
HalAcquireDisplayOwnership(IntVideoPortResetDisplayParameters);
InbvNotifyDisplayOwnershipLost(IntVideoPortResetDisplayParameters);
nErrCode = STATUS_SUCCESS;
Irp->IoStatus.Information = piosStack->Parameters.Write.Length;

3
reactos/hal/hal/hal.def
View file

@ -101,6 +101,3 @@ WRITE_PORT_BUFFER_USHORT@12
WRITE_PORT_UCHAR@8
WRITE_PORT_ULONG@8
WRITE_PORT_USHORT@8
HalReleaseDisplayOwnership@0
HalQueryDisplayOwnership@0

736
reactos/hal/halx86/generic/display.c
View file

@ -16,646 +16,14 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/hal/x86/display.c
* PURPOSE: Blue screen display
* PROGRAMMER: Eric Kohl (ekohl@rz-online.de)
* UPDATE HISTORY:
* Created 08/10/99
*/
/*
* Portions of this code are from the XFree86 Project and available from the
* following license:
*
* Copyright (C) 1994-2003 The XFree86 Project, Inc. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
* NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the XFree86 Project shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization from the
* XFree86 Project.
*/
/* DISPLAY OWNERSHIP
*
* So, who owns the physical display and is allowed to write to it?
*
* In MS NT, upon boot HAL owns the display. Somewhere in the boot
* sequence (haven't figured out exactly where or by who), some
* component calls HalAcquireDisplayOwnership. From that moment on,
* the display is owned by that component and is switched to graphics
* mode. The display is not supposed to return to text mode, except
* in case of a bug check. The bug check will call HalDisplayString
* to output a string to the text screen. HAL will notice that it
* currently doesn't own the display and will re-take ownership, by
* calling the callback function passed to HalAcquireDisplayOwnership.
* After the bugcheck, execution is halted. So, under NT, the only
* possible sequence of display modes is text mode -> graphics mode ->
* text mode (the latter hopefully happening very infrequently).
*
* Things are a little bit different in the current state of ReactOS.
* We want to have a functional interactive text mode. We should be
* able to switch from text mode to graphics mode when a GUI app is
* started and switch back to text mode when it's finished. Then, when
* another GUI app is started, another switch to and from graphics mode
* is possible. Also, when the system bugchecks in graphics mode we want
* to switch back to text mode to show the registers and stack trace.
* Last but not least, HalDisplayString is used a lot more in ReactOS,
* e.g. to print debug messages when the /DEBUGPORT=SCREEN boot option
* is present.
* 3 Components are involved in Reactos: HAL, BLUE.SYS and VIDEOPRT.SYS.
* As in NT, on boot HAL owns the display. When entering the text mode
* command interpreter, BLUE.SYS kicks in. It will write directly to the
* screen, more or less behind HALs back.
* When a GUI app is started, WIN32K.SYS will open the DISPLAY device.
* This open call will end up in VIDEOPRT.SYS. That component will then
* take ownership of the display by calling HalAcquireDisplayOwnership.
* When the GUI app terminates (WIN32K.SYS will close the DISPLAY device),
* we want to give ownership of the display back to HAL. Using the
* standard exported HAL functions, that's a bit of a problem, because
* there is no function defined to do that. In NT, this is handled by
* HalDisplayString, but that solution isn't satisfactory in ReactOS,
* because HalDisplayString is (in some cases) also used to output debug
* messages. If we do it the NT way, the first debug message output while
* in graphics mode would switch the display back to text mode.
* So, instead, if HalDisplayString detects that HAL doesn't have ownership
* of the display, it doesn't do anything.
* To return ownership to HAL, a new function is exported,
* HalReleaseDisplayOwnership. This function is called by the DISPLAY
* device Close routine in VIDEOPRT.SYS. It is also called at the beginning
* of a bug check, so HalDisplayString is activated again.
* Now, while the display is in graphics mode (not owned by HAL), BLUE.SYS
* should also refrain from writing to the screen buffer. The text mode
* screen buffer might overlap the graphics mode screen buffer, so changing
* something in the text mode buffer might mess up the graphics screen. To
* allow BLUE.SYS to detect if HAL owns the display, another new function is
* exported, HalQueryDisplayOwnership. BLUE.SYS will call this function to
* check if it's allowed to touch the text mode buffer.
*
* In an ideal world, when HAL takes ownership of the display, it should set
* up the CRT using real-mode (actually V86 mode, but who cares) INT 0x10
* calls. Unfortunately, this will require HAL to setup a real-mode interrupt
* table etc. So, we chickened out of that by having the loader set up the
* display before switching to protected mode. If HAL is given back ownership
* after a GUI app terminates, the INT 0x10 calls are made by VIDEOPRT.SYS,
* since there is already support for them via the VideoPortInt10 routine.
*/
#include <hal.h>
#define NDEBUG
#include <debug.h>
#define SCREEN_SYNCHRONIZATION
#define VGA_GRAPH_MEM 0xa0000
#define VGA_CHAR_MEM 0xb8000
#define VGA_END_MEM 0xbffff
#define VGA_AC_INDEX 0x3c0
#define VGA_AC_READ 0x3c1
#define VGA_AC_WRITE 0x3c0
#define VGA_MISC_WRITE 0x3c2
#define VGA_SEQ_INDEX 0x3c4
#define VGA_SEQ_DATA 0x3c5
#define VGA_DAC_MASK 0x3c6
#define VGA_DAC_READ_INDEX 0x3c7
#define VGA_DAC_WRITE_INDEX 0x3c8
#define VGA_DAC_DATA 0x3c9
#define VGA_FEATURE_READ 0x3ca
#define VGA_MISC_READ 0x3cc
#define VGA_GC_INDEX 0x3ce
#define VGA_GC_DATA 0x3cf
#define VGA_CRTC_INDEX 0x3d4
#define VGA_CRTC_DATA 0x3d5
#define VGA_INSTAT_READ 0x3da
#define VGA_SEQ_NUM_REGISTERS 5
#define VGA_CRTC_NUM_REGISTERS 25
#define VGA_GC_NUM_REGISTERS 9
#define VGA_AC_NUM_REGISTERS 21
#define CRTC_COLUMNS 0x01
#define CRTC_OVERFLOW 0x07
#define CRTC_ROWS 0x12
#define CRTC_SCANLINES 0x09
#define CRTC_CURHI 0x0e
#define CRTC_CURLO 0x0f
#define CHAR_ATTRIBUTE_BLACK 0x00 /* black on black */
#define CHAR_ATTRIBUTE 0x17 /* grey on blue */
#define FONT_AMOUNT (8*8192)
/* VARIABLES ****************************************************************/
static ULONG CursorX = 0; /* Cursor Position */
static ULONG CursorY = 0;
static ULONG SizeX = 80; /* Display size */
static ULONG SizeY = 25;
static BOOLEAN DisplayInitialized = FALSE;
static BOOLEAN HalOwnsDisplay = TRUE;
static PUSHORT VideoBuffer = NULL;
static PUCHAR GraphVideoBuffer = NULL;
static PHAL_RESET_DISPLAY_PARAMETERS HalResetDisplayParameters = NULL;
static UCHAR SavedTextPalette[768];
static UCHAR SavedTextMiscOutReg;
static UCHAR SavedTextCrtcReg[VGA_CRTC_NUM_REGISTERS];
static UCHAR SavedTextAcReg[VGA_AC_NUM_REGISTERS];
static UCHAR SavedTextGcReg[VGA_GC_NUM_REGISTERS];
static UCHAR SavedTextSeqReg[VGA_SEQ_NUM_REGISTERS];
static UCHAR SavedTextFont[2][FONT_AMOUNT];
static BOOLEAN TextPaletteEnabled = FALSE;
/* PRIVATE FUNCTIONS *********************************************************/
VOID FASTCALL
HalClearDisplay (UCHAR CharAttribute)
{
WORD *ptr = (WORD*)VideoBuffer;
ULONG i;
for (i = 0; i < SizeX * SizeY; i++, ptr++)
*ptr = ((CharAttribute << 8) + ' ');
CursorX = 0;
CursorY = 0;
}
/* STATIC FUNCTIONS *********************************************************/
VOID STATIC
HalScrollDisplay (VOID)
{
PUSHORT ptr;
int i;
ptr = VideoBuffer + SizeX;
RtlMoveMemory(VideoBuffer,
ptr,
SizeX * (SizeY - 1) * 2);
ptr = VideoBuffer + (SizeX * (SizeY - 1));
for (i = 0; i < (int)SizeX; i++, ptr++)
{
*ptr = (CHAR_ATTRIBUTE << 8) + ' ';
}
}
VOID STATIC FASTCALL
HalPutCharacter (CHAR Character)
{
PUSHORT ptr;
ptr = VideoBuffer + ((CursorY * SizeX) + CursorX);
*ptr = (CHAR_ATTRIBUTE << 8) + Character;
}
VOID STATIC
HalDisablePalette(VOID)
{
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, 0x20);
TextPaletteEnabled = FALSE;
}
VOID STATIC
HalEnablePalette(VOID)
{
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, 0x00);
TextPaletteEnabled = TRUE;
}
UCHAR STATIC FASTCALL
HalReadGc(ULONG Index)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_GC_INDEX, (UCHAR)Index);
return(READ_PORT_UCHAR((PUCHAR)VGA_GC_DATA));
}
VOID STATIC FASTCALL
HalWriteGc(ULONG Index, UCHAR Value)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_GC_INDEX, (UCHAR)Index);
WRITE_PORT_UCHAR((PUCHAR)VGA_GC_DATA, Value);
}
UCHAR STATIC FASTCALL
HalReadSeq(ULONG Index)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_SEQ_INDEX, (UCHAR)Index);
return(READ_PORT_UCHAR((PUCHAR)VGA_SEQ_DATA));
}
VOID STATIC FASTCALL
HalWriteSeq(ULONG Index, UCHAR Value)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_SEQ_INDEX, (UCHAR)Index);
WRITE_PORT_UCHAR((PUCHAR)VGA_SEQ_DATA, Value);
}
VOID STATIC FASTCALL
HalWriteAc(ULONG Index, UCHAR Value)
{
if (TextPaletteEnabled)
{
Index &= ~0x20;
}
else
{
Index |= 0x20;
}
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, (UCHAR)Index);
WRITE_PORT_UCHAR((PUCHAR)VGA_AC_WRITE, Value);
}
UCHAR STATIC FASTCALL
HalReadAc(ULONG Index)
{
if (TextPaletteEnabled)
{
Index &= ~0x20;
}
else
{
Index |= 0x20;
}
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, (UCHAR)Index);
return(READ_PORT_UCHAR((PUCHAR)VGA_AC_READ));
}
VOID STATIC FASTCALL
HalWriteCrtc(ULONG Index, UCHAR Value)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, (UCHAR)Index);
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, Value);
}
UCHAR STATIC FASTCALL
HalReadCrtc(ULONG Index)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, (UCHAR)Index);
return(READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA));
}
VOID STATIC FASTCALL
HalResetSeq(BOOLEAN Start)
{
if (Start)
{
HalWriteSeq(0x00, 0x01);
}
else
{
HalWriteSeq(0x00, 0x03);
}
}
VOID STATIC FASTCALL
HalBlankScreen(BOOLEAN On)
{
UCHAR Scrn;
Scrn = HalReadSeq(0x01);
if (On)
{
Scrn &= ~0x20;
}
else
{
Scrn |= 0x20;
}
HalResetSeq(TRUE);
HalWriteSeq(0x01, Scrn);
HalResetSeq(FALSE);
}
VOID STATIC
HalSaveFont(VOID)
{
UCHAR Attr10;
UCHAR MiscOut, Gc4, Gc5, Gc6, Seq2, Seq4;
ULONG i;
/* Check if we are already in graphics mode. */
Attr10 = HalReadAc(0x10);
if (Attr10 & 0x01)
{
return;
}
/* Save registers. */
MiscOut = READ_PORT_UCHAR((PUCHAR)VGA_MISC_READ);
Gc4 = HalReadGc(0x04);
Gc5 = HalReadGc(0x05);
Gc6 = HalReadGc(0x06);
Seq2 = HalReadSeq(0x02);
Seq4 = HalReadSeq(0x04);
/* Force colour mode. */
WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, (UCHAR)(MiscOut | 0x01));
HalBlankScreen(FALSE);
for (i = 0; i < 2; i++)
{
/* Save font 1 */
HalWriteSeq(0x02, (UCHAR)(0x04 << i)); /* Write to plane 2 or 3 */
HalWriteSeq(0x04, 0x06); /* Enable plane graphics. */
HalWriteGc(0x04, (UCHAR)(0x02 + i)); /* Read plane 2 or 3 */
HalWriteGc(0x05, 0x00); /* Write mode 0; read mode 0 */
HalWriteGc(0x06, 0x05); /* Set graphics. */
memcpy(SavedTextFont[i], GraphVideoBuffer, FONT_AMOUNT);
}
/* Restore registers. */
HalWriteAc(0x10, Attr10);
HalWriteSeq(0x02, Seq2);
HalWriteSeq(0x04, Seq4);
HalWriteGc(0x04, Gc4);
HalWriteGc(0x05, Gc5);
HalWriteGc(0x06, Gc6);
WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, MiscOut);
HalBlankScreen(TRUE);
}
VOID STATIC
HalSaveMode(VOID)
{
ULONG i;
SavedTextMiscOutReg = READ_PORT_UCHAR((PUCHAR)VGA_MISC_READ);
for (i = 0; i < VGA_CRTC_NUM_REGISTERS; i++)
{
SavedTextCrtcReg[i] = HalReadCrtc(i);
}
HalEnablePalette();
for (i = 0; i < VGA_AC_NUM_REGISTERS; i++)
{
SavedTextAcReg[i] = HalReadAc(i);
}
HalDisablePalette();
for (i = 0; i < VGA_GC_NUM_REGISTERS; i++)
{
SavedTextGcReg[i] = HalReadGc(i);
}
for (i = 0; i < VGA_SEQ_NUM_REGISTERS; i++)
{
SavedTextSeqReg[i] = HalReadSeq(i);
}
}
VOID STATIC
HalDacDelay(VOID)
{
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
(VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
}
VOID STATIC
HalSavePalette(VOID)
{
ULONG i;
WRITE_PORT_UCHAR((PUCHAR)VGA_DAC_MASK, 0xFF);
WRITE_PORT_UCHAR((PUCHAR)VGA_DAC_READ_INDEX, 0x00);
for (i = 0; i < 768; i++)
{
SavedTextPalette[i] = READ_PORT_UCHAR((PUCHAR)VGA_DAC_DATA);
HalDacDelay();
}
}
VOID STATIC
HalRestoreFont(VOID)
{
UCHAR MiscOut, Attr10, Gc1, Gc3, Gc4, Gc5, Gc6, Gc8;
UCHAR Seq2, Seq4;
ULONG i;
/* Save registers. */
MiscOut = READ_PORT_UCHAR((PUCHAR)VGA_MISC_READ);
Attr10 = HalReadAc(0x10);
Gc1 = HalReadGc(0x01);
Gc3 = HalReadGc(0x03);
Gc4 = HalReadGc(0x04);
Gc5 = HalReadGc(0x05);
Gc6 = HalReadGc(0x06);
Gc8 = HalReadGc(0x08);
Seq2 = HalReadSeq(0x02);
Seq4 = HalReadSeq(0x04);
/* Force into colour mode. */
WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, (UCHAR)(MiscOut | 0x10));
HalBlankScreen(FALSE);
HalWriteGc(0x03, 0x00); /* Don't rotate; write unmodified. */
HalWriteGc(0x08, 0xFF); /* Write all bits. */
HalWriteGc(0x01, 0x00); /* All planes from CPU. */
for (i = 0; i < 2; i++)
{
HalWriteSeq(0x02, (UCHAR)(0x04 << i)); /* Write to plane 2 or 3 */
HalWriteSeq(0x04, 0x06); /* Enable plane graphics. */
HalWriteGc(0x04, (UCHAR)(0x02 + i)); /* Read plane 2 or 3 */
HalWriteGc(0x05, 0x00); /* Write mode 0; read mode 0. */
HalWriteGc(0x06, 0x05); /* Set graphics. */
memcpy(GraphVideoBuffer, SavedTextFont[i], FONT_AMOUNT);
}
HalBlankScreen(TRUE);
/* Restore registers. */
WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, MiscOut);
HalWriteAc(0x10, Attr10);
HalWriteGc(0x01, Gc1);
HalWriteGc(0x03, Gc3);
HalWriteGc(0x04, Gc4);
HalWriteGc(0x05, Gc5);
HalWriteGc(0x06, Gc6);
HalWriteGc(0x08, Gc8);
HalWriteSeq(0x02, Seq2);
HalWriteSeq(0x04, Seq4);
}
VOID STATIC
HalRestoreMode(VOID)
{
ULONG i;
WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, SavedTextMiscOutReg);
for (i = 1; i < VGA_SEQ_NUM_REGISTERS; i++)
{
HalWriteSeq(i, SavedTextSeqReg[i]);
}
/* Unlock CRTC registers 0-7 */
HalWriteCrtc(17, (UCHAR)(SavedTextCrtcReg[17] & ~0x80));
for (i = 0; i < VGA_CRTC_NUM_REGISTERS; i++)
{
HalWriteCrtc(i, SavedTextCrtcReg[i]);
}
for (i = 0; i < VGA_GC_NUM_REGISTERS; i++)
{
HalWriteGc(i, SavedTextGcReg[i]);
}
HalEnablePalette();
for (i = 0; i < VGA_AC_NUM_REGISTERS; i++)
{
HalWriteAc(i, SavedTextAcReg[i]);
}
HalDisablePalette();
}
VOID STATIC
HalRestorePalette(VOID)
{
ULONG i;
WRITE_PORT_UCHAR((PUCHAR)VGA_DAC_MASK, 0xFF);
WRITE_PORT_UCHAR((PUCHAR)VGA_DAC_WRITE_INDEX, 0x00);
for (i = 0; i < 768; i++)
{
WRITE_PORT_UCHAR((PUCHAR)VGA_DAC_DATA, SavedTextPalette[i]);
HalDacDelay();
}
HalDisablePalette();
}
/* PRIVATE FUNCTIONS ********************************************************/
VOID FASTCALL
HalInitializeDisplay (PLOADER_PARAMETER_BLOCK LoaderBlock)
/*
* FUNCTION: Initalize the display
* ARGUMENTS:
* InitParameters = Parameters setup by the boot loader
*/
{
PHYSICAL_ADDRESS PhysBuffer;
if (! DisplayInitialized)
{
ULONG ScanLines;
ULONG Data;
PhysBuffer.u.HighPart = 0;
PhysBuffer.u.LowPart = VGA_GRAPH_MEM;
GraphVideoBuffer = MmMapIoSpace(PhysBuffer, VGA_END_MEM - VGA_GRAPH_MEM + 1, MmNonCached);
if (NULL == GraphVideoBuffer)
{
return;
}
VideoBuffer = (PUSHORT) (GraphVideoBuffer + (VGA_CHAR_MEM - VGA_GRAPH_MEM));
/* Set cursor position */
// CursorX = LoaderBlock->cursorx;
// CursorY = LoaderBlock->cursory;
CursorX = 0;
CursorY = 0;
/* read screen size from the crtc */
/* FIXME: screen size should be read from the boot parameters */
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_COLUMNS);
SizeX = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA) + 1;
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_ROWS);
SizeY = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_OVERFLOW);
Data = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
SizeY |= (((Data & 0x02) << 7) | ((Data & 0x40) << 3));
SizeY++;
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_SCANLINES);
ScanLines = (READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA) & 0x1F) + 1;
SizeY = SizeY / ScanLines;
#ifdef BOCHS_30ROWS
SizeY=30;
#endif
HalClearDisplay(CHAR_ATTRIBUTE_BLACK);
DisplayInitialized = TRUE;
/*
Save the VGA state at this point so we can restore it on a bugcheck.
*/
HalSavePalette();
HalSaveMode();
HalSaveFont();
}
}
#include <ndk/inbvfuncs.h>
/* PUBLIC FUNCTIONS *********************************************************/
VOID STDCALL
HalReleaseDisplayOwnership(VOID)
/*
* FUNCTION: Release ownership of display back to HAL
*/
{
if (HalResetDisplayParameters == NULL)
return;
if (HalOwnsDisplay == TRUE)
return;
if (!HalResetDisplayParameters(SizeX, SizeY))
{
HalRestoreMode();
HalRestoreFont();
HalRestorePalette();
}
HalOwnsDisplay = TRUE;
HalClearDisplay(CHAR_ATTRIBUTE);
}
VOID STDCALL
HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters)
/*
@ -665,12 +33,11 @@ HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParamete
* reset routine.
*/
{
HalOwnsDisplay = FALSE;
HalResetDisplayParameters = ResetDisplayParameters;
}
VOID STDCALL
HalDisplayString(IN PCH String)
HalDisplayString(
IN PCH String)
/*
* FUNCTION: Switches the screen to HAL console mode (BSOD) if not there
* already and displays a string
@ -680,85 +47,7 @@ HalDisplayString(IN PCH String)
* mode
*/
{
PCH pch;
#ifdef SCREEN_SYNCHRONIZATION
int offset;
#endif
static KSPIN_LOCK Lock;
KIRQL OldIrql;
ULONG Flags;
/* See comment at top of file */
if (! HalOwnsDisplay || ! DisplayInitialized)
{
return;
}
pch = String;
OldIrql = KfRaiseIrql(HIGH_LEVEL);
KiAcquireSpinLock(&Lock);
Ki386SaveFlags(Flags);
Ki386DisableInterrupts();
#ifdef SCREEN_SYNCHRONIZATION
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURHI);
offset = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA)<<8;
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURLO);
offset += READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
CursorY = offset / SizeX;
CursorX = offset % SizeX;
#endif
while (*pch != 0)
{
if (*pch == '\n')
{
CursorY++;
CursorX = 0;
}
else if (*pch == '\b')
{
if (CursorX > 0)
{
CursorX--;
}
}
else if (*pch != '\r')
{
HalPutCharacter (*pch);
CursorX++;
if (CursorX >= SizeX)
{
CursorY++;
CursorX = 0;
}
}
if (CursorY >= SizeY)
{
HalScrollDisplay ();
CursorY = SizeY - 1;
}
pch++;
}
#ifdef SCREEN_SYNCHRONIZATION
offset = (CursorY * SizeX) + CursorX;
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURLO);
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, (UCHAR)(offset & 0xff));
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURHI);
WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, (UCHAR)((offset >> 8) & 0xff));
#endif
Ki386RestoreFlags(Flags);
KiReleaseSpinLock(&Lock);
KfLowerIrql(OldIrql);
InbvDisplayString(String);
}
VOID STDCALL
@ -767,14 +56,6 @@ HalQueryDisplayParameters(OUT PULONG DispSizeX,
OUT PULONG CursorPosX,
OUT PULONG CursorPosY)
{
if (DispSizeX)
*DispSizeX = SizeX;
if (DispSizeY)
*DispSizeY = SizeY;
if (CursorPosX)
*CursorPosX = CursorX;
if (CursorPosY)
*CursorPosY = CursorY;
}
@ -782,15 +63,6 @@ VOID STDCALL
HalSetDisplayParameters(IN ULONG CursorPosX,
IN ULONG CursorPosY)
{
CursorX = (CursorPosX < SizeX) ? CursorPosX : SizeX - 1;
CursorY = (CursorPosY < SizeY) ? CursorPosY : SizeY - 1;
}
BOOLEAN STDCALL
HalQueryDisplayOwnership(VOID)
{
return !HalOwnsDisplay;
}
/* EOF */

23
reactos/hal/halx86/generic/dma.c
View file

@ -1565,6 +1565,9 @@ IoFlushAdapterBuffers(
{
BOOLEAN SlaveDma = FALSE;
PROS_MAP_REGISTER_ENTRY RealMapRegisterBase;
PHYSICAL_ADDRESS HighestAcceptableAddress;
PHYSICAL_ADDRESS PhysicalAddress;
PPFN_NUMBER MdlPagesPtr;
ASSERT_IRQL(DISPATCH_LEVEL);
@ -1601,16 +1604,25 @@ IoFlushAdapterBuffers(
{
if (SlaveDma && !AdapterObject->IgnoreCount)
Length -= HalReadDmaCounter(AdapterObject);
}
HalpCopyBufferMap(Mdl, RealMapRegisterBase, CurrentVa, Length, FALSE);
}
}
else
{
/* FIXME: Unimplemented case */
ASSERT(FALSE);
MdlPagesPtr = MmGetMdlPfnArray(Mdl);
MdlPagesPtr += ((ULONG_PTR)CurrentVa - (ULONG_PTR)Mdl->StartVa) >> PAGE_SHIFT;
PhysicalAddress.QuadPart = *MdlPagesPtr << PAGE_SHIFT;
PhysicalAddress.QuadPart += BYTE_OFFSET(CurrentVa);
HighestAcceptableAddress = HalpGetAdapterMaximumPhysicalAddress(AdapterObject);
if (PhysicalAddress.QuadPart + Length >
HighestAcceptableAddress.QuadPart)
{
HalpCopyBufferMap(Mdl, RealMapRegisterBase, CurrentVa, Length, FALSE);
}
}
}
RealMapRegisterBase->Counter = 0;
@ -1793,11 +1805,12 @@ IoMapTransfer(
HighestAcceptableAddress.QuadPart)
{
UseMapRegisters = TRUE;
PhysicalAddress = RealMapRegisterBase->PhysicalAddress;
PhysicalAddress = RealMapRegisterBase[Counter].PhysicalAddress;
PhysicalAddress.QuadPart += ByteOffset;
if ((ULONG_PTR)MapRegisterBase & MAP_BASE_SW_SG)
{
RealMapRegisterBase->Counter = ~0;
Counter = 0;
}
}
}

8
reactos/hal/halx86/generic/halinit.c
View file

@ -46,7 +46,6 @@ HalInitSystem (ULONG BootPhase,
//HalpInitPhase1();
/* Initialize display and make the screen black */
HalInitializeDisplay (LoaderBlock);
HalpInitBusHandlers();
HalpInitDma();
@ -55,12 +54,7 @@ HalInitSystem (ULONG BootPhase,
}
else if (BootPhase == 2)
{
PHYSICAL_ADDRESS Null = {{0}};
/* Go to blue screen */
HalClearDisplay (0x17); /* grey on blue */
HalpZeroPageMapping = MmMapIoSpace(Null, PAGE_SIZE, MmNonCached);
HalpZeroPageMapping = MmMapIoSpace((LARGE_INTEGER)0LL, PAGE_SIZE, MmNonCached);
}
return TRUE;

5
reactos/hal/halx86/include/halp.h
View file

@ -17,11 +17,6 @@ typedef struct _KD_PORT_INFORMATION
ULONG BaudRate;
ULONG BaseAddress;
} KD_PORT_INFORMATION, *PKD_PORT_INFORMATION;
/* display.c */
VOID FASTCALL HalInitializeDisplay (struct _LOADER_PARAMETER_BLOCK *LoaderBlock);
VOID FASTCALL HalClearDisplay (UCHAR CharAttribute);
/* adapter.c */
PADAPTER_OBJECT STDCALL HalpAllocateAdapterEx(ULONG NumberOfMapRegisters,BOOLEAN IsMaster, BOOLEAN Dma32BitAddresses);

16
reactos/ntoskrnl/ex/init.c
View file

@ -786,6 +786,9 @@ ExpInitializeExecutive(IN ULONG Cpu,
/* Set up Region Maps, Sections and the Paging File */
MmInit2();
/* Initialize the boot video. */
InbvDisplayInitialize();
/* Initialize the Process Manager */
if (!PsInitSystem()) KEBUGCHECK(PROCESS_INITIALIZATION_FAILED);
@ -832,6 +835,10 @@ ExPhase2Init(PVOID Context)
/* Check if GUI Boot is enabled */
if (strstr(KeLoaderBlock->LoadOptions, "NOGUIBOOT")) NoGuiBoot = TRUE;
/* Display the boot screen image if not disabled */
if (!ExpInTextModeSetup) InbvDisplayInitialize2(NoGuiBoot);
if (!NoGuiBoot) InbvDisplayBootLogo();
/* Clear the screen to blue and display the boot notice and debug status */
HalInitSystem(2, KeLoaderBlock);
if (NoGuiBoot) ExpDisplayNotice();
@ -923,9 +930,6 @@ ExPhase2Init(PVOID Context)
/* Initialize the I/O Subsystem */
if (!IoInitSystem(KeLoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
/* Display the boot screen image if not disabled */
if (!NoGuiBoot) InbvEnableBootDriver(TRUE);
/* Unmap Low memory, and initialize the MPW and Balancer Thread */
MmInit3();
@ -955,12 +959,6 @@ ExPhase2Init(PVOID Context)
ZwClose(ThreadHandle);
ZwClose(ProcessHandle);
/*
* FIXME: FILIP!
* Disable the Boot Logo
*/
if (!NoGuiBoot) InbvEnableBootDriver(FALSE);
/* FIXME: We should free the initial process' memory!*/
/* Increase init phase */

11
reactos/ntoskrnl/ex/power.c
View file

@ -142,7 +142,16 @@ ShutdownThreadMain(PVOID Context)
/* Run the thread on the boot processor */
KeSetSystemAffinityThread(1);
HalReleaseDisplayOwnership();
if (InbvIsBootDriverInstalled())
{
InbvAcquireDisplayOwnership();
InbvResetDisplay();
InbvSolidColorFill(0, 0, 639, 479, 4);
InbvSetTextColor(15);
InbvInstallDisplayStringFilter(NULL);
InbvEnableDisplayString(TRUE);
InbvSetScrollRegion(0, 0, 639, 479);
}
if (Action == ShutdownNoReboot)
{

434
reactos/ntoskrnl/inbv/inbv.c
View file

@ -11,242 +11,340 @@
/* INCLUDES ******************************************************************/
#include <ntoskrnl.h>
#include "../../drivers/base/bootvid/ntbootvid.h"
#define NDEBUG
#include <internal/debug.h>
#if defined (ALLOC_PRAGMA)
#pragma alloc_text(INIT, InbvEnableBootDriver)
#pragma alloc_text(INIT, InbvDisplayInitialize)
#endif
/* ROS Internal. Please deprecate */
NTHALAPI
VOID
NTAPI
HalReleaseDisplayOwnership(VOID);
/* GLOBALS *******************************************************************/
/* DATA **********************************************************************/
static HANDLE BootVidDevice = NULL;
static BOOLEAN BootVidDriverInstalled = FALSE;
static NTBOOTVID_FUNCTION_TABLE BootVidFunctionTable;
static BOOLEAN (NTAPI *VidInitialize)(BOOLEAN);
static VOID (NTAPI *VidCleanUp)(VOID);
static VOID (NTAPI *VidResetDisplay)(VOID);
static VOID (NTAPI *VidBufferToScreenBlt)(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
static VOID (NTAPI *VidScreenToBufferBlt)(PUCHAR, ULONG, ULONG, ULONG, ULONG, ULONG);
static VOID (NTAPI *VidBitBlt)(PUCHAR, ULONG, ULONG);
static VOID (NTAPI *VidSolidColorFill)(ULONG, ULONG, ULONG, ULONG, ULONG);
static VOID (NTAPI *VidDisplayString)(PUCHAR);
static NTSTATUS (NTAPI *BootVidDisplayBootLogo)(PVOID);
static VOID (NTAPI *BootVidUpdateProgress)(ULONG Progress);
static VOID (NTAPI *BootVidFinalizeBootLogo)(VOID);
static KSPIN_LOCK InbvLock;
static KIRQL InbvOldIrql;
static ULONG InbvDisplayState = 0;
static PHAL_RESET_DISPLAY_PARAMETERS InbvResetDisplayParameters = NULL;
static PVOID BootVidBase;
/* FUNCTIONS *****************************************************************/
NTSTATUS
static
InbvCheckBootVid(VOID)
VOID NTAPI INIT_FUNCTION
InbvDisplayInitialize(VOID)
{
IO_STATUS_BLOCK Iosb;
struct {
ANSI_STRING Name;
PVOID *Ptr;
} Exports[] = {
{ RTL_CONSTANT_STRING("VidInitialize"), (PVOID*)&VidInitialize },
{ RTL_CONSTANT_STRING("VidCleanUp"), (PVOID*)&VidCleanUp },
{ RTL_CONSTANT_STRING("VidResetDisplay"), (PVOID*)&VidResetDisplay },
{ RTL_CONSTANT_STRING("VidBufferToScreenBlt"), (PVOID*)&VidBufferToScreenBlt },
{ RTL_CONSTANT_STRING("VidScreenToBufferBlt"), (PVOID*)&VidScreenToBufferBlt },
{ RTL_CONSTANT_STRING("VidBitBlt"), (PVOID*)&VidBitBlt },
{ RTL_CONSTANT_STRING("VidSolidColorFill"), (PVOID*)&VidSolidColorFill },
{ RTL_CONSTANT_STRING("VidDisplayString"), (PVOID*)&VidDisplayString },
{ RTL_CONSTANT_STRING("BootVidDisplayBootLogo"), (PVOID*)&BootVidDisplayBootLogo },
{ RTL_CONSTANT_STRING("BootVidUpdateProgress"), (PVOID*)&BootVidUpdateProgress },
{ RTL_CONSTANT_STRING("BootVidFinalizeBootLogo"), (PVOID*)&BootVidFinalizeBootLogo }
};
UNICODE_STRING BootVidPath = RTL_CONSTANT_STRING(L"bootvid.sys");
PLDR_DATA_TABLE_ENTRY ModuleObject = NULL, LdrEntry;
ULONG Index;
NTSTATUS Status;
if (BootVidDevice == NULL)
{
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING BootVidName = RTL_CONSTANT_STRING(L"\\Device\\BootVid");
/* FIXME: Hack, try to search for boot driver. */
#if 0
ModuleObject = LdrGetModuleObject(&BootVidPath);
#else
{
NTSTATUS LdrProcessModule(PVOID, PUNICODE_STRING, PLDR_DATA_TABLE_ENTRY*);
PLIST_ENTRY ListHead, NextEntry;
InitializeObjectAttributes(&ObjectAttributes,
&BootVidName,
0,
NULL,
NULL);
Status = ZwOpenFile(&BootVidDevice,
FILE_ALL_ACCESS,
&ObjectAttributes,
&Iosb,
0,
0);
if (!NT_SUCCESS(Status))
{
return(Status);
}
}
return(STATUS_SUCCESS);
ListHead = &KeLoaderBlock->LoadOrderListHead;
NextEntry = ListHead->Flink;
while (ListHead != NextEntry)
{
/* Get the entry */
LdrEntry = CONTAINING_RECORD(NextEntry,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
/* Compare names */
if (RtlEqualUnicodeString(&LdrEntry->BaseDllName, &BootVidPath, TRUE))
{
/* Tell, that the module is already loaded */
LdrEntry->Flags |= LDRP_ENTRY_INSERTED;
Status = LdrProcessModule(LdrEntry->DllBase,
&BootVidPath,
&ModuleObject);
if (!NT_SUCCESS(Status))
{
DPRINT1("%x\n", Status);
return;
}
break;
}
/* Go to the next driver */
NextEntry= NextEntry->Flink;
}
}
#endif
if (ModuleObject != NULL)
{
for (Index = 0; Index < sizeof(Exports) / sizeof(Exports[0]); Index++)
{
Status = LdrGetProcedureAddress(ModuleObject->DllBase,
&Exports[Index].Name, 0,
Exports[Index].Ptr);
if (!NT_SUCCESS(Status))
return;
}
DPRINT1("Done!\n");
KeInitializeSpinLock(&InbvLock);
BootVidBase = ModuleObject->DllBase;
BootVidDriverInstalled = TRUE;
}
}
VOID
STDCALL
InbvAcquireDisplayOwnership(VOID)
static VOID NTAPI
InbvAcquireLock(VOID)
{
if ((InbvOldIrql = KeGetCurrentIrql()) < DISPATCH_LEVEL)
InbvOldIrql = KfRaiseIrql(DISPATCH_LEVEL);
KiAcquireSpinLock(&InbvLock);
}
BOOLEAN
STDCALL
InbvCheckDisplayOwnership(VOID)
static VOID NTAPI
InbvReleaseLock(VOID)
{
return FALSE;
KiReleaseSpinLock(&InbvLock);
if (InbvOldIrql < DISPATCH_LEVEL)
KfLowerIrql(InbvOldIrql);
}
BOOLEAN
STDCALL
InbvDisplayString(IN PCHAR String)
{
/* Call Bootvid (we don't support bootvid for now)
* vidDisplayString(String);
* so instead, we'll fall-back to HAL
*/
HalDisplayString(String);
/* Call Headless (We don't support headless for now)
HeadlessDispatch(DISPLAY_STRING);
*/
/* Return success */
return TRUE;
}
BOOLEAN
STDCALL
InbvResetDisplayParameters(ULONG SizeX,
ULONG SizeY)
{
return(InbvResetDisplay());
}
VOID
STDCALL
INIT_FUNCTION
VOID STDCALL
InbvEnableBootDriver(IN BOOLEAN Enable)
{
NTSTATUS Status;
IO_STATUS_BLOCK Iosb;
if (BootVidDriverInstalled)
{
if (InbvDisplayState >= 2)
return;
InbvAcquireLock();
if (InbvDisplayState == 0)
VidCleanUp();
InbvDisplayState = !Enable;
InbvReleaseLock();
}
else
{
InbvDisplayState = !Enable;
}
}
Status = InbvCheckBootVid();
if (!NT_SUCCESS(Status))
{
return;
}
VOID NTAPI
InbvAcquireDisplayOwnership(VOID)
{
if (InbvResetDisplayParameters && InbvDisplayState == 2)
{
if (InbvResetDisplayParameters != NULL)
InbvResetDisplayParameters(80, 50);
}
InbvDisplayState = 0;
}
if (Enable)
{
/* Notify the hal we will acquire the display. */
HalAcquireDisplayOwnership(InbvResetDisplayParameters);
BOOLEAN STDCALL
InbvCheckDisplayOwnership(VOID)
{
return InbvDisplayState != 2;
}
Status = ZwDeviceIoControlFile(BootVidDevice,
NULL,
NULL,
NULL,
&Iosb,
IOCTL_BOOTVID_INITIALIZE,
NULL,
0,
&BootVidFunctionTable,
sizeof(BootVidFunctionTable));
if (!NT_SUCCESS(Status))
{
KEBUGCHECK(0);
}
BootVidDriverInstalled = TRUE;
CHECKPOINT;
}
else
{
Status = ZwDeviceIoControlFile(BootVidDevice,
NULL,
NULL,
NULL,
&Iosb,
IOCTL_BOOTVID_CLEANUP,
NULL,
0,
NULL,
0);
if (!NT_SUCCESS(Status))
{
KEBUGCHECK(0);
}
BootVidDriverInstalled = FALSE;
/* Notify the hal we have released the display. */
HalReleaseDisplayOwnership();
}
BOOLEAN STDCALL
InbvDisplayString(IN PCHAR String)
{
if (BootVidDriverInstalled && InbvDisplayState == 0)
{
InbvAcquireLock();
VidDisplayString(String);
InbvReleaseLock();
ZwClose(BootVidDevice);
BootVidDevice = NULL;
/* Call Headless (We don't support headless for now)
HeadlessDispatch(DISPLAY_STRING);
*/
return TRUE;
}
return FALSE;
}
BOOLEAN
STDCALL
BOOLEAN STDCALL
InbvEnableDisplayString(IN BOOLEAN Enable)
{
return FALSE;
return FALSE;
}
VOID
STDCALL
VOID STDCALL
InbvInstallDisplayStringFilter(IN PVOID Unknown)
{
}
BOOLEAN
STDCALL
BOOLEAN STDCALL
InbvIsBootDriverInstalled(VOID)
{
return(BootVidDriverInstalled);
return BootVidDriverInstalled;
}
VOID
STDCALL
InbvNotifyDisplayOwnershipLost(IN PVOID Callback)
VOID STDCALL
InbvNotifyDisplayOwnershipLost(
IN PVOID Callback)
{
if (BootVidDriverInstalled)
{
InbvAcquireLock();
if (InbvDisplayState != 2)
VidCleanUp();
else if (InbvResetDisplayParameters != NULL)
InbvResetDisplayParameters(80, 50);
InbvResetDisplayParameters = Callback;
InbvDisplayState = 2;
InbvReleaseLock();
}
else
{
InbvResetDisplayParameters = Callback;
InbvDisplayState = 2;
}
}
BOOLEAN
STDCALL
BOOLEAN STDCALL
InbvResetDisplay(VOID)
{
if (!BootVidDriverInstalled)
{
return(FALSE);
}
return(BootVidFunctionTable.ResetDisplay());
if (BootVidDriverInstalled && InbvDisplayState == 0)
{
VidResetDisplay();
return TRUE;
}
return FALSE;
}
VOID
STDCALL
InbvSetScrollRegion(IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height)
VOID STDCALL
InbvSetScrollRegion(
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height)
{
}
VOID
STDCALL
InbvSetTextColor(IN ULONG Color)
VOID STDCALL
InbvSetTextColor(
IN ULONG Color)
{
}
VOID
STDCALL
InbvSolidColorFill(IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Color)
VOID STDCALL
InbvSolidColorFill(
IN ULONG Left,
IN ULONG Top,
IN ULONG Width,
IN ULONG Height,
IN ULONG Color)
{
if (BootVidDriverInstalled && InbvDisplayState == 0)
{
VidSolidColorFill(Left, Top, Width, Height, Color);
}
}
NTSTATUS
STDCALL
NtDisplayString(IN PUNICODE_STRING DisplayString)
BOOLEAN NTAPI
BootVidResetDisplayParameters(ULONG SizeX, ULONG SizeY)
{
OEM_STRING OemString;
RtlUnicodeStringToOemString(&OemString, DisplayString, TRUE);
HalDisplayString(OemString.Buffer);
RtlFreeOemString(&OemString);
return STATUS_SUCCESS;
BootVidFinalizeBootLogo();
return TRUE;
}
VOID NTAPI
InbvDisplayInitialize2(BOOLEAN NoGuiBoot)
{
VidInitialize(!NoGuiBoot);
}
VOID NTAPI
InbvDisplayBootLogo(VOID)
{
InbvEnableBootDriver(TRUE);
if (BootVidDriverInstalled)
{
InbvResetDisplayParameters = BootVidResetDisplayParameters;
BootVidDisplayBootLogo(BootVidBase);
}
}
VOID NTAPI
InbvUpdateProgressBar(
IN ULONG Progress)
{
if (BootVidDriverInstalled)
{
BootVidUpdateProgress(Progress);
}
}
VOID NTAPI
InbvFinalizeBootLogo(VOID)
{
if (BootVidDriverInstalled)
{
/* Notify the hal we have released the display. */
/* InbvReleaseDisplayOwnership(); */
BootVidFinalizeBootLogo();
InbvEnableBootDriver(FALSE);
}
}
NTSTATUS STDCALL
NtDisplayString(
IN PUNICODE_STRING DisplayString)
{
OEM_STRING OemString;
RtlUnicodeStringToOemString(&OemString, DisplayString, TRUE);
InbvDisplayString(OemString.Buffer);
RtlFreeOemString(&OemString);
return STATUS_SUCCESS;
}

18
reactos/ntoskrnl/include/internal/inbv.h
View file

@ -7,9 +7,21 @@
/* FUNCTIONS *****************************************************************/
BOOLEAN
NTAPI
InbvDisplayString(IN PCHAR String);
VOID NTAPI INIT_FUNCTION
InbvDisplayInitialize(VOID);
VOID NTAPI
InbvDisplayInitialize2(BOOLEAN NoGuiBoot);
VOID NTAPI
InbvDisplayBootLogo(VOID);
VOID NTAPI
InbvUpdateProgressBar(ULONG Progress);
VOID NTAPI
InbvFinalizeBootLogo(VOID);
#endif /* NTOSKRNL_INBV_H */

2
reactos/ntoskrnl/kdbg/kdb.c
View file

@ -1140,7 +1140,7 @@ KdbpInternalEnter()
KbdDisableMouse();
if (KdpDebugMode.Screen)
{
HalReleaseDisplayOwnership();
InbvAcquireDisplayOwnership();
}
/* Call the interface's main loop on a different stack */

24
reactos/ntoskrnl/ke/bug.c
View file

@ -16,14 +16,6 @@
#pragma alloc_text(INIT, KiInitializeBugCheck)
#endif
/* ROS Internal. Please deprecate */
NTHALAPI
VOID
NTAPI
HalReleaseDisplayOwnership(
VOID
);
/* GLOBALS *******************************************************************/
LIST_ENTRY BugcheckCallbackListHead;
@ -435,8 +427,6 @@ KiDisplayBlueScreen(IN ULONG MessageId,
{
CHAR AnsiName[75];
/* FIXMEs: Use inbv to clear, fill and write to screen. */
/* Check if this is a hard error */
if (IsHardError)
{
@ -847,8 +837,18 @@ KeBugCheckWithTf(IN ULONG BugCheckCode,
}
}
/* Switching back to the blue screen so we print messages on it */
HalReleaseDisplayOwnership();
/* Use the boot video driver to clear, fill and write to screen. */
if (InbvIsBootDriverInstalled())
{
/* FIXME: This should happen in KiDisplayBlueScreen!!! */
InbvAcquireDisplayOwnership();
InbvResetDisplay();
InbvSolidColorFill(0, 0, 639, 479, 4);
InbvSetTextColor(15);
InbvInstallDisplayStringFilter(NULL);
InbvEnableDisplayString(TRUE);
InbvSetScrollRegion(0, 0, 639, 479);
}
/* Raise IRQL to HIGH_LEVEL */
Ke386DisableInterrupts();

35
reactos/subsystems/win32/csrss/win32csr/conio.c
View file

@ -16,10 +16,6 @@
/* FIXME: Is there a way to create real aliasses with gcc? [CSH] */
#define ALIAS(Name, Target) typeof(Target) Name = Target
/* Private user32 routines for CSRSS, not defined in any header file */
extern VOID STDCALL PrivateCsrssRegisterPrimitive(VOID);
extern VOID STDCALL PrivateCsrssAcquireOrReleaseInputOwnership(BOOL Release);
/* GLOBALS *******************************************************************/
#define ConioInitRect(Rect, Top, Left, Bottom, Right) \
@ -1422,37 +1418,6 @@ ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode)
}
}
DWORD STDCALL
Console_Api (PVOID unused)
{
/* keep reading events from the keyboard and stuffing them into the current
console's input queue */
MSG msg;
/* This call establishes our message queue */
PeekMessageW(&msg, 0, 0, 0, PM_NOREMOVE);
/* This call registers our message queue */
PrivateCsrssRegisterPrimitive();
/* This call turns on the input system in win32k */
PrivateCsrssAcquireOrReleaseInputOwnership(FALSE);
while (TRUE)
{
GetMessageW(&msg, 0, 0, 0);
TranslateMessage(&msg);
if (msg.message == WM_CHAR || msg.message == WM_SYSCHAR ||
msg.message == WM_KEYDOWN || msg.message == WM_KEYUP ||
msg.message == WM_SYSKEYDOWN || msg.message == WM_SYSKEYUP)
{
ConioProcessKey(&msg, TuiGetFocusConsole(), TRUE);
}
}
PrivateCsrssAcquireOrReleaseInputOwnership(TRUE);
return 0;
}
CSR_API(CsrGetScreenBufferInfo)
{
NTSTATUS Status;

9
reactos/subsystems/win32/csrss/win32csr/dllmain.c
View file

@ -170,20 +170,11 @@ Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
PCSRSS_EXPORTED_FUNCS Exports,
HANDLE CsrssApiHeap)
{
HANDLE ThreadHandle;
CsrExports = *Exports;
Win32CsrApiHeap = CsrssApiHeap;
PrivateCsrssManualGuiCheck(0);
CsrInitConsoleSupport();
ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) Console_Api, NULL, 0, NULL);
if (NULL == ThreadHandle)
{
DPRINT1("CSR: Unable to create console thread\n");
return FALSE;
}
CloseHandle(ThreadHandle);
*ApiDefinitions = Win32CsrApiDefinitions;
*ObjectDefinitions = Win32CsrObjectDefinitions;

84
reactos/subsystems/win32/csrss/win32csr/tuiconsole.c
View file

@ -18,11 +18,28 @@ static PCSRSS_CONSOLE ActiveConsole;
static BOOL ConsInitialized = FALSE;
static LRESULT CALLBACK
TuiConsoleWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_ACTIVATE)
{
CHECKPOINT1;
if (LOWORD(wParam) != WA_INACTIVE)
{
CHECKPOINT1;
SetFocus(hWnd);
ConioDrawConsole(ActiveConsole);
}
}
return DefWindowProcW(hWnd, msg, wParam, lParam);
}
static BOOL FASTCALL
TuiInit(VOID)
{
CONSOLE_SCREEN_BUFFER_INFO ScrInfo;
DWORD BytesReturned;
WNDCLASSEXW wc;
ConsoleDeviceHandle = CreateFileW(L"\\\\.\\BlueScreen", FILE_ALL_ACCESS, 0, NULL,
OPEN_EXISTING, 0, NULL);
@ -42,6 +59,17 @@ TuiInit(VOID)
}
PhysicalConsoleSize = ScrInfo.dwSize;
RtlZeroMemory(&wc, sizeof(WNDCLASSEXW));
wc.cbSize = sizeof(WNDCLASSEXW);
wc.lpszClassName = L"TuiConsoleWindowClass";
wc.lpfnWndProc = TuiConsoleWndProc;
wc.hInstance = (HINSTANCE) GetModuleHandleW(NULL);
if (RegisterClassExW(&wc) == 0)
{
DPRINT1("Failed to register console wndproc\n");
return FALSE;
}
return TRUE;
}
@ -194,6 +222,8 @@ TuiChangeTitle(PCSRSS_CONSOLE Console)
static VOID STDCALL
TuiCleanupConsole(PCSRSS_CONSOLE Console)
{
DestroyWindow(Console->hWindow);
EnterCriticalSection(&ActiveConsoleLock);
/* Switch to next console */
@ -215,6 +245,47 @@ TuiCleanupConsole(PCSRSS_CONSOLE Console)
}
}
DWORD STDCALL
TuiConsoleThread (PVOID Data)
{
PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Data;
HWND NewWindow;
MSG msg;
NewWindow = CreateWindowW(L"TuiConsoleWindowClass",
Console->Title.Buffer,
0,
-32000, -32000, 0, 0,
NULL, NULL,
(HINSTANCE) GetModuleHandleW(NULL),
(PVOID) Console);
Console->hWindow = NewWindow;
if (NULL == NewWindow)
{
DPRINT1("CSR: Unable to create console window\n");
return 1;
}
SetForegroundWindow(Console->hWindow);
while (TRUE)
{
GetMessageW(&msg, 0, 0, 0);
DispatchMessage(&msg);
TranslateMessage(&msg);
if (msg.message == WM_CHAR || msg.message == WM_SYSCHAR ||
msg.message == WM_KEYDOWN || msg.message == WM_KEYUP ||
msg.message == WM_SYSKEYDOWN || msg.message == WM_SYSKEYUP)
{
CHECKPOINT1;
ConioProcessKey(&msg, Console, TRUE);
}
}
return 0;
}
static CSRSS_CONSOLE_VTBL TuiVtbl =
{
TuiInitScreenBuffer,
@ -229,6 +300,8 @@ static CSRSS_CONSOLE_VTBL TuiVtbl =
NTSTATUS FASTCALL
TuiInitConsole(PCSRSS_CONSOLE Console)
{
HANDLE ThreadHandle;
if (! ConsInitialized)
{
ConsInitialized = TRUE;
@ -240,11 +313,20 @@ TuiInitConsole(PCSRSS_CONSOLE Console)
}
Console->Vtbl = &TuiVtbl;
Console->hWindow = (HWND) NULL;
Console->hWindow = NULL;
Console->Size = PhysicalConsoleSize;
Console->ActiveBuffer->MaxX = PhysicalConsoleSize.X;
Console->ActiveBuffer->MaxY = PhysicalConsoleSize.Y;
ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) TuiConsoleThread,
Console, 0, NULL);
if (NULL == ThreadHandle)
{
DPRINT1("CSR: Unable to create console thread\n");
return STATUS_UNSUCCESSFUL;
}
CloseHandle(ThreadHandle);
EnterCriticalSection(&ActiveConsoleLock);
if (NULL != ActiveConsole)
{

4
reactos/subsystems/win32/win32k/include/painting.h
View file

@ -5,10 +5,10 @@
#include <include/msgqueue.h>
#include <include/window.h>
VOID FASTCALL
IntValidateParent(PWINDOW_OBJECT Child, HRGN ValidRegion);
BOOL FASTCALL
co_UserRedrawWindow(PWINDOW_OBJECT Wnd, const RECT* UpdateRect, HRGN UpdateRgn, ULONG Flags);
VOID FASTCALL
IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags);
BOOL FASTCALL
IntGetPaintMessage(HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, PW32THREAD Thread,
MSG *Message, BOOL Remove);

5
reactos/subsystems/win32/win32k/include/userfuncs.h
View file

@ -88,11 +88,6 @@ PVOID UserGetNextHandle(PUSER_HANDLE_TABLE ht, HANDLE* handle, USER_OBJECT_TYPE
HWINSTA FASTCALL UserGetProcessWindowStation(VOID);
/*************** INPUT.C ***************/
NTSTATUS FASTCALL
UserAcquireOrReleaseInputOwnership(BOOLEAN Release);
/*************** WINPOS.C ***************/
BOOL FASTCALL

12
reactos/subsystems/win32/win32k/ntuser/focus.c
View file

@ -89,6 +89,7 @@ co_IntSendActivateMessages(HWND hWndPrev, HWND hWnd, BOOL MouseActivate)
/* FIXME: IntIsWindow */
CHECKPOINT1;
co_IntPostOrSendMessage(hWnd, WM_NCACTIVATE, (WPARAM)(hWnd == UserGetForegroundWindow()), 0);
/* FIXME: WA_CLICKACTIVE */
co_IntPostOrSendMessage(hWnd, WM_ACTIVATE,
@ -158,7 +159,8 @@ co_IntSetForegroundAndFocusWindow(PWINDOW_OBJECT Window, PWINDOW_OBJECT FocusWin
return FALSE;
}
if (0 == (Window->Style & WS_VISIBLE))
if (0 == (Window->Style & WS_VISIBLE) &&
Window->OwnerThread->ThreadsProcess != CsrProcess)
{
DPRINT("Failed - Invisible\n");
return FALSE;
@ -172,7 +174,7 @@ co_IntSetForegroundAndFocusWindow(PWINDOW_OBJECT Window, PWINDOW_OBJECT FocusWin
if (hWndPrev == hWnd)
{
DPRINT("Failed - Same\n");
DPRINT1("Failed - Same\n");
return TRUE;
}
@ -200,6 +202,7 @@ co_IntSetForegroundAndFocusWindow(PWINDOW_OBJECT Window, PWINDOW_OBJECT FocusWin
/* FIXME: Send WM_ACTIVATEAPP to all thread windows. */
}
CHECKPOINT1;
co_IntSendSetFocusMessages(hWndFocusPrev, hWndFocus);
co_IntSendActivateMessages(hWndPrev, hWnd, MouseActivate);
@ -272,8 +275,9 @@ co_IntSetActiveWindow(PWINDOW_OBJECT Window OPTIONAL)
if (Window != 0)
{
if (!(Window->Style & WS_VISIBLE) ||
(Window->Style & (WS_POPUP | WS_CHILD)) == WS_CHILD)
if ((!(Window->Style & WS_VISIBLE) &&
Window->OwnerThread->ThreadsProcess != CsrProcess) ||
(Window->Style & (WS_POPUP | WS_CHILD)) == WS_CHILD)
{
return ThreadQueue ? 0 : ThreadQueue->ActiveWindow;
}

40
reactos/subsystems/win32/win32k/ntuser/input.c
View file

@ -48,7 +48,6 @@ static CLIENT_ID KeyboardThreadId;
static HANDLE KeyboardDeviceHandle;
static KEVENT InputThreadsStart;
static BOOLEAN InputThreadsRunning = FALSE;
PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue = 0;
/* FUNCTIONS *****************************************************************/
ULONG FASTCALL
@ -733,9 +732,6 @@ KeyboardThreadMain(PVOID StartContext)
}
/* Find the target thread whose locale is in effect */
if (!IntGetScreenDC())
FocusQueue = W32kGetPrimitiveMessageQueue();
else
FocusQueue = IntGetFocusMessageQueue();
/* This might cause us to lose hot keys, which are important
@ -793,42 +789,10 @@ KeyboardEscape:
}
NTSTATUS FASTCALL
UserAcquireOrReleaseInputOwnership(BOOLEAN Release)
{
if (Release && InputThreadsRunning && !pmPrimitiveMessageQueue)
{
DPRINT( "Releasing input: PM = %08x\n", pmPrimitiveMessageQueue );
KeClearEvent(&InputThreadsStart);
InputThreadsRunning = FALSE;
NtAlertThread(KeyboardThreadHandle);
NtAlertThread(MouseThreadHandle);
}
else if (!Release && !InputThreadsRunning)
{
InputThreadsRunning = TRUE;
KeSetEvent(&InputThreadsStart, IO_NO_INCREMENT, FALSE);
}
return(STATUS_SUCCESS);
}
NTSTATUS STDCALL
NtUserAcquireOrReleaseInputOwnership(BOOLEAN Release)
{
DECLARE_RETURN(NTSTATUS);
DPRINT("Enter NtUserAcquireOrReleaseInputOwnership\n");
UserEnterExclusive();
RETURN(UserAcquireOrReleaseInputOwnership(Release));
CLEANUP:
DPRINT("Leave NtUserAcquireOrReleaseInputOwnership, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
return STATUS_SUCCESS;
}
@ -867,6 +831,8 @@ InitInputImpl(VOID)
DPRINT1("Win32K: Failed to create mouse thread.\n");
}
InputThreadsRunning = TRUE;
KeSetEvent(&InputThreadsStart, IO_NO_INCREMENT, FALSE);
return STATUS_SUCCESS;
}

38
reactos/subsystems/win32/win32k/ntuser/misc.c
View file

@ -17,39 +17,6 @@
/* registered Logon process */
PW32PROCESS LogonProcess = NULL;
VOID W32kRegisterPrimitiveMessageQueue(VOID)
{
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
if( !pmPrimitiveMessageQueue )
{
PW32THREAD pThread;
pThread = PsGetCurrentThreadWin32Thread();
if( pThread && pThread->MessageQueue )
{
pmPrimitiveMessageQueue = pThread->MessageQueue;
IntReferenceMessageQueue(pmPrimitiveMessageQueue);
DPRINT( "Installed primitive input queue.\n" );
}
}
else
{
DPRINT1( "Alert! Someone is trying to steal the primitive queue.\n" );
}
}
VOID W32kUnregisterPrimitiveMessageQueue(VOID)
{
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
IntDereferenceMessageQueue(pmPrimitiveMessageQueue);
pmPrimitiveMessageQueue = NULL;
}
PUSER_MESSAGE_QUEUE W32kGetPrimitiveMessageQueue()
{
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
return pmPrimitiveMessageQueue;
}
BOOL FASTCALL
co_IntRegisterLogonProcess(HANDLE ProcessId, BOOL Register)
{
@ -119,11 +86,6 @@ NtUserCallNoParam(DWORD Routine)
switch(Routine)
{
case NOPARAM_ROUTINE_REGISTER_PRIMITIVE:
W32kRegisterPrimitiveMessageQueue();
Result = (DWORD)TRUE;
break;
case NOPARAM_ROUTINE_DESTROY_CARET:
Result = (DWORD)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
break;

21
reactos/subsystems/win32/win32k/ntuser/msgqueue.c
View file

@ -479,12 +479,6 @@ co_MsqPeekHardwareMessage(PUSER_MESSAGE_QUEUE MessageQueue, HWND hWnd,
DECLARE_RETURN(BOOL);
USER_REFERENCE_ENTRY Ref;
if( !IntGetScreenDC() ||
PsGetCurrentThreadWin32Thread()->MessageQueue == W32kGetPrimitiveMessageQueue() )
{
RETURN(FALSE);
}
WaitObjects[1] = MessageQueue->NewMessages;
WaitObjects[0] = &HardwareMessageQueueLock;
do
@ -719,16 +713,6 @@ co_MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
}
FocusMessageQueue = IntGetFocusMessageQueue();
if( !IntGetScreenDC() )
{
/* FIXME: What to do about Msg.pt here? */
if( W32kGetPrimitiveMessageQueue() )
{
MsqPostMessage(W32kGetPrimitiveMessageQueue(), &Msg, FALSE, QS_KEY);
}
}
else
{
if (FocusMessageQueue == NULL)
{
DPRINT("No focus message queue\n");
@ -748,7 +732,6 @@ co_MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
DPRINT("Invalid focus window handle\n");
}
}
}
VOID FASTCALL
MsqPostHotKeyMessage(PVOID Thread, HWND hWnd, WPARAM wParam, LPARAM lParam)
@ -1511,10 +1494,6 @@ MsqDestroyMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
IntDereferenceMessageQueue(MessageQueue);
}
/* if this is the primitive message queue, deregister it */
if (MessageQueue == W32kGetPrimitiveMessageQueue())
W32kUnregisterPrimitiveMessageQueue();
/* clean it up */
MsqCleanupMessageQueue(MessageQueue);

27
reactos/subsystems/win32/win32k/ntuser/painting.c
View file

@ -81,11 +81,14 @@ IntIntersectWithParents(PWINDOW_OBJECT Child, PRECT WindowRect)
return TRUE;
}
VOID FASTCALL
IntValidateParent(PWINDOW_OBJECT Child, HRGN ValidRegion)
BOOL FASTCALL
IntValidateParent(PWINDOW_OBJECT Child, BOOL Recurse)
{
PWINDOW_OBJECT ParentWindow = Child->Parent;
while (ParentWindow && ParentWindow->Style & WS_CHILD)
ParentWindow = ParentWindow->Parent;
while (ParentWindow)
{
if (ParentWindow->Style & WS_CLIPCHILDREN)
@ -93,13 +96,17 @@ IntValidateParent(PWINDOW_OBJECT Child, HRGN ValidRegion)
if (ParentWindow->UpdateRegion != 0)
{
NtGdiCombineRgn(ParentWindow->UpdateRegion, ParentWindow->UpdateRegion,
ValidRegion, RGN_DIFF);
/* FIXME: If the resulting region is empty, remove fake posted paint message */
if (Recurse)
return FALSE;
IntInvalidateWindows(ParentWindow, Child->UpdateRegion,
RDW_VALIDATE | RDW_NOCHILDREN);
}
ParentWindow = ParentWindow->Parent;
}
return TRUE;
}
/**
@ -219,7 +226,7 @@ IntGetNCUpdateRgn(PWINDOW_OBJECT Window, BOOL Validate)
*/
static VOID FASTCALL
co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags)
co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags, BOOL Recurse)
{
HDC hDC;
HWND hWnd = Window->hSelf;
@ -229,7 +236,8 @@ co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags)
{
if (Window->UpdateRegion)
{
IntValidateParent(Window, Window->UpdateRegion);
if (!IntValidateParent(Window, Recurse))
return;
}
if (Flags & RDW_UPDATENOW)
@ -290,6 +298,7 @@ co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags)
if ((List = IntWinListChildren(Window)))
{
/* FIXME: Handle WS_EX_TRANSPARENT */
for (phWnd = List; *phWnd; ++phWnd)
{
Window = UserGetWindowObject(*phWnd);
@ -297,7 +306,7 @@ co_IntPaintWindows(PWINDOW_OBJECT Window, ULONG Flags)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Window, &Ref);
co_IntPaintWindows(Window, Flags);
co_IntPaintWindows(Window, Flags, TRUE);
UserDerefObjectCo(Window);
}
}
@ -578,7 +587,7 @@ co_UserRedrawWindow(PWINDOW_OBJECT Window, const RECT* UpdateRect, HRGN UpdateRg
if (Flags & (RDW_ERASENOW | RDW_UPDATENOW))
{
co_IntPaintWindows(Window, Flags);
co_IntPaintWindows(Window, Flags, FALSE);
}
/*

4
reactos/subsystems/win32/win32k/ntuser/winpos.c
View file

@ -133,7 +133,8 @@ BOOL FASTCALL can_activate_window( PWINDOW_OBJECT Wnd OPTIONAL)
if (!Wnd) return FALSE;
style = Wnd->Style;
if (!(style & WS_VISIBLE)) return FALSE;
if (!(style & WS_VISIBLE) &&
Wnd->OwnerThread->ThreadsProcess != CsrProcess) return FALSE;
if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
return !(style & WS_DISABLED);
}
@ -1194,7 +1195,6 @@ co_WinPosSetWindowPos(
CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
CopyRect.top + (OldWindowRect.top - NewWindowRect.top), SRCCOPY, 0, 0);
UserReleaseDC(Window, Dc, FALSE);
IntValidateParent(Window, CopyRgn);
NtGdiOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
}
else if(VisRgn)

3
reactos/subsystems/win32/win32k/ntuser/winsta.c
View file

@ -294,8 +294,6 @@ co_IntInitializeDesktopGraphics(VOID)
}
DC_SetOwnership(ScreenDeviceContext, NULL);
UserAcquireOrReleaseInputOwnership(FALSE);
/* Setup the cursor */
co_IntLoadDefaultCursors();
@ -305,7 +303,6 @@ co_IntInitializeDesktopGraphics(VOID)
VOID FASTCALL
IntEndDesktopGraphics(VOID)
{
UserAcquireOrReleaseInputOwnership(TRUE);
if (NULL != ScreenDeviceContext)
{
DC_SetOwnership(ScreenDeviceContext, PsGetCurrentProcess());

16
reactos/subsystems/win32/win32k/objects/dc.c
View file

@ -2528,7 +2528,6 @@ IntEnumDisplaySettings(
{
if (iModeNum == 0 || CachedDevModes == NULL) /* query modes from drivers */
{
BOOL PrimarySurfaceCreated = FALSE;
UNICODE_STRING DriverFileNames;
LPWSTR CurrentName;
DRVENABLEDATA DrvEnableData;
@ -2541,11 +2540,7 @@ IntEnumDisplaySettings(
return FALSE;
}
if (!HalQueryDisplayOwnership())
{
IntCreatePrimarySurface();
PrimarySurfaceCreated = TRUE;
}
IntPrepareDriverIfNeeded();
/*
* DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
@ -2611,10 +2606,6 @@ IntEnumDisplaySettings(
SizeOfCachedDevModes = 0;
CachedDevModes = NULL;
CachedDevModesEnd = NULL;
if (PrimarySurfaceCreated)
{
IntDestroyPrimarySurface();
}
SetLastWin32Error(STATUS_NO_MEMORY);
return FALSE;
}
@ -2643,11 +2634,6 @@ IntEnumDisplaySettings(
}
}
if (PrimarySurfaceCreated)
{
IntDestroyPrimarySurface();
}
RtlFreeUnicodeString(&DriverFileNames);
}