fsvga.h File Reference

#include "ntddvdeo.h"
#include "fscrnctl.h"
#include "vga.h"

Go to the source code of this file.

Classes
struct	_FSVGA_CONFIGURATION_INFORMATION
struct	_EMULATE_BUFFER_INFORMATION
struct	_DEVICE_EXTENSION
Defines
#define	ENABLE_WORD_WRITE_VRAM   0x01
#define	NO_HARDWARE_CURSOR   0
#define	HARDWARE_CURSOR   0x01
#define	NO_HARDWARE_SCROLL   0
#define	HARDWARE_SCROLL   0x01
#define	USE_LINE_COMPARE   0x02
#define	OFFSET_128_TO_NEXT_SLICE   0x04
#define	LIMIT_64K   0x10000L
#define	FSVGA_ERROR_VALUE_BASE   1000
#define	FSVGA_HARDWARE_PRESENT   1
#define	FsVgaPrint(x)
Typedefs
typedef enum _VGA_IO_PORT_TYPE	VGA_IO_PORT_TYPE
typedef _FSVGA_CONFIGURATION_INFORMATION	FSVGA_CONFIGURATION_INFORMATION
typedef _FSVGA_CONFIGURATION_INFORMATION *	PFSVGA_CONFIGURATION_INFORMATION
typedef _EMULATE_BUFFER_INFORMATION	EMULATE_BUFFER_INFORMATION
typedef _EMULATE_BUFFER_INFORMATION *	PEMULATE_BUFFER_INFORMATION
typedef _DEVICE_EXTENSION	DEVICE_EXTENSION
typedef _DEVICE_EXTENSION *	PDEVICE_EXTENSION
Enumerations
enum	_VGA_IO_PORT_TYPE {   CRTCAddressPortColor = 0, CRTCDataPortColor, GRAPHAddressPort, SEQUAddressPort,   MaximumPortCount }
Functions
NTSTATUS	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID	FsVgaConfiguration (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING KeyboardDeviceName)
NTSTATUS	FsVgaPeripheralCallout (IN PVOID Context, IN PUNICODE_STRING PathName, IN INTERFACE_TYPE BusType, IN ULONG BusNumber, IN PKEY_VALUE_FULL_INFORMATION *BusInformation, IN CONFIGURATION_TYPE ControllerType, IN ULONG ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, IN CONFIGURATION_TYPE PeripheralType, IN ULONG PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation)
VOID	FsVgaServiceParameters (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING FsVgaDeviceName)
VOID	FsVgaBuildResourceList (IN PDEVICE_EXTENSION DeviceExtension, OUT PCM_RESOURCE_LIST *ResourceList, OUT PULONG ResourceListSize)
NTSTATUS	FsVgaOpenCloseDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	FsVgaDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	FsVgaCopyFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_COPY_FRAME_BUFFER CopyFrameBuffer, ULONG inputBufferLength)
NTSTATUS	FsVgaWriteToFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_WRITE_TO_FRAME_BUFFER WriteFrameBuffer, ULONG inputBufferLength)
NTSTATUS	FsVgaReverseMousePointer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_REVERSE_MOUSE_POINTER MouseBuffer, ULONG inputBufferLength)
NTSTATUS	FsVgaSetMode (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_MODE_INFORMATION ModeInformation, ULONG inputBufferLength)
NTSTATUS	FsVgaSetScreenInformation (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_SCREEN_INFORMATION ScreenInformation, ULONG inputBufferLength)
NTSTATUS	FsVgaSetCursorPosition (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_CURSOR_POSITION CursorPosition, ULONG inputBufferLength)
NTSTATUS	FsVgaSetCursorAttribute (PDEVICE_EXTENSION DeviceExtension, PVIDEO_CURSOR_ATTRIBUTES CursorAttributes, ULONG inputBufferLength)
VOID	FsVgaLogError (IN PDEVICE_OBJECT DeviceObject, IN NTSTATUS ErrorCode, IN ULONG UniqueErrorValue, IN NTSTATUS FinalStatus, IN PULONG DumpData, IN ULONG DumpCount)
ULONG	CalcGRAMSize (IN COORD WindowSize, IN PDEVICE_EXTENSION DeviceExtension)
PUCHAR	CalcGRAMAddress (IN COORD WindowSize, IN PDEVICE_EXTENSION DeviceExtension)
BOOL	IsGRAMRowOver (PUCHAR BufPtr, BOOL fDbcs, PDEVICE_EXTENSION DeviceExtension)
PUCHAR	NextGRAMRow (PUCHAR BufPtr, PDEVICE_EXTENSION DeviceExtension)
VOID	memcpyGRAM (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length)
VOID	memcpyGRAMOver (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length, IN PUCHAR FrameBufPtr, IN PDEVICE_EXTENSION DeviceExtension)
VOID	MoveGRAM (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length, IN PUCHAR FrameBufPtr, IN PDEVICE_EXTENSION DeviceExtension)
NTSTATUS	FsgVgaInitializeHWFlags (PDEVICE_EXTENSION DeviceExtension)
NTSTATUS	FsgCopyFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_COPY_FRAME_BUFFER CopyFrameBuffer, ULONG inputBufferLength)
NTSTATUS	FsgWriteToFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_WRITE_TO_FRAME_BUFFER WriteFrameBuffer, ULONG inputBufferLength)
NTSTATUS	FsgReverseMousePointer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_REVERSE_MOUSE_POINTER MouseBuffer, ULONG inputBufferLength)
NTSTATUS	FsgInvertCursor (PDEVICE_EXTENSION DeviceExtension, BOOL Invert)
NTSTATUS	FsgWriteToScreen (PUCHAR FrameBuffer, PUCHAR BitmapBuffer, DWORD cjBytes, BOOL fDbcs, WORD Attributes1, WORD Attributes2, PDEVICE_EXTENSION DeviceExtension)
NTSTATUS	FsgWriteToScreenCommonLVB (PUCHAR FrameBuffer, WORD Attributes, PDEVICE_EXTENSION DeviceExtension)
UCHAR	AccessGRAM_WR (PUCHAR FrameBuffer, UCHAR write)
UCHAR	AccessGRAM_RW (PUCHAR FrameBuffer, UCHAR write)
UCHAR	AccessGRAM_AND (PUCHAR FrameBuffer, UCHAR write)
DWORD	CalcBitmapBufferSize (IN COORD FontSize, IN DWORD dwAlign)
VOID	AlignCopyMemory (OUT PBYTE pDestBits, IN DWORD dwDestAlign, IN PBYTE pSrcBits, IN DWORD dwSrcAlign, IN COORD FontSize)
int	ConvertOutputToOem (IN LPWSTR Source, IN int SourceLength, OUT LPSTR Target, IN int TargetLength)
NTSTATUS	TranslateOutputToOem (OUT PCHAR_IMAGE_INFO OutputBuffer, IN PCHAR_IMAGE_INFO InputBuffer, IN DWORD Length)
VOID	GetHardwareScrollReg (PDEVICE_EXTENSION deviceExtension)
VOID	SetGRAMWriteMode (PDEVICE_EXTENSION deviceExtension)
VOID	SetGRAMCopyMode (PDEVICE_EXTENSION deviceExtension)
VOID	SetGRAMInvertMode (PDEVICE_EXTENSION deviceExtension)
VOID	set_opaque_bkgnd_proc (PDEVICE_EXTENSION deviceExtension, PUCHAR FrameBuffer, WORD Attributes)
VOID	ColorSetGridMask (PDEVICE_EXTENSION deviceExtension, BYTE BitMask)
VOID	ColorSetDirect (PDEVICE_EXTENSION deviceExtension, PUCHAR FrameBuffer, BYTE ColorFg, BYTE ColorBg)

---

Define Documentation

#define ENABLE_WORD_WRITE_VRAM   0x01

Definition at line 50 of file fsvga.h. Referenced by FsgWriteToScreen().

#define FSVGA_ERROR_VALUE_BASE   1000

Definition at line 168 of file fsvga.h. Referenced by DriverEntry(), FsVgaBuildResourceList(), and FsVgaWriteToFrameBuffer().

#define FSVGA_HARDWARE_PRESENT   1

Definition at line 174 of file fsvga.h. Referenced by DriverEntry(), FsVgaConfiguration(), and FsVgaPeripheralCallout().

#define FsVgaPrint (  x   )

Definition at line 310 of file fsvga.h. Referenced by DriverEntry(), FsVgaBuildResourceList(), FsVgaConfiguration(), FsVgaDeviceControl(), FsVgaOpenCloseDispatch(), FsVgaPeripheralCallout(), FsVgaServiceParameters(), and FsVgaWriteToFrameBuffer().

#define HARDWARE_CURSOR   0x01

Definition at line 54 of file fsvga.h.

#define HARDWARE_SCROLL   0x01

Definition at line 58 of file fsvga.h.

#define LIMIT_64K   0x10000L

Definition at line 96 of file fsvga.h. Referenced by FsgVgaInitializeHWFlags().

#define NO_HARDWARE_CURSOR   0

Definition at line 53 of file fsvga.h. Referenced by FsVgaServiceParameters().

#define NO_HARDWARE_SCROLL   0

Definition at line 57 of file fsvga.h. Referenced by FsVgaServiceParameters().

#define OFFSET_128_TO_NEXT_SLICE   0x04

Definition at line 60 of file fsvga.h.

#define USE_LINE_COMPARE   0x02

Definition at line 59 of file fsvga.h. Referenced by FsgVgaInitializeHWFlags().

---

Typedef Documentation

typedef struct _DEVICE_EXTENSION DEVICE_EXTENSION

typedef struct _EMULATE_BUFFER_INFORMATION EMULATE_BUFFER_INFORMATION

typedef struct _FSVGA_CONFIGURATION_INFORMATION FSVGA_CONFIGURATION_INFORMATION

typedef struct _DEVICE_EXTENSION * PDEVICE_EXTENSION

typedef struct _EMULATE_BUFFER_INFORMATION * PEMULATE_BUFFER_INFORMATION

typedef struct _FSVGA_CONFIGURATION_INFORMATION * PFSVGA_CONFIGURATION_INFORMATION

Referenced by FsVgaConfiguration().

typedef enum _VGA_IO_PORT_TYPE VGA_IO_PORT_TYPE

---

Enumeration Type Documentation

enum _VGA_IO_PORT_TYPE

Enumeration values: CRTCAddressPortColor  CRTCDataPortColor  GRAPHAddressPort  SEQUAddressPort  MaximumPortCount  Definition at line 35 of file fsvga.h. { CRTCAddressPortColor = 0, CRTCDataPortColor, GRAPHAddressPort, SEQUAddressPort, MaximumPortCount } VGA_IO_PORT_TYPE;

---

Function Documentation

UCHAR AccessGRAM_AND (  PUCHAR  FrameBuffer, UCHAR  write )

Definition at line 998 of file drawscrn.c. Referenced by FsgInvertCursor(), and FsgReverseMousePointer(). { return *FrameBuffer &= write; }

UCHAR AccessGRAM_RW (  PUCHAR  FrameBuffer, UCHAR  write )

