fsvga.c File Reference

#include "stdarg.h"
#include "stdio.h"
#include "ntddk.h"
#include "fsvga.h"
#include "fsvgalog.h"

Go to the source code of this file.

Defines
#define	NAME_MAX   256
#define	DUMP_COUNT   4
#define	PARAMETER_MAX   256
#define	DUMP_COUNT   4
#define	DUMP_COUNT   4
Functions
NTSTATUS	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID	FsVgaConfiguration (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING FsVgaDeviceName)
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)

---

Define Documentation

#define DUMP_COUNT   4

#define DUMP_COUNT   4

#define DUMP_COUNT   4

Referenced by DriverEntry(), FsVgaBuildResourceList(), and FsVgaWriteToFrameBuffer().

#define NAME_MAX   256

Referenced by DriverEntry().

#define PARAMETER_MAX   256

---

Function Documentation

NTSTATUS DriverEntry (  IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING  RegistryPath )

Definition at line 53 of file fsvga.c. References ASSERT, _FSVGA_CONFIGURATION_INFORMATION::BusNumber, CdfsFileSystem, _DEVICE_EXTENSION::Configuration, DEVICE_EXTENSION, _DEVICE_OBJECT::DeviceExtension, _DEVICE_EXTENSION::DeviceObject, _DEVICE_EXTENSION::DeviceRegisters, DriverEntry(), DUMP_COUNT, ExAllocatePool, ExAllocatePoolWithTag, ExFreePool(), FALSE, FatFileSystem, FSREC_POOL_TAG, FsRecCleanupClose(), FsRecCreate(), FsRecCreateAndRegisterDO(), FsRecFsControl(), FsRecLoadSync, FsRecUnload(), FSVGA_ERROR_VALUE_BASE, FSVGA_HARDWARE_PRESENT, FsVgaBuildResourceList(), FsVgaConfiguration(), FsVgaDeviceControl(), FsVgaOpenCloseDispatch(), FsVgaPrint, HalTranslateBusAddress(), _DEVICE_EXTENSION::HardwarePresent, _FSVGA_CONFIGURATION_INFORMATION::InterfaceType, IoAllocateErrorLogEntry(), IoCreateDevice(), IoDeleteDevice(), IoReportResourceUsage(), IoWriteErrorLogEntry(), IRP_MJ_CLEANUP, IRP_MJ_CLOSE, IRP_MJ_CREATE, IRP_MJ_DEVICE_CONTROL, IRP_MJ_FILE_SYSTEM_CONTROL, KeInitializeEvent, L, MmMapIoSpace(), MmPageEntireDriver(), MmUnmapIoSpace(), NAME_MAX, NonPagedPool, NT_SUCCESS, NtfsFileSystem, NTSTATUS(), NULL, PAGED_CODE, PagedPool, _FSVGA_CONFIGURATION_INFORMATION::PortList, _FSVGA_CONFIGURATION_INFORMATION::PortListCount, RtlAppendUnicodeStringToString(), RtlAppendUnicodeToString(), RtlInitUnicodeString(), RtlIntegerToUnicodeString(), RtlWriteRegistryValue(), TRUE, UdfsFileSystem, _DEVICE_EXTENSION::UnmapRegistersRequired, and USHORT. : Installable driver initialization entry point. This entry point is called directly by the I/O system. Arguments: DriverObject - Pointer to driver object created by system. RegistryPath - Pointer to the Unicode name of the registry path for this driver. Return Value: The function value is the final status from the initialization operation. --*/ { PDEVICE_OBJECT DeviceObject = NULL; PDEVICE_EXTENSION deviceExtension = NULL; DEVICE_EXTENSION tmpDeviceExtension; NTSTATUS status = STATUS_SUCCESS; PCM_RESOURCE_LIST resources = NULL; ULONG resourceListSize = 0; BOOLEAN overrideConflict; BOOLEAN conflictDetected; ULONG addressSpace; PHYSICAL_ADDRESS cardAddress; ULONG i; UNICODE_STRING fullFsVgaName; UNICODE_STRING baseFsVgaName; UNICODE_STRING deviceNameSuffix; UNICODE_STRING resourceDeviceClass; UNICODE_STRING registryPath; #define NAME_MAX 256 WCHAR FsVgaBuffer[NAME_MAX]; ULONG uniqueErrorValue; NTSTATUS errorCode = STATUS_SUCCESS; ULONG dumpCount = 0; #define DUMP_COUNT 4 ULONG dumpData[DUMP_COUNT]; FsVgaPrint((1, "\n\nFSVGA-FSVGAInitialize: enter\n")); // // Zero-initialize various structures. // RtlZeroMemory(&tmpDeviceExtension, sizeof(DEVICE_EXTENSION)); fullFsVgaName.MaximumLength = 0; fullFsVgaName.Length = 0; deviceNameSuffix.MaximumLength = 0; deviceNameSuffix.Length = 0; resourceDeviceClass.MaximumLength = 0; resourceDeviceClass.Length = 0; registryPath.MaximumLength = 0; registryPath.Length = 0; RtlZeroMemory(FsVgaBuffer, NAME_MAX * sizeof(WCHAR)); baseFsVgaName.Buffer = FsVgaBuffer; baseFsVgaName.Length = 0; baseFsVgaName.MaximumLength = NAME_MAX * sizeof(WCHAR); RtlZeroMemory(dumpData, sizeof(dumpData)); // // Need to ensure that the registry path is null-terminated. // Allocate pool to hold a null-terminated copy of the path. // registryPath.Buffer = ExAllocatePool(PagedPool, RegistryPath->Length + sizeof(UNICODE_NULL)); if (!registryPath.Buffer) { FsVgaPrint((1, "FSVGA-FSVGAInitialize: Couldn't allocate pool for registry path\n")); status = STATUS_UNSUCCESSFUL; errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 2; dumpData[0] = (ULONG) RegistryPath->Length + sizeof(UNICODE_NULL); dumpCount = 1; goto FsVgaInitializeExit; } else { registryPath.Length = RegistryPath->Length + sizeof(UNICODE_NULL); registryPath.MaximumLength = registryPath.Length; RtlZeroMemory(registryPath.Buffer, registryPath.Length); RtlMoveMemory(registryPath.Buffer, RegistryPath->Buffer, RegistryPath->Length); } // // Get the configuration information for this driver. // FsVgaConfiguration(&tmpDeviceExtension, &registryPath, &baseFsVgaName); if (!(tmpDeviceExtension.HardwarePresent & FSVGA_HARDWARE_PRESENT)) { // // There is neither a Full Screen Video attached. Free // resources and return with unsuccessful status. // FsVgaPrint((1, "FSVGA-FsVgaInitialize: No Full Screen Video attached.\n")); status = STATUS_NO_SUCH_DEVICE; errorCode = FSVGA_NO_SUCH_DEVICE; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 4; goto FsVgaInitializeExit; } // // Set up space for the port's device object suffix. Note that // we overallocate space for the suffix string because it is much // easier than figuring out exactly how much space is required. // The storage gets freed at the end of driver initialization, so // who cares... // RtlInitUnicodeString(&deviceNameSuffix, NULL); deviceNameSuffix.MaximumLength = FULLSCREEN_VIDEO_SUFFIX_MAXIMUM * sizeof(WCHAR); deviceNameSuffix.MaximumLength += sizeof(UNICODE_NULL); deviceNameSuffix.Buffer = ExAllocatePool(PagedPool, deviceNameSuffix.MaximumLength); if (!deviceNameSuffix.Buffer) { FsVgaPrint((1, "FSVGA-FsVgaInitialize: Couldn't allocate string for device object suffix\n")); status = STATUS_UNSUCCESSFUL; errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 8; dumpData[0] = (ULONG) deviceNameSuffix.MaximumLength; dumpCount = 1; goto FsVgaInitializeExit; } RtlZeroMemory(deviceNameSuffix.Buffer, deviceNameSuffix.MaximumLength); // // Set up space for the port's Full Screen Video device object name. // RtlInitUnicodeString(&fullFsVgaName, NULL); fullFsVgaName.MaximumLength = sizeof(L"\\Device\\") + baseFsVgaName.Length + deviceNameSuffix.MaximumLength; fullFsVgaName.Buffer = ExAllocatePool(PagedPool, fullFsVgaName.MaximumLength); if (!fullFsVgaName.Buffer) { FsVgaPrint((1, "FSVGA-FsVgaInitialize: Couldn't allocate string for Full Screen Video device object name\n")); status = STATUS_UNSUCCESSFUL; errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 10; dumpData[0] = (ULONG) fullFsVgaName.MaximumLength; dumpCount = 1; goto FsVgaInitializeExit; } RtlZeroMemory(fullFsVgaName.Buffer, fullFsVgaName.MaximumLength); RtlAppendUnicodeToString(&fullFsVgaName, L"\\Device\\"); RtlAppendUnicodeToString(&fullFsVgaName, baseFsVgaName.Buffer); // // Append the suffix to the device object name string. E.g., turn // \Device\FullScreenVideo into \Device\FullScreenVideo0. Then we attempt // to create the device object. If the device object already // exists (because it was already created by another port driver), // increment the suffix and try again. // status = RtlIntegerToUnicodeString( 0, // suffix number = 0 10, &deviceNameSuffix); if (!NT_SUCCESS(status)) { FsVgaPrint((1, "FSVGA-FsVgaInitialize: Could not create suffix number\n")); errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 12; dumpData[0] = (ULONG) 0; // suffix number = 0 dumpCount = 1; goto FsVgaInitializeExit; } RtlAppendUnicodeStringToString(&fullFsVgaName, &deviceNameSuffix); FsVgaPrint((1, "FSVGA-FSVGAInitialize: Creating device object named %ws\n", fullFsVgaName.Buffer)); // // Create device object for the FsVga device. // Note that we specify that this is a exclusive device. // status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION), &fullFsVgaName, FILE_DEVICE_FULLSCREEN_VIDEO, 0, TRUE, &DeviceObject); if (!NT_SUCCESS(status)) { FsVgaPrint((1, "FSVGA-FSVGAInitialize: Couldn't create device object = %ws\n")); status = STATUS_UNSUCCESSFUL; errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 2; dumpData[0] = (ULONG) RegistryPath->Length + sizeof(UNICODE_NULL); dumpCount = 1; goto FsVgaInitializeExit; } // // Set up the device extension. // deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension; *deviceExtension = tmpDeviceExtension; deviceExtension->DeviceObject = DeviceObject; // // Set up the resource list prior to reporting resource usage. // FsVgaBuildResourceList(deviceExtension, &resources, &resourceListSize); // // Set up space for the resource device class name. // RtlInitUnicodeString(&resourceDeviceClass, NULL); resourceDeviceClass.MaximumLength = baseFsVgaName.Length; resourceDeviceClass.Buffer = ExAllocatePool(PagedPool, resourceDeviceClass.MaximumLength); if (!resourceDeviceClass.Buffer) { FsVgaPrint((1, "FSVGA-FsVgaInitialize: Couldn't allocate string for resource device class name\n")); status = STATUS_UNSUCCESSFUL; errorCode = FSVGA_INSUFFICIENT_RESOURCES; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 15; dumpData[0] = (ULONG) resourceDeviceClass.MaximumLength; dumpCount = 1; goto FsVgaInitializeExit; } // // Form the resource device class name from the Full Screen Video // device names. // RtlZeroMemory(resourceDeviceClass.Buffer, resourceDeviceClass.MaximumLength); RtlAppendUnicodeStringToString(&resourceDeviceClass, &baseFsVgaName); // // Report resource usage for the registry. // // // If we are loading the VGA, do not generate an error if it conflicts // with another driver. // // overrideConflict = pOverrideConflict(DeviceExtension, TRUE); overrideConflict = TRUE; #if DBG if (overrideConflict) { FsVgaPrint((2, "We are checking the vga driver resources\n")); } else { FsVgaPrint((2, "We are NOT checking vga driver resources\n")); } #endif status = IoReportResourceUsage(&resourceDeviceClass, DriverObject, NULL, 0, DeviceObject, resources, resourceListSize, overrideConflict, &conflictDetected ); // // If we tried to override the conflict, let's take a look a what // we want to do with the result // if ((NT_SUCCESS(status)) && overrideConflict && conflictDetected) { // // For cases like DetectDisplay, a conflict is bad and we do // want to fail. // // In the case of Basevideo, a conflict is possible. But we still // want to load the VGA anyways. Return success and reset the // conflict flag ! // // pOverrideConflict with the FALSE flag will check that. // // // if (pOverrideConflict(DeviceExtension, FALSE)) { // error // } // else { conflictDetected = FALSE; // } } if (conflictDetected) { // // Some other device already owns the Full Screen Video ports. // Fatal error. // FsVgaPrint((1, "FSVGA-FsVgaInitialize: Resource usage conflict\n")); // // Set up error log info. // status = STATUS_INSUFFICIENT_RESOURCES; errorCode = FSVGA_RESOURCE_CONFLICT; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 20; dumpData[0] = (ULONG) resources->List[0].PartialResourceList.PartialDescriptors[0].u.Port.Start.LowPart; dumpData[1] = (ULONG) resources->List[0].PartialResourceList.PartialDescriptors[1].u.Port.Start.LowPart; dumpData[2] = (ULONG) resources->List[0].PartialResourceList.PartialDescriptors[2].u.Port.Start.LowPart; dumpCount = 3; goto FsVgaInitializeExit; } // // Map the VGA controller registers. // for (i = 0; i < deviceExtension->Configuration.PortListCount; i++) { addressSpace = (deviceExtension->Configuration.PortList[i].Flags & CM_RESOURCE_PORT_IO) == CM_RESOURCE_PORT_IO? 1:0; if (!HalTranslateBusAddress(deviceExtension->Configuration.InterfaceType, deviceExtension->Configuration.BusNumber, deviceExtension->Configuration.PortList[i].u.Port.Start, &addressSpace, &cardAddress )) { addressSpace = 1; cardAddress.QuadPart = 0; } if (!addressSpace) { deviceExtension->UnmapRegistersRequired = TRUE; deviceExtension->DeviceRegisters[i] = MmMapIoSpace( cardAddress, deviceExtension->Configuration.PortList[i].u.Port.Length, FALSE ); } else { deviceExtension->UnmapRegistersRequired = FALSE; deviceExtension->DeviceRegisters[i] = (PVOID)cardAddress.LowPart; } if (!deviceExtension->DeviceRegisters[i]) { FsVgaPrint((1, "FSVGA-FsVgaInitialize: Couldn't map the device registers.\n")); status = STATUS_NONE_MAPPED; // // Set up error log info. // errorCode = FSVGA_REGISTERS_NOT_MAPPED; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 30; dumpData[0] = cardAddress.LowPart; dumpCount = 1; goto FsVgaInitializeExit; } } // // Once initialization is finished, load the device map information // into the registry so that setup can determine which full screen // port are active. // if (deviceExtension->HardwarePresent & FSVGA_HARDWARE_PRESENT) { status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP, baseFsVgaName.Buffer, fullFsVgaName.Buffer, REG_SZ, registryPath.Buffer, registryPath.Length); if (!NT_SUCCESS(status)) { FsVgaPrint((1, "FSVGA-FSVGAInitialize: Could not store keyboard name in DeviceMap\n")); errorCode = FSVGA_NO_DEVICEMAP_CREATED; uniqueErrorValue = FSVGA_ERROR_VALUE_BASE + 90; dumpCount = 0; goto FsVgaInitializeExit; } else { FsVgaPrint((1, "FSVGA-FSVGAInitialize: Stored pointer name in DeviceMap\n")); } } ASSERT(status == STATUS_SUCCESS); // // Set up the device driver entry points. // DriverObject->MajorFunction[IRP_MJ_CREATE] = FsVgaOpenCloseDispatch; DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsVgaOpenCloseDispatch; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FsVgaDeviceControl; FsVgaInitializeExit: if (errorCode != STATUS_SUCCESS) { PIO_ERROR_LOG_PACKET errorLogEntry; ULONG i; // // Log an error/warning message. // errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry( (DeviceObject == NULL) ? (PVOID) DriverObject : (PVOID) 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 = status; for (i = 0; i < dumpCount; i++) errorLogEntry->DumpData[i] = dumpData[i]; IoWriteErrorLogEntry(errorLogEntry); } } if (!NT_SUCCESS(status)) { // // The initialization failed. Cleanup resources before exiting. // if (resources) { // // Call IoReportResourceUsage to remove the resources from // the map. // resources->Count = 0; IoReportResourceUsage(&resourceDeviceClass, DriverObject, NULL, 0, DeviceObject, resources, resourceListSize, FALSE, &conflictDetected ); } if (deviceExtension) { if (deviceExtension->UnmapRegistersRequired) { for (i = 0; i < deviceExtension->Configuration.PortListCount; i++){ if (deviceExtension->DeviceRegisters[i]) { MmUnmapIoSpace( deviceExtension->DeviceRegisters[i], deviceExtension->Configuration.PortList[i].u.Port.Length); } } } } if (DeviceObject) { IoDeleteDevice(DeviceObject); } } // // Free the resource list. // // N.B. If we ever decide to hang on to the resource list instead, // we need to allocate it from non-paged pool (it is now paged pool). // if (resources) { ExFreePool(resources); } // // Free the unicode strings for device names. // if (deviceNameSuffix.MaximumLength != 0) ExFreePool(deviceNameSuffix.Buffer); if (fullFsVgaName.MaximumLength != 0) ExFreePool(fullFsVgaName.Buffer); if (resourceDeviceClass.MaximumLength != 0) ExFreePool(resourceDeviceClass.Buffer); if (registryPath.MaximumLength != 0) ExFreePool(registryPath.Buffer); FsVgaPrint((1, "FSVGA-FsVgaInitialize: exit\n")); return(status); }

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  FsVgaDeviceName )

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 BusNumber, _FSVGA_CONFIGURATION_INFORMATION::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; }

---