Definition at line 986 of file drawscrn.c. Referenced by FsgWriteToScreenCommonLVB(). { UCHAR tmp; tmp = *FrameBuffer; *FrameBuffer = write; return tmp; }

UCHAR AccessGRAM_WR (  PUCHAR  FrameBuffer, UCHAR  write )

Definition at line 976 of file drawscrn.c. Referenced by ColorSetDirect(). { *FrameBuffer = write; return *FrameBuffer; }

VOID AlignCopyMemory (  OUT PBYTE  pDestBits, IN DWORD  dwDestAlign, IN PBYTE  pSrcBits, IN DWORD  dwSrcAlign, IN COORD  FontSize )

Definition at line 56 of file fullscr/vga/foncache.c. References BITMAP_BITS_BYTE_ALIGN, BITMAP_BITS_WORD_ALIGN, BYTE_ALIGN, CALC_BITMAP_BITS_FOR_X, CalcBitmapBufferSize(), DWORD, EXCEPTION_EXECUTE_HANDLER, and WORD_ALIGN. Referenced by FsgWriteToFrameBuffer(). { DWORD dwDestBufferSize; COORD coord; try { if (dwDestAlign == dwSrcAlign) { dwDestBufferSize = CalcBitmapBufferSize(FontSize, dwDestAlign); RtlCopyMemory(pDestBits, pSrcBits, dwDestBufferSize); return; } switch (dwDestAlign) { default: case WORD_ALIGN: switch (dwSrcAlign) { default: // // pDest = WORD, pSrc = WORD // case WORD_ALIGN: dwDestBufferSize = CalcBitmapBufferSize(FontSize, dwDestAlign); RtlCopyMemory(pDestBits, pSrcBits, dwDestBufferSize); break; // // pDest = WORD, pSrc = BYTE // case BYTE_ALIGN: dwDestBufferSize = CalcBitmapBufferSize(FontSize, dwDestAlign); if (((FontSize.X % BITMAP_BITS_BYTE_ALIGN) == 0) && ((FontSize.X % BITMAP_BITS_WORD_ALIGN) == 0) ) { RtlCopyMemory(pDestBits, pSrcBits, dwDestBufferSize); } else { RtlZeroMemory(pDestBits, dwDestBufferSize); for (coord.Y=0; coord.Y < FontSize.Y; coord.Y++) { for (coord.X=0; coord.X < CALC_BITMAP_BITS_FOR_X(FontSize.X, BITMAP_BITS_BYTE_ALIGN); coord.X++) { *pDestBits++ = *pSrcBits++; } if (CALC_BITMAP_BITS_FOR_X(FontSize.X, BITMAP_BITS_BYTE_ALIGN) & 1) pDestBits++; } } break; } break; case BYTE_ALIGN: switch (dwSrcAlign) { // // pDest = BYTE, pSrc = BYTE // case BYTE_ALIGN: dwDestBufferSize = CalcBitmapBufferSize(FontSize, dwDestAlign); RtlCopyMemory(pDestBits, pSrcBits, dwDestBufferSize); break; default: // // pDest = BYTE, pSrc = WORD // case WORD_ALIGN: dwDestBufferSize = CalcBitmapBufferSize(FontSize, dwDestAlign); if (((FontSize.X % BITMAP_BITS_BYTE_ALIGN) == 0) && ((FontSize.X % BITMAP_BITS_WORD_ALIGN) == 0) ) { RtlCopyMemory(pDestBits, pSrcBits, dwDestBufferSize); } else { RtlZeroMemory(pDestBits, dwDestBufferSize); for (coord.Y=0; coord.Y < FontSize.Y; coord.Y++) { for (coord.X=0; coord.X < CALC_BITMAP_BITS_FOR_X(FontSize.X, BITMAP_BITS_BYTE_ALIGN); coord.X++) { *pDestBits++ = *pSrcBits++; } if (CALC_BITMAP_BITS_FOR_X(FontSize.X, BITMAP_BITS_BYTE_ALIGN) & 1) pSrcBits++; } } break; } break; } } except (EXCEPTION_EXECUTE_HANDLER) { } }

DWORD CalcBitmapBufferSize (  IN COORD  FontSize, IN DWORD  dwAlign )

Definition at line 41 of file fullscr/vga/foncache.c. { DWORD uiCount; uiCount = CALC_BITMAP_BITS_FOR_X(FontSize.X, (dwAlign==BYTE_ALIGN ? BITMAP_BITS_BYTE_ALIGN : BITMAP_BITS_WORD_ALIGN)); uiCount = uiCount * BITMAP_PLANES * FontSize.Y; return uiCount; }

PUCHAR CalcGRAMAddress (  IN COORD  WindowSize, IN PDEVICE_EXTENSION  DeviceExtension )

Definition at line 116 of file drawscrn.c. References CalcGRAMOffs, and DWORD. Referenced by FsgCopyFrameBuffer(), FsgInvertCursor(), FsgReverseMousePointer(), and FsgWriteToFrameBuffer(). : This routine calcurate a graphics buffer address. Arguments: WindowSize - Coord of window size. DeviceExtension - Pointer to the miniport driver's device extension. Return Value: Returen to graphics buffer address. --*/ { PUCHAR BufPtr = (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase; BufPtr += CalcGRAMOffs(WindowSize, DeviceExtension); if ((DWORD)(BufPtr - (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) >= DeviceExtension->EmulateInfo.LimitGRAM) return (BufPtr - DeviceExtension->EmulateInfo.LimitGRAM); else return BufPtr; }

ULONG CalcGRAMSize (  IN COORD  WindowSize, IN PDEVICE_EXTENSION  DeviceExtension )

Definition at line 85 of file drawscrn.c. References CalcGRAMScanLine. : This Macro calcurate a graphics buffer size. Arguments: WindowSize - Coord of window size. DeviceExtension - Pointer to the miniport driver's device extension. Return Value: Returen to graphics buffer offset. --*/ { return WindowSize.X + CalcGRAMScanLine(WindowSize.Y, DeviceExtension->ScreenAndFont.FontSize.Y) * DeviceExtension->EmulateInfo.BytePerLine; }

VOID ColorSetDirect (  PDEVICE_EXTENSION  deviceExtension, PUCHAR  FrameBuffer, BYTE  ColorFg, BYTE  ColorBg )

Definition at line 257 of file port.c. References AccessGRAM_WR(), _DEVICE_EXTENSION::DeviceRegisters, DR_SET, DR_XOR, GRAPH_ADDR_MASK, GRAPHAddressPort, IND_DATA_ROTATE, IND_SET_RESET, and IND_SET_RESET_ENABLE. Referenced by FsgWriteToScreenCommonLVB(), and set_opaque_bkgnd_proc(). { // // Set up to write data without interacting with the latches. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_SET)); // // Put the background color in the Set/Reset register. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET, ColorBg)); // // That color is used for all planes. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET_ENABLE, GRAPH_ADDR_MASK)); // // This gets our background color into the latches. // AccessGRAM_WR(FrameBuffer, GRAPH_ADDR_MASK); // // Change the Set/Reset register to be all zeroes. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET, 0)); // // The Set/Reset enable register now flags where the foreground/background colors are the same. // ColorFg = ~(ColorFg ^ ColorBg); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET_ENABLE, ColorFg)); // // Color differences will be xor'd with the latches. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_XOR)); }

VOID ColorSetGridMask (  PDEVICE_EXTENSION  deviceExtension, BYTE  BitMask )

Definition at line 225 of file port.c. References _DEVICE_EXTENSION::DeviceRegisters, DR_SET, GRAPH_ADDR_MASK, GRAPHAddressPort, IND_BIT_MASK, IND_DATA_ROTATE, IND_SET_RESET, and IND_SET_RESET_ENABLE. Referenced by FsgWriteToScreenCommonLVB(). { // // That color is used for all planes. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET_ENABLE, GRAPH_ADDR_MASK)); // // Change the Set/Reset register to be all set. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET, 0x07)); // // Use specified pixel positions. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_BIT_MASK, BitMask)); // // Set up to write data without interacting with the latches. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_SET)); }

int ConvertOutputToOem (  IN LPWSTR  Source, IN int  SourceLength, OUT LPSTR  Target, IN int  TargetLength )

Definition at line 31 of file w32/ntcon/fullscr/vga/misc.c. { NTSTATUS Status; int Length; UNICODE_STRING SourceUni; ANSI_STRING TargetAns; CHAR AnsBuf[256]; SourceUni.MaximumLength = SourceUni.Length = SourceLength * sizeof(WCHAR); SourceUni.Buffer = Source; TargetAns.Length = 0; TargetAns.MaximumLength = sizeof(AnsBuf); TargetAns.Buffer = AnsBuf; // Can do this in place Status = RtlUnicodeStringToAnsiString(&TargetAns, &SourceUni, FALSE); if (NT_SUCCESS(Status)) { Length = strlen(AnsBuf); if (Length <= TargetLength) { RtlMoveMemory(Target, AnsBuf, Length); return Length; } else { return 0; } } else { return 0; } }

NTSTATUS DriverEntry (  IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING  RegistryPath )

Definition at line 67 of file fs_rec.c. : This routine is invoked once when the driver is loaded to allow the driver to initialize itself. The initialization for the driver consists of simply creating a device object for each type of file system recognized by this driver, and then registering each as active file systems. Arguments: DriverObject - Pointer to the driver object for this driver. RegistryPath - Pointer to the registry service node for this driver. Return Value: The function value is the final status of the initialization for the driver. --*/ { PDEVICE_OBJECT UdfsMainRecognizerDeviceObject; NTSTATUS status; ULONG count = 0; PAGED_CODE(); // // Mark the entire driver as pagable. // MmPageEntireDriver ((PVOID)DriverEntry); // // Begin by initializing the driver object so that it the driver is // prepared to provide services. // DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FsRecFsControl; DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRecCreate; DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FsRecCleanupClose; DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsRecCleanupClose; DriverObject->DriverUnload = FsRecUnload; FsRecLoadSync = ExAllocatePoolWithTag( NonPagedPool, sizeof(KEVENT), FSREC_POOL_TAG ); if (FsRecLoadSync == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } KeInitializeEvent( FsRecLoadSync, SynchronizationEvent, TRUE ); // // Create and initialize each of the file system driver type device // objects. // status = FsRecCreateAndRegisterDO( DriverObject, NULL, NULL, L"\\Cdfs", L"\\FileSystem\\CdfsRecognizer", CdfsFileSystem, FILE_DEVICE_CD_ROM_FILE_SYSTEM ); if (NT_SUCCESS( status )) { count++; } status = FsRecCreateAndRegisterDO( DriverObject, NULL, &UdfsMainRecognizerDeviceObject, L"\\UdfsCdRom", L"\\FileSystem\\UdfsCdRomRecognizer", UdfsFileSystem, FILE_DEVICE_CD_ROM_FILE_SYSTEM ); if (NT_SUCCESS( status )) { count++; } status = FsRecCreateAndRegisterDO( DriverObject, UdfsMainRecognizerDeviceObject, NULL, L"\\UdfsDisk", L"\\FileSystem\\UdfsDiskRecognizer", UdfsFileSystem, FILE_DEVICE_DISK_FILE_SYSTEM ); if (NT_SUCCESS( status )) { count++; } status = FsRecCreateAndRegisterDO( DriverObject, NULL, NULL, L"\\Fat", L"\\FileSystem\\FatRecognizer", FatFileSystem, FILE_DEVICE_DISK_FILE_SYSTEM ); if (NT_SUCCESS( status )) { count++; } status = FsRecCreateAndRegisterDO( DriverObject, NULL, NULL, L"\\Ntfs", L"\\FileSystem\\NtfsRecognizer", NtfsFileSystem, FILE_DEVICE_DISK_FILE_SYSTEM ); if (NT_SUCCESS( status )) { count++; } if (count) { return STATUS_SUCCESS; } else { return STATUS_IMAGE_ALREADY_LOADED; } }

NTSTATUS FsgCopyFrameBuffer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_COPY_FRAME_BUFFER  CopyFrameBuffer, ULONG  inputBufferLength )

Definition at line 437 of file drawscrn.c. References CalcGRAMAddress(), _DEVICE_EXTENSION::CurrentMode, FALSE, FsgInvertCursor(), MoveGRAM(), _DEVICE_EXTENSION::ScreenAndFont, and TRUE. Referenced by FsVgaCopyFrameBuffer(). : This routine copy the frame buffer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. CopyFrameBuffer - Pointer to the structure containing the information about the copy frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { PUCHAR SourcePtr, TargetPtr; FsgInvertCursor(DeviceExtension,FALSE); SourcePtr = CalcGRAMAddress (CopyFrameBuffer->SrcScreen.Position, DeviceExtension); TargetPtr = CalcGRAMAddress (CopyFrameBuffer->DestScreen.Position, DeviceExtension); MoveGRAM (TargetPtr, SourcePtr, CopyFrameBuffer->SrcScreen.nNumberOfChars * DeviceExtension->ScreenAndFont.FontSize.Y, DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase, DeviceExtension ); FsgInvertCursor(DeviceExtension,TRUE); return STATUS_SUCCESS; }

NTSTATUS FsgInvertCursor (  PDEVICE_EXTENSION  DeviceExtension, BOOL  Invert )

Definition at line 702 of file drawscrn.c. References AccessGRAM_AND(), BOOL, BYTE, CalcGRAMAddress(), _EMULATE_BUFFER_INFORMATION::CursorAttributes, _EMULATE_BUFFER_INFORMATION::CursorPosition, _DEVICE_EXTENSION::EmulateInfo, FALSE, NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, SetGRAMInvertMode(), SetGRAMWriteMode(), SHORT, _EMULATE_BUFFER_INFORMATION::ShowCursor, and TRUE. Referenced by FsgCopyFrameBuffer(), FsgReverseMousePointer(), FsgWriteToFrameBuffer(), FsVgaSetCursorAttribute(), and FsVgaSetCursorPosition(). : This routine inverts the cursor. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. Invert - Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { PUCHAR CurFrameBufPtr; COORD CursorPosition; COORD FontSize; SHORT i; SHORT TopScanLine; BOOL fOneMore = FALSE; if (DeviceExtension->EmulateInfo.ShowCursor == Invert) return STATUS_SUCCESS; DeviceExtension->EmulateInfo.ShowCursor = Invert; if (!(DeviceExtension->EmulateInfo.CursorAttributes.Enable)) return STATUS_SUCCESS; FontSize = DeviceExtension->ScreenAndFont.FontSize; if (DeviceExtension->ScreenAndFont.ScreenSize.Y > 25) { TopScanLine = ((DeviceExtension->EmulateInfo.CursorAttributes.Height + 8) * 100 / 8) - 100; } else { TopScanLine = ((DeviceExtension->EmulateInfo.CursorAttributes.Height + 16) * 100 / 16) - 100; } TopScanLine = (FontSize.Y * TopScanLine) / 100; CursorPosition.X = DeviceExtension->EmulateInfo.CursorPosition.Coord.Column; CursorPosition.Y = DeviceExtension->EmulateInfo.CursorPosition.Coord.Row; if ( (0 <= CursorPosition.X && CursorPosition.X < DeviceExtension->ScreenAndFont.ScreenSize.X) && (0 <= CursorPosition.Y && CursorPosition.Y < DeviceExtension->ScreenAndFont.ScreenSize.Y) ) { switch (DeviceExtension->EmulateInfo.CursorPosition.dwType) { case CHAR_TYPE_LEADING: if (CursorPosition.X != DeviceExtension->ScreenAndFont.ScreenSize.X-1) { fOneMore = TRUE; } break; case CHAR_TYPE_TRAILING: if (CursorPosition.X != 0) { fOneMore = TRUE; CursorPosition.X--; } break; } CurFrameBufPtr = CalcGRAMAddress (CursorPosition, DeviceExtension); /* * CursorAttributes.Height is top scan lines. */ for (i = 0; i < TopScanLine; i++) { CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); } // // Set invert mode of graphics register // SetGRAMInvertMode(DeviceExtension); /* * CursorAttributes.Width is bottom scan lines. */ for ( ; i < FontSize.Y; i++) { AccessGRAM_AND(CurFrameBufPtr, (BYTE)-1); if (fOneMore) AccessGRAM_AND(CurFrameBufPtr+1, (BYTE)-1); CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); } SetGRAMWriteMode(DeviceExtension); } return STATUS_SUCCESS; }

NTSTATUS FsgReverseMousePointer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_REVERSE_MOUSE_POINTER  MouseBuffer, ULONG  inputBufferLength )

Definition at line 609 of file drawscrn.c. References AccessGRAM_AND(), BOOL, BYTE, CalcGRAMAddress(), FALSE, FsgInvertCursor(), NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, SetGRAMInvertMode(), SetGRAMWriteMode(), SHORT, and TRUE. Referenced by FsVgaReverseMousePointer(). : This routine reverse the frame buffer for mouse pointer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. MouseBuffer - Pointer to the structure containing the information about the mouse frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { PUCHAR CurFrameBufPtr; COORD CursorPosition; COORD FontSize; SHORT i; BOOL fOneMore = FALSE; FsgInvertCursor(DeviceExtension,FALSE); FontSize = DeviceExtension->ScreenAndFont.FontSize; CursorPosition.X = MouseBuffer->Screen.Position.X; CursorPosition.Y = MouseBuffer->Screen.Position.Y; if ( (0 <= CursorPosition.X && CursorPosition.X < MouseBuffer->Screen.ScreenSize.X) && (0 <= CursorPosition.Y && CursorPosition.Y < MouseBuffer->Screen.ScreenSize.Y) ) { switch (MouseBuffer->dwType) { case CHAR_TYPE_LEADING: if (CursorPosition.X != MouseBuffer->Screen.ScreenSize.X-1) { fOneMore = TRUE; } break; case CHAR_TYPE_TRAILING: if (CursorPosition.X != 0) { fOneMore = TRUE; CursorPosition.X--; } break; } CurFrameBufPtr = CalcGRAMAddress (CursorPosition, DeviceExtension); // // Set invert mode of graphics register // SetGRAMInvertMode(DeviceExtension); /* * CursorAttributes.Width is bottom scan lines. */ for (i=0 ; i < FontSize.Y; i++) { AccessGRAM_AND(CurFrameBufPtr, (BYTE)-1); if (fOneMore) AccessGRAM_AND(CurFrameBufPtr+1, (BYTE)-1); CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); } SetGRAMWriteMode(DeviceExtension); } FsgInvertCursor(DeviceExtension,TRUE); return STATUS_SUCCESS; }

NTSTATUS FsgVgaInitializeHWFlags (  PDEVICE_EXTENSION  DeviceExtension  )

Definition at line 387 of file drawscrn.c. References BYTE, _EMULATE_BUFFER_INFORMATION::BytePerLine, CalcGRAMScanLine, _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, _DEVICE_EXTENSION::Configuration, _EMULATE_BUFFER_INFORMATION::CursorAttributes, _EMULATE_BUFFER_INFORMATION::DeltaNextFontRow, _DEVICE_EXTENSION::EmulateInfo, FALSE, GetBytePerLine, GetHardwareScrollReg(), _FSVGA_CONFIGURATION_INFORMATION::HardwareScroll, Index, LIMIT_64K, _EMULATE_BUFFER_INFORMATION::LimitGRAM, _EMULATE_BUFFER_INFORMATION::MaxScanLine, _DEVICE_EXTENSION::ScreenAndFont, SetGRAMWriteMode(), _EMULATE_BUFFER_INFORMATION::ShowCursor, and USE_LINE_COMPARE. Referenced by FsVgaSetScreenInformation(). : This routine initialize the hardware scrolls flag and any values. Arguments: EmulateInfo - Pointer to screen emulate information structure. Return Value: --*/ { ULONG Index; GetHardwareScrollReg(DeviceExtension); DeviceExtension->EmulateInfo.BytePerLine = (WORD)GetBytePerLine(DeviceExtension); DeviceExtension->EmulateInfo.MaxScanLine = (WORD)CalcGRAMScanLine(DeviceExtension->ScreenAndFont.ScreenSize.Y, DeviceExtension->ScreenAndFont.FontSize.Y); DeviceExtension->EmulateInfo.DeltaNextFontRow = DeviceExtension->EmulateInfo.BytePerLine * DeviceExtension->ScreenAndFont.FontSize.Y; if (DeviceExtension->Configuration.HardwareScroll & USE_LINE_COMPARE) { DeviceExtension->EmulateInfo.LimitGRAM = DeviceExtension->EmulateInfo.MaxScanLine * DeviceExtension->EmulateInfo.BytePerLine; } else { DeviceExtension->EmulateInfo.LimitGRAM = LIMIT_64K; } DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; DeviceExtension->EmulateInfo.CursorAttributes.Enable = 0; DeviceExtension->EmulateInfo.ShowCursor = FALSE; SetGRAMWriteMode(DeviceExtension); return STATUS_SUCCESS; }

NTSTATUS FsgWriteToFrameBuffer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_WRITE_TO_FRAME_BUFFER  WriteFrameBuffer, ULONG  inputBufferLength )

Definition at line 489 of file drawscrn.c. References AlignCopyMemory(), BOOL, BYTE, BYTE_ALIGN, CalcBitmapBufferSize(), CalcGRAMAddress(), _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, DWORD, _DEVICE_EXTENSION::EmulateInfo, ExAllocatePool, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), FALSE, FsgInvertCursor(), FsgWriteToScreen(), NTSTATUS(), NULL, PagedPool, _DEVICE_EXTENSION::ScreenAndFont, Status, TRUE, and WORD_ALIGN. Referenced by FsVgaWriteToFrameBuffer(). : This routine write the frame buffer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. WriteFrameBuffer - Pointer to the structure containing the information about the write frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { PCHAR_IMAGE_INFO pCharInfoUni = WriteFrameBuffer->SrcBuffer; PUCHAR TargetPtr; COORD Position = WriteFrameBuffer->DestScreen.Position; DWORD Length = WriteFrameBuffer->DestScreen.nNumberOfChars; COORD FontSize1 = DeviceExtension->ScreenAndFont.FontSize; COORD FontSize2; PVOID pCapBuffer = NULL; ULONG cCapBuffer = 0; BOOL fDbcs; NTSTATUS Status; FsgInvertCursor(DeviceExtension,FALSE); DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; FontSize2 = FontSize1; FontSize2.X *= 2; cCapBuffer = CalcBitmapBufferSize(FontSize2,BYTE_ALIGN); pCapBuffer = ExAllocatePool(PagedPool, cCapBuffer); while (Length--) { if (pCharInfoUni->FontImageInfo.ImageBits != NULL) { try { fDbcs = pCharInfoUni->CharInfo.Attributes & COMMON_LVB_SBCSDBCS; AlignCopyMemory((PVOID)pCapBuffer, // pDestBits BYTE_ALIGN, // dwDestAlign pCharInfoUni->FontImageInfo.ImageBits,// pSrcBits WORD_ALIGN, // dwSrcAlign fDbcs ? FontSize2 : FontSize1); TargetPtr = CalcGRAMAddress (Position, DeviceExtension); if (fDbcs) { if (Length) { FsgWriteToScreen(TargetPtr, pCapBuffer, 2, fDbcs, pCharInfoUni->CharInfo.Attributes, (pCharInfoUni+1)->CharInfo.Attributes, DeviceExtension); } else { FsgWriteToScreen(TargetPtr, pCapBuffer, 2, FALSE, pCharInfoUni->CharInfo.Attributes, (WORD)-1, DeviceExtension); } } else { FsgWriteToScreen(TargetPtr, pCapBuffer, 1, fDbcs, pCharInfoUni->CharInfo.Attributes, (WORD)-1, DeviceExtension); } } except (EXCEPTION_EXECUTE_HANDLER) { } } if (fDbcs && Length) { Length--; Position.X += 2; pCharInfoUni += 2; } else { Position.X++; pCharInfoUni++; } } FsgInvertCursor(DeviceExtension,TRUE); if (pCapBuffer != NULL) ExFreePool(pCapBuffer); return STATUS_SUCCESS; }

NTSTATUS FsgWriteToScreen (  PUCHAR  FrameBuffer, PUCHAR  BitmapBuffer, DWORD  cjBytes, BOOL  fDbcs, WORD  Attributes1, WORD  Attributes2, PDEVICE_EXTENSION  DeviceExtension )

Definition at line 813 of file drawscrn.c. References COMMON_LVB_MASK, _DEVICE_EXTENSION::Configuration, _FSVGA_CONFIGURATION_INFORMATION::EmulationMode, ENABLE_WORD_WRITE_VRAM, EXCEPTION_EXECUTE_HANDLER, FsgWriteToScreenCommonLVB(), Index, IsGRAMRowOver(), NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, and set_opaque_bkgnd_proc(). Referenced by FsgWriteToFrameBuffer(). { WORD Index; PCHAR CurFrameBufPtrTmp; PCHAR CurFrameBufPtr2nd; PWORD CurFrameBufPtrWord; PUCHAR BitmapBufferTmp; #ifdef LATER_HIGH_SPPED_VRAM_ACCESS // kazum if (! IsGRAMRowOver(FrameBuffer,fDBCS,DeviceExtension)) { if (!fDbcs) { if (cjBytes == 2) BitmapBuffer++; (*WriteGramInfo->pfnWriteFontToByteGRAM)(WriteGramInfo); } else if (cjBytes == 2 && fDBCS) { if (DeviceExtension->Configuration.EmulationMode & ENABLE_WORD_WRITE_VRAM) { (*WriteGramInfo->pfnWriteFontToFirstWordGRAM)(WriteGramInfo); } else { (*WriteGramInfo->pfnWriteFontToWordGRAM)(WriteGramInfo); } } } else #endif // LATER_HIGH_SPPED_VRAM_ACCESS // kazum try { set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes1); if (!fDbcs) { CurFrameBufPtrTmp = FrameBuffer; if (cjBytes == 2) BitmapBuffer++; for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { *CurFrameBufPtrTmp = *BitmapBuffer; BitmapBuffer += cjBytes; CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); } } else if (cjBytes == 2 && fDbcs) { if ((DeviceExtension->Configuration.EmulationMode & ENABLE_WORD_WRITE_VRAM) && !((ULONG)FrameBuffer & 1) && (Attributes2 != -1) && (Attributes1 == Attributes2) ) { CurFrameBufPtrWord = (PWORD)FrameBuffer; for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { *CurFrameBufPtrWord = *((PWORD)BitmapBuffer); BitmapBuffer += cjBytes; CurFrameBufPtrWord=(PWORD)NextGRAMRow((PCHAR)CurFrameBufPtrWord,DeviceExtension); } } else { CurFrameBufPtrTmp = FrameBuffer; CurFrameBufPtr2nd = FrameBuffer + 1; BitmapBufferTmp = BitmapBuffer + 1; for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { *CurFrameBufPtrTmp = *BitmapBuffer; BitmapBuffer += cjBytes; CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); } if (Attributes2 != -1 && Attributes1 != Attributes2) set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes2); for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { *CurFrameBufPtr2nd = *BitmapBufferTmp; BitmapBufferTmp += cjBytes; CurFrameBufPtr2nd=NextGRAMRow(CurFrameBufPtr2nd,DeviceExtension); } } } } except (EXCEPTION_EXECUTE_HANDLER) { } if (Attributes1 & COMMON_LVB_MASK) { FsgWriteToScreenCommonLVB(FrameBuffer, Attributes1, DeviceExtension); } if ((Attributes2 != (WORD)-1) && (Attributes2 & COMMON_LVB_MASK)) { FsgWriteToScreenCommonLVB(FrameBuffer+1, Attributes2, DeviceExtension); } return STATUS_SUCCESS; }

NTSTATUS FsgWriteToScreenCommonLVB (  PUCHAR  FrameBuffer, WORD  Attributes, PDEVICE_EXTENSION  DeviceExtension )

Definition at line 915 of file drawscrn.c. References AccessGRAM_RW(), BYTE, _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, ColorSetDirect(), ColorSetGridMask(), _DEVICE_EXTENSION::EmulateInfo, EXCEPTION_EXECUTE_HANDLER, Index, NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, set_opaque_bkgnd_proc(), and SetGRAMWriteMode(). Referenced by FsgWriteToScreen(). { WORD Index; PUCHAR CurFrameBufPtrTmp; try { if (Attributes & COMMON_LVB_UNDERSCORE) { set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes); CurFrameBufPtrTmp = FrameBuffer; for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y - 1; Index++) CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); *CurFrameBufPtrTmp = 0xff; } if (Attributes & COMMON_LVB_GRID_HORIZONTAL) { ColorSetDirect(DeviceExtension, FrameBuffer, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED, 0); *FrameBuffer = 0xff; } if ( (Attributes & COMMON_LVB_GRID_LVERTICAL) || (Attributes & COMMON_LVB_GRID_RVERTICAL) ) { BYTE mask = ((Attributes & COMMON_LVB_GRID_LVERTICAL) ? 0x80 : 0) + ((Attributes & COMMON_LVB_GRID_RVERTICAL) ? 0x01 : 0); ColorSetGridMask(DeviceExtension, mask ); CurFrameBufPtrTmp = FrameBuffer; for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { AccessGRAM_RW(CurFrameBufPtrTmp, mask); CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); } SetGRAMWriteMode(DeviceExtension); } DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; } except (EXCEPTION_EXECUTE_HANDLER) { } return STATUS_SUCCESS; }

VOID FsVgaBuildResourceList (  IN PDEVICE_EXTENSION  DeviceExtension, OUT PCM_RESOURCE_LIST *  ResourceList, OUT PULONG  ResourceListSize )

Definition at line 1056 of file fsvga.c. References DUMP_COUNT, ExAllocatePool, FSVGA_ERROR_VALUE_BASE, FsVgaLogError(), FsVgaPrint, and PagedPool. Referenced by DriverEntry(). : Creates a resource list that is used to query or report resource usage. Arguments: DeviceExtension - Pointer to the port's device extension. ResourceList - Pointer to a pointer to the resource list to be allocated and filled. ResourceListSize - Pointer to the returned size of the resource list (in bytes). Return Value: None. If the call succeeded, *ResourceList points to the built resource list and *ResourceListSize is set to the size (in bytes) of the resource list; otherwise, *ResourceList is NULL. Note: Memory may be allocated here for *ResourceList. It must be freed up by the caller, by calling ExFreePool(); --*/ { ULONG count = 0; ULONG i = 0; ULONG j = 0; #define DUMP_COUNT 4 ULONG dumpData[DUMP_COUNT]; count += DeviceExtension->Configuration.PortListCount; *ResourceListSize = sizeof(CM_RESOURCE_LIST) + ((count - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR)); *ResourceList = (PCM_RESOURCE_LIST) ExAllocatePool(PagedPool, *ResourceListSize); // // Return NULL if the structure could not be allocated. // Otherwise, fill in the resource list. // if (!*ResourceList) { // // Could not allocate memory for the resource list. // FsVgaPrint((1, "FSVGA-FsVgaBuildResourceList: Could not allocate resource list\n")); // // Log an error. // dumpData[0] = *ResourceListSize; *ResourceListSize = 0; FsVgaLogError(DeviceExtension->DeviceObject, FSVGA_INSUFFICIENT_RESOURCES, FSVGA_ERROR_VALUE_BASE + 110, STATUS_INSUFFICIENT_RESOURCES, dumpData, 1 ); return; } RtlZeroMemory(*ResourceList, *ResourceListSize); // // Concoct one full resource descriptor. // (*ResourceList)->Count = 1; (*ResourceList)->List[0].InterfaceType = DeviceExtension->Configuration.InterfaceType; (*ResourceList)->List[0].BusNumber = DeviceExtension->Configuration.BusNumber; // // Build the partial resource descriptors for port // resources from the saved values. // (*ResourceList)->List[0].PartialResourceList.Count = count; for (j = 0; j < DeviceExtension->Configuration.PortListCount; j++) { (*ResourceList)->List[0].PartialResourceList.PartialDescriptors[i++] = DeviceExtension->Configuration.PortList[j]; } }

VOID FsVgaConfiguration (  IN PDEVICE_EXTENSION  DeviceExtension, IN PUNICODE_STRING  RegistryPath, IN PUNICODE_STRING  KeyboardDeviceName )

Definition at line 649 of file fsvga.c. References FSVGA_HARDWARE_PRESENT, FsVgaPeripheralCallout(), FsVgaPrint, FsVgaServiceParameters(), IoQueryDeviceDescription(), NTSTATUS(), NULL, and PFSVGA_CONFIGURATION_INFORMATION. Referenced by DriverEntry(). : This routine retrieves the configuration information for the keyboard. Arguments: DeviceExtension - Pointer to the device extension. RegistryPath - Pointer to the null-terminated Unicode name of the registry path for this driver. FsVgaDeviceName - Pointer to the Unicode string that will receive the Full Screen Video port device name. Return Value: None. As a side-effect, may set DeviceExtension->HardwarePresent. --*/ { NTSTATUS status = STATUS_SUCCESS; PFSVGA_CONFIGURATION_INFORMATION configuration; INTERFACE_TYPE interfaceType; ULONG i; for (i = 0; i < MaximumInterfaceType; i++) { // // Get the registry information for this device. // interfaceType = i; status = IoQueryDeviceDescription(&interfaceType, NULL, NULL, NULL, NULL, NULL, FsVgaPeripheralCallout, (PVOID) DeviceExtension); if (DeviceExtension->HardwarePresent & FSVGA_HARDWARE_PRESENT) { // // Get the service parameters (e.g., user-configurable number // of resends, polling iterations, etc.). // FsVgaServiceParameters(DeviceExtension, RegistryPath, FsVgaDeviceName); break; } else { FsVgaPrint((1, "FSVGA-FsVgaConfiguration: IoQueryDeviceDescription for bus type %d failed\n", interfaceType)); } } }

NTSTATUS FsVgaCopyFrameBuffer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_COPY_FRAME_BUFFER  CopyFrameBuffer, ULONG  inputBufferLength )

Definition at line 1349 of file fsvga.c. References _DEVICE_EXTENSION::CurrentMode, FsgCopyFrameBuffer(), and SCREEN_BUFFER_POINTER. Referenced by FsVgaDeviceControl(). : This routine copy the frame buffer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. CopyFrameBuffer - Pointer to the structure containing the information about the copy frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(FSVIDEO_COPY_FRAME_BUFFER)) { return STATUS_INVALID_BUFFER_SIZE; } if (CopyFrameBuffer->SrcScreen.nNumberOfChars != CopyFrameBuffer->DestScreen.nNumberOfChars) { return STATUS_INVALID_PARAMETER; } if (! (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS)) { /* * This is the TEXT frame buffer. */ ULONG OffsSrc; ULONG OffsDest; PUCHAR pFrameBuf = DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase; OffsSrc = SCREEN_BUFFER_POINTER(CopyFrameBuffer->SrcScreen.Position.X, CopyFrameBuffer->SrcScreen.Position.Y, CopyFrameBuffer->SrcScreen.ScreenSize.X, sizeof(VGA_CHAR)); OffsDest = SCREEN_BUFFER_POINTER(CopyFrameBuffer->DestScreen.Position.X, CopyFrameBuffer->DestScreen.Position.Y, CopyFrameBuffer->DestScreen.ScreenSize.X, sizeof(VGA_CHAR)); RtlMoveMemory(pFrameBuf + OffsDest, pFrameBuf + OffsSrc, CopyFrameBuffer->SrcScreen.nNumberOfChars * sizeof(VGA_CHAR)); } else { /* * This is the GRAPHICS frame buffer. */ return FsgCopyFrameBuffer(DeviceExtension, CopyFrameBuffer, inputBufferLength); } return STATUS_SUCCESS; }

NTSTATUS FsVgaDeviceControl (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp )

Definition at line 1213 of file fsvga.c. References _IRP::AssociatedIrp, FsVgaCopyFrameBuffer(), FsVgaPrint, FsVgaReverseMousePointer(), FsVgaSetCursorAttribute(), FsVgaSetCursorPosition(), FsVgaSetMode(), FsVgaSetScreenInformation(), FsVgaWriteToFrameBuffer(), IO_NO_INCREMENT, IoCompleteRequest, IoGetCurrentIrpStackLocation, _IRP::IoStatus, Irp, NTSTATUS(), PAGED_CODE, and _IO_STACK_LOCATION::Parameters. Referenced by DriverEntry(). : This routine is the dispatch routine for device control requests. Arguments: DeviceObject - Pointer to the device object. Irp - Pointer to the request packet. Return Value: Status is returned. --*/ { PIO_STACK_LOCATION irpSp; PVOID ioBuffer; ULONG inputBufferLength; ULONG outputBufferLength; PDEVICE_EXTENSION deviceExtension; NTSTATUS status = STATUS_SUCCESS; FsVgaPrint((2,"FSVGA-FsVgaDeviceControl: enter\n")); PAGED_CODE(); // // Get a pointer to the device extension. // deviceExtension = DeviceObject->DeviceExtension; // // Initialize the returned Information field. // Irp->IoStatus.Information = 0; // // Get a pointer to the current parameters for this request. The // information is contained in the current stack location. // irpSp = IoGetCurrentIrpStackLocation(Irp); // // Get the pointer to the input/output buffer and it's length // ioBuffer = Irp->AssociatedIrp.SystemBuffer; inputBufferLength = irpSp->Parameters.DeviceIoControl.InputBufferLength; outputBufferLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; // // Case on the device control subfunction that is being performed by the // requestor. // switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_FSVIDEO_COPY_FRAME_BUFFER: FsVgaPrint((2, "FsVgaDeviceControl - CopyFrameBuffer\n")); status = FsVgaCopyFrameBuffer(deviceExtension, (PFSVIDEO_COPY_FRAME_BUFFER) ioBuffer, inputBufferLength); break; case IOCTL_FSVIDEO_WRITE_TO_FRAME_BUFFER: FsVgaPrint((2, "FsVgaDeviceControl - WriteToFrameBuffer\n")); status = FsVgaWriteToFrameBuffer(deviceExtension, (PFSVIDEO_WRITE_TO_FRAME_BUFFER) ioBuffer, inputBufferLength); break; case IOCTL_FSVIDEO_REVERSE_MOUSE_POINTER: FsVgaPrint((2, "FsVgaDeviceControl - ReverseMousePointer\n")); status = FsVgaReverseMousePointer(deviceExtension, (PFSVIDEO_REVERSE_MOUSE_POINTER) ioBuffer, inputBufferLength); break; case IOCTL_FSVIDEO_SET_CURRENT_MODE: FsVgaPrint((2, "FsVgaDeviceControl - SetCurrentModes\n")); status = FsVgaSetMode(deviceExtension, (PFSVIDEO_MODE_INFORMATION) ioBuffer, inputBufferLength); break; case IOCTL_FSVIDEO_SET_SCREEN_INFORMATION: FsVgaPrint((2, "FsVgaDeviceControl - SetScreenInformation\n")); status = FsVgaSetScreenInformation(deviceExtension, (PFSVIDEO_SCREEN_INFORMATION) ioBuffer, inputBufferLength); break; case IOCTL_FSVIDEO_SET_CURSOR_POSITION: FsVgaPrint((2, "FsVgaDeviceControl - SetCursorPosition\n")); status = FsVgaSetCursorPosition(deviceExtension, (PFSVIDEO_CURSOR_POSITION) ioBuffer, inputBufferLength); break; case IOCTL_VIDEO_SET_CURSOR_ATTR: FsVgaPrint((2, "FsVgaDeviceControl - SetCursorAttribute\n")); status = FsVgaSetCursorAttribute(deviceExtension, (PVIDEO_CURSOR_ATTRIBUTES) ioBuffer, inputBufferLength); break; default: FsVgaPrint((1, "FSVGA-FsVgaDeviceControl: INVALID REQUEST (0x%x)\n", irpSp->Parameters.DeviceIoControl.IoControlCode)); status = STATUS_INVALID_DEVICE_REQUEST; break; } Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); FsVgaPrint((2,"FSVGA-FsVgaDeviceControl: exit\n")); return(status); }

VOID FsVgaLogError (  IN PDEVICE_OBJECT  DeviceObject, IN NTSTATUS  ErrorCode, IN ULONG  UniqueErrorValue, IN NTSTATUS  FinalStatus, IN PULONG  DumpData, IN ULONG  DumpCount )

Definition at line 1844 of file fsvga.c. References IoAllocateErrorLogEntry(), IoWriteErrorLogEntry(), NULL, and USHORT. Referenced by FsVgaBuildResourceList(), and FsVgaWriteToFrameBuffer(). : This routine contains common code to write an error log entry. It is called from other routines, especially FsVgaInitialize, to avoid duplication of code. Note that some routines continue to have their own error logging code (especially in the case where the error logging can be localized and/or the routine has more data because there is and IRP). Arguments: DeviceObject - Pointer to the device object. ErrorCode - The error code for the error log packet. UniqueErrorValue - The unique error value for the error log packet. FinalStatus - The final status of the operation for the error log packet. DumpData - Pointer to an array of dump data for the error log packet. DumpCount - The number of entries in the dump data array. Return Value: None. --*/ { PIO_ERROR_LOG_PACKET errorLogEntry; ULONG i; errorLogEntry = (PIO_ERROR_LOG_PACKET) IoAllocateErrorLogEntry( DeviceObject, (UCHAR) (sizeof(IO_ERROR_LOG_PACKET) + (DumpCount * sizeof(ULONG))) ); if (errorLogEntry != NULL) { errorLogEntry->ErrorCode = ErrorCode; errorLogEntry->DumpDataSize = (USHORT) (DumpCount * sizeof(ULONG)); errorLogEntry->SequenceNumber = 0; errorLogEntry->MajorFunctionCode = 0; errorLogEntry->IoControlCode = 0; errorLogEntry->RetryCount = 0; errorLogEntry->UniqueErrorValue = UniqueErrorValue; errorLogEntry->FinalStatus = FinalStatus; for (i = 0; i < DumpCount; i++) errorLogEntry->DumpData[i] = DumpData[i]; IoWriteErrorLogEntry(errorLogEntry); } }

NTSTATUS FsVgaOpenCloseDispatch (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp )

Definition at line 1167 of file fsvga.c. References FsVgaPrint, IO_NO_INCREMENT, IoCompleteRequest, _IRP::IoStatus, Irp, and PAGED_CODE. Referenced by DriverEntry(). : This is the dispatch routine for create/open and close requests. These requests complete successfully. Arguments: DeviceObject - Pointer to the device object. Irp - Pointer to the request packet. Return Value: Status is returned. --*/ { UNREFERENCED_PARAMETER(DeviceObject); FsVgaPrint((3,"FSVGA-FsVgaOpenCloseDispatch: enter\n")); PAGED_CODE(); // // Complete the request with successful status. // Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); FsVgaPrint((3,"FSVGA-FsVgaOpenCloseDispatch: exit\n")); return(STATUS_SUCCESS); }

NTSTATUS FsVgaPeripheralCallout (  IN PVOID  Context, IN PUNICODE_STRING  PathName, IN INTERFACE_TYPE  BusType, IN ULONG  BusNumber, IN PKEY_VALUE_FULL_INFORMATION *  BusInformation, IN CONFIGURATION_TYPE  ControllerType, IN ULONG  ControllerNumber, IN PKEY_VALUE_FULL_INFORMATION *  ControllerInformation, IN CONFIGURATION_TYPE  PeripheralType, IN ULONG  PeripheralNumber, IN PKEY_VALUE_FULL_INFORMATION *  PeripheralInformation )

Definition at line 722 of file fsvga.c. References _FSVGA_CONFIGURATION_INFORMATION::BusNumber, BusNumber, _DEVICE_EXTENSION::Configuration, ControllerType, CRTC_ADDRESS_PORT_COLOR, CRTC_DATA_PORT_COLOR, FSVGA_HARDWARE_PRESENT, FsVgaPrint, GRAPH_ADDRESS_PORT, _DEVICE_EXTENSION::HardwarePresent, _FSVGA_CONFIGURATION_INFORMATION::InterfaceType, NTSTATUS(), PeripheralType, _FSVGA_CONFIGURATION_INFORMATION::PortList, _FSVGA_CONFIGURATION_INFORMATION::PortListCount, SEQ_ADDRESS_PORT, and VGA_BASE_IO_PORT. Referenced by FsVgaConfiguration(). : This is the callout routine sent as a parameter to IoQueryDeviceDescription. It grabs the Display controller configuration information. Arguments: Context - Context parameter that was passed in by the routine that called IoQueryDeviceDescription. PathName - The full pathname for the registry key. BusType - Bus interface type (Isa, Eisa, Mca, etc.). BusNumber - The bus sub-key (0, 1, etc.). BusInformation - Pointer to the array of pointers to the full value information for the bus. ControllerType - The controller type (should be DisplayController). ControllerNumber - The controller sub-key (0, 1, etc.). ControllerInformation - Pointer to the array of pointers to the full value information for the controller key. PeripheralType - The peripheral type (should be MonitorPeripheral). PeripheralNumber - The peripheral sub-key. PeripheralInformation - Pointer to the array of pointers to the full value information for the peripheral key. Return Value: None. If successful, will have the following side-effects: - Sets DeviceObject->DeviceExtension->HardwarePresent. - Sets configuration fields in DeviceObject->DeviceExtension->Configuration. --*/ { PDEVICE_EXTENSION deviceExtension; PFSVGA_CONFIGURATION_INFORMATION configuration; NTSTATUS status = STATUS_SUCCESS; CM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor; FsVgaPrint((1, "FSVGA-FsVgaPeripheralCallout: Path @ 0x%x, Bus Type 0x%x, Bus Number 0x%x\n", PathName, BusType, BusNumber)); FsVgaPrint((1, " Controller Type 0x%x, Controller Number 0x%x, Controller info @ 0x%x\n", ControllerType, ControllerNumber, ControllerInformation)); FsVgaPrint((1, " Peripheral Type 0x%x, Peripheral Number 0x%x, Peripheral info @ 0x%x\n", PeripheralType, PeripheralNumber, PeripheralInformation)); // // If we already have the configuration information for the // keyboard peripheral, or if the peripheral identifier is missing, // just return. // deviceExtension = (PDEVICE_EXTENSION) Context; if (deviceExtension->HardwarePresent & FSVGA_HARDWARE_PRESENT) { return (status); } configuration = &deviceExtension->Configuration; deviceExtension->HardwarePresent |= FSVGA_HARDWARE_PRESENT; // // Get the bus information. // configuration->InterfaceType = BusType; configuration->BusNumber = BusNumber; // // Get logical IO port addresses. // ResourceDescriptor.Type = CmResourceTypePort; ResourceDescriptor.ShareDisposition = CmResourceShareShared; ResourceDescriptor.Flags = CM_RESOURCE_PORT_IO; ResourceDescriptor.u.Port.Start.LowPart = VGA_BASE_IO_PORT+CRTC_ADDRESS_PORT_COLOR; ResourceDescriptor.u.Port.Start.HighPart = 0; ResourceDescriptor.u.Port.Length = 1; configuration->PortList[configuration->PortListCount] = ResourceDescriptor; configuration->PortListCount += 1; ResourceDescriptor.u.Port.Start.LowPart = VGA_BASE_IO_PORT+CRTC_DATA_PORT_COLOR; ResourceDescriptor.u.Port.Start.HighPart = 0; ResourceDescriptor.u.Port.Length = 1; configuration->PortList[configuration->PortListCount] = ResourceDescriptor; configuration->PortListCount += 1; ResourceDescriptor.u.Port.Start.LowPart = VGA_BASE_IO_PORT+GRAPH_ADDRESS_PORT; ResourceDescriptor.u.Port.Start.HighPart = 0; ResourceDescriptor.u.Port.Length = 2; configuration->PortList[configuration->PortListCount] = ResourceDescriptor; configuration->PortListCount += 1; ResourceDescriptor.u.Port.Start.LowPart = VGA_BASE_IO_PORT+SEQ_ADDRESS_PORT; ResourceDescriptor.u.Port.Start.HighPart = 0; ResourceDescriptor.u.Port.Length = 2; configuration->PortList[configuration->PortListCount] = ResourceDescriptor; configuration->PortListCount += 1; return(status); }

NTSTATUS FsVgaReverseMousePointer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_REVERSE_MOUSE_POINTER  MouseBuffer, ULONG  inputBufferLength )

Definition at line 1546 of file fsvga.c. References BYTE, _DEVICE_EXTENSION::CurrentMode, FsgReverseMousePointer(), and SCREEN_BUFFER_POINTER. Referenced by FsVgaDeviceControl(). : This routine reverse the frame buffer for mouse pointer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. MouseBuffer - Pointer to the structure containing the information about the mouse frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(FSVIDEO_REVERSE_MOUSE_POINTER)) { return STATUS_INVALID_BUFFER_SIZE; } if (! (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS)) { /* * This is the TEXT frame buffer. */ ULONG Offs; PUCHAR pFrameBuf = DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase; BYTE Attribute; Offs = SCREEN_BUFFER_POINTER(MouseBuffer->Screen.Position.X, MouseBuffer->Screen.Position.Y, MouseBuffer->Screen.ScreenSize.X, sizeof(VGA_CHAR)); pFrameBuf += Offs; Attribute = (*(pFrameBuf + 1) & 0xF0) >> 4; Attribute |= (*(pFrameBuf + 1) & 0x0F) << 4; *(pFrameBuf + 1) = Attribute; } else { /* * This is the GRAPHICS frame buffer. */ return FsgReverseMousePointer(DeviceExtension, MouseBuffer, inputBufferLength); } return STATUS_SUCCESS; }

VOID FsVgaServiceParameters (  IN PDEVICE_EXTENSION  DeviceExtension, IN PUNICODE_STRING  RegistryPath, IN PUNICODE_STRING  FsVgaDeviceName )

Definition at line 858 of file fsvga.c. References _FSVGA_CONFIGURATION_INFORMATION::EmulationMode, ExAllocatePool, ExFreePool(), FsVgaPrint, _FSVGA_CONFIGURATION_INFORMATION::HardwareCursor, _FSVGA_CONFIGURATION_INFORMATION::HardwareScroll, L, NO_HARDWARE_CURSOR, NO_HARDWARE_SCROLL, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, path, RtlAppendUnicodeToString(), RtlCopyUnicodeString(), RtlInitUnicodeString(), RtlQueryRegistryValues(), and USHORT. Referenced by FsVgaConfiguration(). : This routine retrieves this driver's service parameters information from the registry. Arguments: DeviceExtension - Pointer to the device extension. RegistryPath - Pointer to the null-terminated Unicode name of the registry path for this driver. FsVgaDeviceName - Pointer to the Unicode string that will receive the Full Screen Video port device name. Return Value: None. As a side-effect, sets fields in DeviceExtension->Configuration. --*/ { PFSVGA_CONFIGURATION_INFORMATION configuration; UNICODE_STRING parametersPath; PWSTR path; PRTL_QUERY_REGISTRY_TABLE parameters = NULL; USHORT queriesPlusOne = 4; NTSTATUS status = STATUS_SUCCESS; #define PARAMETER_MAX 256 ULONG EmulationMode; ULONG HardwareCursor; ULONG HardwareScroll; USHORT defaultEmulationMode = 0; USHORT defaultHardwareCursor = NO_HARDWARE_CURSOR; USHORT defaultHardwareScroll = NO_HARDWARE_SCROLL; UNICODE_STRING defaultFsVgaName; configuration = &DeviceExtension->Configuration; parametersPath.Buffer = NULL; // // Registry path is already null-terminated, so just use it. // path = RegistryPath->Buffer; // // Allocate the Rtl query table. // parameters = ExAllocatePool(PagedPool, sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne); if (!parameters) { FsVgaPrint((1, "FSVGA-FsVgaServiceParameters: Couldn't allocate table for Rtl query to parameters for %ws\n", path)); status = STATUS_UNSUCCESSFUL; } else { RtlZeroMemory(parameters, sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne); // // Form a path to this driver's Parameters subkey. // RtlInitUnicodeString(&parametersPath, NULL); parametersPath.MaximumLength = RegistryPath->Length + sizeof(L"\\Parameters"); parametersPath.Buffer = ExAllocatePool(PagedPool, parametersPath.MaximumLength); if (!parametersPath.Buffer) { FsVgaPrint((1, "FSVGA-FsVgaServiceParameters: Couldn't allocate string for path to parameters for %ws\n", path)); status = STATUS_UNSUCCESSFUL; } } if (NT_SUCCESS(status)) { // // Form the parameters path. // RtlZeroMemory(parametersPath.Buffer, parametersPath.MaximumLength); RtlAppendUnicodeToString(&parametersPath, path); RtlAppendUnicodeToString(&parametersPath, L"\\Parameters"); FsVgaPrint((1, "FsVga-FsVgaServiceParameters: parameters path is %ws\n", parametersPath.Buffer)); // // Gather all of the "user specified" information from // the registry. // parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT; parameters[0].Name = L"ConsoleFullScreen.EmulationMode"; parameters[0].EntryContext = &EmulationMode; parameters[0].DefaultType = REG_DWORD; parameters[0].DefaultData = &defaultEmulationMode; parameters[0].DefaultLength = sizeof(USHORT); parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT; parameters[1].Name = L"ConsoleFullScreen.HardwareCursor"; parameters[1].EntryContext = &HardwareCursor; parameters[1].DefaultType = REG_DWORD; parameters[1].DefaultData = &defaultHardwareCursor; parameters[1].DefaultLength = sizeof(USHORT); parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT; parameters[2].Name = L"ConsoleFullScreen.HardwareScroll"; parameters[2].EntryContext = &HardwareScroll; parameters[2].DefaultType = REG_DWORD; parameters[2].DefaultData = &defaultHardwareScroll; parameters[2].DefaultLength = sizeof(USHORT); status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL, parametersPath.Buffer, parameters, NULL, NULL); if (!NT_SUCCESS(status)) { FsVgaPrint((1, "FsVga-FsVgaServiceParameters: RtlQueryRegistryValues failed with 0x%x\n", status)); } } if (!NT_SUCCESS(status)) { // // Go ahead and assign driver defaults. // configuration->EmulationMode = defaultEmulationMode; configuration->HardwareCursor = defaultHardwareCursor; configuration->HardwareScroll = defaultHardwareScroll; } else { configuration->EmulationMode = (USHORT)EmulationMode; configuration->HardwareCursor = (USHORT)HardwareCursor; configuration->HardwareScroll = (USHORT)HardwareScroll; } // // Form the default port device names, in case they are not // specified in the registry. // RtlInitUnicodeString(&defaultFsVgaName, DD_FULLSCREEN_PORT_BASE_NAME_U); RtlCopyUnicodeString(FsVgaDeviceName, &defaultFsVgaName); FsVgaPrint((1, "FsVga-FsVgaServiceParameters: Full Screen Video port base name = %ws\n", FsVgaDeviceName->Buffer)); FsVgaPrint((1, "FsVga-FsVgaServiceParameters: Emulation Mode = %d\n", configuration->EmulationMode)); FsVgaPrint((1, "FsVga-FsVgaServiceParameters: Hardware Cursor = %d\n", configuration->HardwareCursor)); FsVgaPrint((1, "FsVga-FsVgaServiceParameters: Hardware Scroll = %d\n", configuration->HardwareScroll)); // // Free the allocated memory before returning. // if (parametersPath.Buffer) ExFreePool(parametersPath.Buffer); if (parameters) ExFreePool(parameters); }

NTSTATUS FsVgaSetCursorAttribute (  PDEVICE_EXTENSION  DeviceExtension, PVIDEO_CURSOR_ATTRIBUTES  CursorAttributes, ULONG  inputBufferLength )

Definition at line 1777 of file fsvga.c. References _DEVICE_EXTENSION::CurrentMode, _EMULATE_BUFFER_INFORMATION::CursorAttributes, _DEVICE_EXTENSION::EmulateInfo, FALSE, FsgInvertCursor(), and TRUE. Referenced by FsVgaDeviceControl(). : This routine sets the cursor attributes. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. CursorAttributes - Pointer to the structure containing the information about the cursor attributes. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(VIDEO_CURSOR_ATTRIBUTES)) { return STATUS_INVALID_BUFFER_SIZE; } if (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS) { FsgInvertCursor(DeviceExtension,FALSE); } DeviceExtension->EmulateInfo.CursorAttributes = *CursorAttributes; if (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS) { FsgInvertCursor(DeviceExtension,TRUE); return STATUS_SUCCESS; } else { /* * If current video mode is a TEXT MODE. * FSVGA.SYS didn't handling hardware cursor * because I don't know device of VGA.SYS or others. * * In this case, by returns STATUS_UNSUCCESSFUL, caller * do DeviceIoControl to VGA miniport driver. */ return STATUS_UNSUCCESSFUL; } }

NTSTATUS FsVgaSetCursorPosition (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_CURSOR_POSITION  CursorPosition, ULONG  inputBufferLength )

Definition at line 1710 of file fsvga.c. References _DEVICE_EXTENSION::CurrentMode, _EMULATE_BUFFER_INFORMATION::CursorPosition, _DEVICE_EXTENSION::EmulateInfo, FALSE, FsgInvertCursor(), and TRUE. Referenced by FsVgaDeviceControl(). : This routine sets the cursor position. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. CursorPosition - Pointer to the structure containing the information about the cursor position. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(VIDEO_CURSOR_POSITION)) { return STATUS_INVALID_BUFFER_SIZE; } if (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS) { FsgInvertCursor(DeviceExtension,FALSE); } DeviceExtension->EmulateInfo.CursorPosition = *CursorPosition; if (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS) { FsgInvertCursor(DeviceExtension,TRUE); return STATUS_SUCCESS; } else { /* * If current video mode is a TEXT MODE. * FSVGA.SYS didn't handling hardware cursor * because I don't know device of VGA.SYS or others. * * In this case, by returns STATUS_UNSUCCESSFUL, caller * do DeviceIoControl to VGA miniport driver. */ return STATUS_UNSUCCESSFUL; } }

NTSTATUS FsVgaSetMode (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_MODE_INFORMATION  ModeInformation, ULONG  inputBufferLength )

Definition at line 1618 of file fsvga.c. References _DEVICE_EXTENSION::CurrentMode. Referenced by FsVgaDeviceControl(). : This routine sets the current video information. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. ModeInformation - Pointer to the structure containing the information about the full screen video. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(FSVIDEO_MODE_INFORMATION)) { return STATUS_INVALID_BUFFER_SIZE; } DeviceExtension->CurrentMode = *ModeInformation; return STATUS_SUCCESS; }

NTSTATUS FsVgaSetScreenInformation (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_SCREEN_INFORMATION  ScreenInformation, ULONG  inputBufferLength )

Definition at line 1663 of file fsvga.c. References FsgVgaInitializeHWFlags(), and _DEVICE_EXTENSION::ScreenAndFont. Referenced by FsVgaDeviceControl(). : This routine sets the screen and font information. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. ScreenInformation - Pointer to the structure containing the information about the screen anf font. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(FSVIDEO_SCREEN_INFORMATION)) { return STATUS_INVALID_BUFFER_SIZE; } DeviceExtension->ScreenAndFont = *ScreenInformation; FsgVgaInitializeHWFlags(DeviceExtension); return STATUS_SUCCESS; }

NTSTATUS FsVgaWriteToFrameBuffer (  PDEVICE_EXTENSION  DeviceExtension, PFSVIDEO_WRITE_TO_FRAME_BUFFER  WriteFrameBuffer, ULONG  inputBufferLength )

Definition at line 1429 of file fsvga.c. References _DEVICE_EXTENSION::CurrentMode, _DEVICE_EXTENSION::DeviceObject, DUMP_COUNT, DWORD, ExAllocatePool, ExFreePool(), FsgWriteToFrameBuffer(), FSVGA_ERROR_VALUE_BASE, FsVgaLogError(), FsVgaPrint, NULL, PagedPool, SCREEN_BUFFER_POINTER, _DEVICE_EXTENSION::ScreenAndFont, SHORT, and TranslateOutputToOem(). Referenced by FsVgaDeviceControl(). : This routine write the frame buffer. Arguments: DeviceExtension - Pointer to the miniport driver's device extension. WriteFrameBuffer - Pointer to the structure containing the information about the write frame buffer. inputBufferLength - Length of the input buffer supplied by the user. Return Value: STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough for the input data. STATUS_SUCCESS if the operation completed successfully. --*/ { // // Check if the size of the data in the input buffer is large enough. // if (inputBufferLength < sizeof(FSVIDEO_WRITE_TO_FRAME_BUFFER)) { return STATUS_INVALID_BUFFER_SIZE; } if (WriteFrameBuffer->DestScreen.Position.X < 0 || WriteFrameBuffer->DestScreen.Position.X > DeviceExtension->ScreenAndFont.ScreenSize.X || (SHORT)(WriteFrameBuffer->DestScreen.Position.X + WriteFrameBuffer->DestScreen.nNumberOfChars) > DeviceExtension->ScreenAndFont.ScreenSize.X || WriteFrameBuffer->DestScreen.Position.Y < 0 || WriteFrameBuffer->DestScreen.Position.Y > DeviceExtension->ScreenAndFont.ScreenSize.Y) { return STATUS_INVALID_BUFFER_SIZE; } if (! (DeviceExtension->CurrentMode.VideoMode.AttributeFlags & VIDEO_MODE_GRAPHICS)) { /* * This is the TEXT frame buffer. */ ULONG Offs; PUCHAR pFrameBuf = DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase; PCHAR_IMAGE_INFO pCharInfoUni = WriteFrameBuffer->SrcBuffer; PCHAR_IMAGE_INFO pCharInfoAsc; DWORD Length = WriteFrameBuffer->DestScreen.nNumberOfChars; PVOID pCapBuffer = NULL; ULONG cCapBuffer = 0; Offs = SCREEN_BUFFER_POINTER(WriteFrameBuffer->DestScreen.Position.X, WriteFrameBuffer->DestScreen.Position.Y, WriteFrameBuffer->DestScreen.ScreenSize.X, sizeof(VGA_CHAR)); cCapBuffer = Length * sizeof(CHAR_IMAGE_INFO); pCapBuffer = ExAllocatePool(PagedPool, cCapBuffer); if (!pCapBuffer) { #define DUMP_COUNT 4 ULONG dumpData[DUMP_COUNT]; FsVgaPrint((1, "FSVGA-FsVgaWriteToFrameBuffer: Could not allocate resource list\n")); // // Log an error. // dumpData[0] = cCapBuffer; FsVgaLogError(DeviceExtension->DeviceObject, FSVGA_INSUFFICIENT_RESOURCES, FSVGA_ERROR_VALUE_BASE + 200, STATUS_INSUFFICIENT_RESOURCES, dumpData, 1 ); return STATUS_UNSUCCESSFUL; } TranslateOutputToOem(pCapBuffer, pCharInfoUni, Length); pCharInfoAsc = pCapBuffer; pFrameBuf += Offs; while (Length--) { *pFrameBuf++ = pCharInfoAsc->CharInfo.Char.AsciiChar; *pFrameBuf++ = (UCHAR) (pCharInfoAsc->CharInfo.Attributes); pCharInfoAsc++; } ExFreePool(pCapBuffer); } else { /* * This is the GRAPHICS frame buffer. */ return FsgWriteToFrameBuffer(DeviceExtension, WriteFrameBuffer, inputBufferLength); } return STATUS_SUCCESS; }

VOID GetHardwareScrollReg (  PDEVICE_EXTENSION  deviceExtension  )

Definition at line 31 of file port.c. References CRTCAddressPortColor, CRTCDataPortColor, _DEVICE_EXTENSION::DeviceRegisters, _DEVICE_EXTENSION::EmulateInfo, high, IND_LINE_COMPARE, IND_LINE_COMPARE8, IND_LINE_COMPARE9, IND_START_ADRS_H, IND_START_ADRS_L, _EMULATE_BUFFER_INFORMATION::LineCompare, low, and _EMULATE_BUFFER_INFORMATION::StartAddress. Referenced by FsgVgaInitializeHWFlags(). : This routine gets the hardware scrolls register value. Arguments: Return Value: --*/ { UCHAR low; UCHAR high; UCHAR mid; WRITE_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCAddressPortColor], IND_START_ADRS_L); low = READ_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCDataPortColor]); WRITE_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCAddressPortColor], IND_START_ADRS_H); high = READ_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCDataPortColor]); deviceExtension->EmulateInfo.StartAddress = MAKEWORD(low, high); WRITE_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCAddressPortColor], IND_LINE_COMPARE); low = READ_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCDataPortColor]); WRITE_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCAddressPortColor], IND_LINE_COMPARE8); mid = READ_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCDataPortColor]); mid = (mid >> 4) & 1; WRITE_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCAddressPortColor], IND_LINE_COMPARE9); high = READ_PORT_UCHAR(deviceExtension->DeviceRegisters[CRTCDataPortColor]); high = (high >> 5) & 2; high |= mid; deviceExtension->EmulateInfo.LineCompare = MAKEWORD(low, high); }

BOOL IsGRAMRowOver (  PUCHAR  BufPtr, BOOL  fDbcs, PDEVICE_EXTENSION  DeviceExtension )

Definition at line 152 of file drawscrn.c. References _DEVICE_EXTENSION::CurrentMode, _EMULATE_BUFFER_INFORMATION::DeltaNextFontRow, DWORD, _DEVICE_EXTENSION::EmulateInfo, FALSE, _EMULATE_BUFFER_INFORMATION::LimitGRAM, and TRUE. Referenced by FsgWriteToScreen(). : This Routine check ROW overflow as GRAM limit line. Arguments: BufPtr - Pointer to graphics buffer. fDbcs - Flag of DBCS(true) or SBCS(false). Return Value: TRUE: if font box is overflow as GRAMlimit line. FALSE: not overflow. --*/ { if (fDbcs) { if ((DWORD)(BufPtr + 1 + DeviceExtension->EmulateInfo.DeltaNextFontRow - (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) >= DeviceExtension->EmulateInfo.LimitGRAM) return TRUE; else return FALSE; } else { if ((DWORD)(BufPtr + DeviceExtension->EmulateInfo.DeltaNextFontRow - (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) >= DeviceExtension->EmulateInfo.LimitGRAM) return TRUE; else return FALSE; } }

VOID memcpyGRAM (  IN PCHAR  TargetPtr, IN PCHAR  SourcePtr, IN ULONG  Length )

Definition at line 233 of file drawscrn.c. Referenced by memcpyGRAMOver(), and MoveGRAM(). : This routine is a memory copy for byte order. Arguments: TargetPtr - Pointer to target graphics buffer. SourcePtr - Pointer to source graphics buffer. Length - Fill length. Return Value: --*/ { while (Length--) *TargetPtr++ = *SourcePtr++; }

VOID memcpyGRAMOver (  IN PCHAR  TargetPtr, IN PCHAR  SourcePtr, IN ULONG  Length, IN PUCHAR  FrameBufPtr, IN PDEVICE_EXTENSION  DeviceExtension )

Definition at line 263 of file drawscrn.c. References DWORD, and memcpyGRAM(). Referenced by MoveGRAM(). : This routine move a graphics buffer. Arguments: TargetPtr - Pointer to target graphics buffer. SourcePtr - Pointer to source graphics buffer. Length - Fill length. Return Value: --*/ { ULONG tmpLen; if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { tmpLen = DeviceExtension->EmulateInfo.LimitGRAM - (SourcePtr - FrameBufPtr); memcpyGRAM(TargetPtr, SourcePtr, tmpLen); TargetPtr += tmpLen; Length -= tmpLen; SourcePtr = FrameBufPtr; } if ((DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { tmpLen = DeviceExtension->EmulateInfo.LimitGRAM - (TargetPtr - FrameBufPtr); memcpyGRAM(TargetPtr, SourcePtr, tmpLen); SourcePtr += tmpLen; Length -= tmpLen; TargetPtr = FrameBufPtr; } if (Length) { memcpyGRAM(TargetPtr, SourcePtr, Length); } }

VOID MoveGRAM (  IN PCHAR  TargetPtr, IN PCHAR  SourcePtr, IN ULONG  Length, IN PUCHAR  FrameBufPtr, IN PDEVICE_EXTENSION  DeviceExtension )

Definition at line 314 of file drawscrn.c. References DWORD, memcpyGRAM(), memcpyGRAMOver(), SetGRAMCopyMode(), and SetGRAMWriteMode(). Referenced by FsgCopyFrameBuffer(). : This routine move a graphics buffer. Arguments: TargetPtr - Pointer to target graphics buffer. SourcePtr - Pointer to source graphics buffer. Length - Fill length. Return Value: none. --*/ { PCHAR tmpSrc; PCHAR tmpTrg; ULONG tmpLen; // // Set copy mode of graphics register // SetGRAMCopyMode(DeviceExtension); if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM || (DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM ) { if (SourcePtr > TargetPtr) { memcpyGRAMOver(TargetPtr,SourcePtr,Length,FrameBufPtr,DeviceExtension); } else if ((ULONG)(TargetPtr - SourcePtr) >= Length) { memcpyGRAMOver(TargetPtr,SourcePtr,Length,FrameBufPtr,DeviceExtension); } else { if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { tmpLen = SourcePtr + Length - FrameBufPtr - DeviceExtension->EmulateInfo.LimitGRAM; tmpTrg = TargetPtr + Length - tmpLen - DeviceExtension->EmulateInfo.LimitGRAM; memcpyGRAM(tmpTrg, FrameBufPtr, tmpLen); Length -= tmpLen; } if ((DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { tmpLen = TargetPtr + Length - FrameBufPtr - DeviceExtension->EmulateInfo.LimitGRAM; tmpSrc = SourcePtr + Length - tmpLen; memcpyGRAM(FrameBufPtr, tmpSrc, tmpLen); Length -= tmpLen; } if (Length) { memcpyGRAM(TargetPtr, SourcePtr, Length); } } } else { memcpyGRAM(TargetPtr, SourcePtr, Length); } SetGRAMWriteMode(DeviceExtension); }

PUCHAR NextGRAMRow (  PUCHAR  BufPtr, PDEVICE_EXTENSION  DeviceExtension )

Definition at line 200 of file drawscrn.c. References _EMULATE_BUFFER_INFORMATION::BytePerLine, _DEVICE_EXTENSION::CurrentMode, DWORD, _DEVICE_EXTENSION::EmulateInfo, and _EMULATE_BUFFER_INFORMATION::LimitGRAM. Referenced by FsgInvertCursor(), FsgReverseMousePointer(), FsgWriteToScreen(), and FsgWriteToScreenCommonLVB(). : This Routine add next row a graphics buffer address. Arguments: BufPtr - Pointer to graphics buffer. Return Value: Returen to graphics buffer address. --*/ { if ((DWORD)(BufPtr + DeviceExtension->EmulateInfo.BytePerLine - (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) >= DeviceExtension->EmulateInfo.LimitGRAM) return (BufPtr + DeviceExtension->EmulateInfo.BytePerLine - DeviceExtension->EmulateInfo.LimitGRAM); else return (BufPtr + DeviceExtension->EmulateInfo.BytePerLine); }

VOID set_opaque_bkgnd_proc (  PDEVICE_EXTENSION  deviceExtension, PUCHAR  FrameBuffer, WORD  Attributes )

Definition at line 186 of file port.c. References BYTE, _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, ColorSetDirect(), _DEVICE_EXTENSION::EmulateInfo, and LOBYTE. Referenced by FsgWriteToScreen(), and FsgWriteToScreenCommonLVB(). { BYTE ColorFg = LOBYTE(Attributes) & 0x0f; BYTE ColorBg = (LOBYTE(Attributes) & 0xf0) >> 4; if (Attributes & COMMON_LVB_REVERSE_VIDEO) { Attributes = ColorBg; ColorBg = ColorFg; ColorFg = (BYTE)Attributes; } if (deviceExtension->EmulateInfo.ColorFg == ColorFg && deviceExtension->EmulateInfo.ColorBg == ColorBg) return; deviceExtension->EmulateInfo.ColorFg = ColorFg; deviceExtension->EmulateInfo.ColorBg = ColorBg; ColorSetDirect(deviceExtension, FrameBuffer, ColorFg, ColorBg); }

VOID SetGRAMCopyMode (  PDEVICE_EXTENSION  deviceExtension  )

Definition at line 121 of file port.c. References _DEVICE_EXTENSION::DeviceRegisters, DR_SET, GRAPHAddressPort, IND_COLOR_DONT_CARE, IND_DATA_ROTATE, IND_GRAPH_MODE, M_COLOR_READ, and M_LATCH_WRITE. Referenced by MoveGRAM(). : This routine sets the copy mode of graphics register. Arguments: Return Value: --*/ { WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_GRAPH_MODE, M_LATCH_WRITE+M_COLOR_READ)); // // Set up to write data without interacting with the latches. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_SET)); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_COLOR_DONT_CARE, 0)); }

VOID SetGRAMInvertMode (  PDEVICE_EXTENSION  deviceExtension  )

Definition at line 152 of file port.c. References BIT_MASK_DEFAULT, _DEVICE_EXTENSION::DeviceRegisters, DR_XOR, GRAPHAddressPort, IND_BIT_MASK, IND_COLOR_DONT_CARE, IND_DATA_ROTATE, IND_GRAPH_MODE, IND_SET_RESET, M_AND_WRITE, and M_COLOR_READ. Referenced by FsgInvertCursor(), and FsgReverseMousePointer(). : This routine sets the invert mode of graphics register. Arguments: Return Value: --*/ { WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_GRAPH_MODE, M_AND_WRITE+M_COLOR_READ)); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_XOR)); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_BIT_MASK, BIT_MASK_DEFAULT)); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_COLOR_DONT_CARE, 0)); WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_SET_RESET, 0xff)); }

VOID SetGRAMWriteMode (  PDEVICE_EXTENSION  deviceExtension  )

Definition at line 81 of file port.c. References BIT_MASK_DEFAULT, _DEVICE_EXTENSION::DeviceRegisters, DR_SET, GRAPH_ADDR_MASK, GRAPHAddressPort, IND_BIT_MASK, IND_DATA_ROTATE, IND_GRAPH_MODE, IND_MAP_MASK, M_DATA_READ, M_PROC_WRITE, and SEQUAddressPort. Referenced by FsgInvertCursor(), FsgReverseMousePointer(), FsgVgaInitializeHWFlags(), FsgWriteToScreenCommonLVB(), and MoveGRAM(). : This routine sets the write mode of graphics register. Arguments: Return Value: --*/ { WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_GRAPH_MODE, M_PROC_WRITE+M_DATA_READ)); // // Set up to write data without interacting with the latches. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_DATA_ROTATE, DR_SET)); // // Enable all the available EGA planes. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[SEQUAddressPort], MAKEWORD(IND_MAP_MASK, GRAPH_ADDR_MASK)); // // Use all pixel positions. // WRITE_PORT_USHORT(deviceExtension->DeviceRegisters[GRAPHAddressPort], MAKEWORD(IND_BIT_MASK, BIT_MASK_DEFAULT)); }

NTSTATUS TranslateOutputToOem (  OUT PCHAR_IMAGE_INFO  OutputBuffer, IN PCHAR_IMAGE_INFO  InputBuffer, IN DWORD  Length )

Definition at line 86 of file w32/ntcon/fullscr/vga/misc.c. References CHAR, and ConvertOutputToOem(). Referenced by FsVgaWriteToFrameBuffer(), and SrvReadConsoleOutput(). { CHAR AsciiDbcs[2]; ULONG NumBytes; while (Length--) { if (InputBuffer->CharInfo.Attributes & COMMON_LVB_LEADING_BYTE) { if (Length >= 2) // Safe DBCS in buffer ? { Length--; NumBytes = sizeof(AsciiDbcs); NumBytes = ConvertOutputToOem(&InputBuffer->CharInfo.Char.UnicodeChar, 1, &AsciiDbcs[0], NumBytes); OutputBuffer->CharInfo.Char.AsciiChar = AsciiDbcs[0]; OutputBuffer->CharInfo.Attributes = InputBuffer->CharInfo.Attributes; OutputBuffer++; InputBuffer++; OutputBuffer->CharInfo.Char.AsciiChar = AsciiDbcs[1]; OutputBuffer->CharInfo.Attributes = InputBuffer->CharInfo.Attributes; OutputBuffer++; InputBuffer++; } else { OutputBuffer->CharInfo.Char.AsciiChar = ' '; OutputBuffer->CharInfo.Attributes = InputBuffer->CharInfo.Attributes & ~COMMON_LVB_SBCSDBCS; OutputBuffer++; InputBuffer++; } } else if (! (InputBuffer->CharInfo.Attributes & COMMON_LVB_SBCSDBCS)) { ConvertOutputToOem(&InputBuffer->CharInfo.Char.UnicodeChar, 1, &OutputBuffer->CharInfo.Char.AsciiChar, 1); OutputBuffer->CharInfo.Attributes = InputBuffer->CharInfo.Attributes; OutputBuffer++; InputBuffer++; } } return STATUS_SUCCESS; }

---