vgamp.c File Reference

#include "vgamp.h"
#include <dderror.h>
#include <devioctl.h>

Include dependency graph for vgamp.c:

Go to the source code of this file.

Functions
ULONG NTAPI	DriverEntry (IN PVOID Context1, IN PVOID Context2)
VP_STATUS NTAPI	VGAFindAdapter (PVOID DeviceExtension, PVOID Context, PWSTR ArgumentString, PVIDEO_PORT_CONFIG_INFO ConfigInfo, PUCHAR Again)
BOOLEAN NTAPI	VGAInitialize (PVOID DeviceExtension)
BOOLEAN NTAPI	VGAStartIO (PVOID DeviceExtension, PVIDEO_REQUEST_PACKET RequestPacket)
BOOLEAN NTAPI	VGAResetHw (PVOID DeviceExtension, ULONG Columns, ULONG Rows)
BOOLEAN	VGAMapVideoMemory (IN PVOID DeviceExtension, IN PVIDEO_MEMORY RequestedAddress, OUT PVIDEO_MEMORY_INFORMATION MapInformation, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGAQueryAvailModes (OUT PVIDEO_MODE_INFORMATION ReturnedModes, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGAQueryCurrentMode (OUT PVIDEO_MODE_INFORMATION CurrentMode, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGAQueryNumAvailModes (OUT PVIDEO_NUM_MODES NumberOfModes, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGASetPaletteRegisters (IN PUSHORT PaletteRegisters, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGASetColorRegisters (IN PVIDEO_CLUT ColorLookUpTable, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGASetCurrentMode (IN PVIDEO_MODE RequestedMode, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGAShareVideoMemory (_In_ PVOID DeviceExtension, _In_ PVIDEO_SHARE_MEMORY RequestedMemory, _Out_ PVIDEO_MEMORY_INFORMATION ReturnedMemory, _Out_ PSTATUS_BLOCK StatusBlock)
	Shares a portion of VGA video memory with a VDM.
BOOLEAN	VGAUnmapVideoMemory (IN PVOID DeviceExtension, IN PVIDEO_MEMORY MemoryToUnmap, OUT PSTATUS_BLOCK StatusBlock)
BOOLEAN	VGAUnshareVideoMemory (IN PVIDEO_MEMORY MemoryToUnshare, OUT PSTATUS_BLOCK StatusBlock)

Variables
VIDEO_ACCESS_RANGE	VGAAccessRange []

Function Documentation

DriverEntry()

ULONG NTAPI DriverEntry	(	IN PVOID	Context1,
		IN PVOID	Context2
	)

Definition at line 37 of file vgamp.c.

{
  VIDEO_HW_INITIALIZATION_DATA  InitData;
 
  VideoPortZeroMemory(&InitData, sizeof InitData);
 
  InitData.HwInitDataSize = sizeof(InitData);
  /* FIXME: Fill in InitData members  */
  InitData.StartingDeviceNumber = 0;
 
  /*  Export driver entry points...  */
  InitData.HwFindAdapter = VGAFindAdapter;
  InitData.HwInitialize = VGAInitialize;
  InitData.HwStartIO = VGAStartIO;
  /* InitData.HwInterrupt = VGAInterrupt;  */
  InitData.HwResetHw = VGAResetHw;
  /* InitData.HwTimer = VGATimer;  */
  InitData.HwLegacyResourceList = VGAAccessRange;
  InitData.HwLegacyResourceCount = ARRAYSIZE(VGAAccessRange);
 
  InitData.AdapterInterfaceType = Isa;
  return  VideoPortInitialize(Context1, Context2, &InitData, NULL);
}

VGAFindAdapter()

VP_STATUS NTAPI VGAFindAdapter	(	PVOID	DeviceExtension,
		PVOID	Context,
		PWSTR	ArgumentString,
		PVIDEO_PORT_CONFIG_INFO	ConfigInfo,
		PUCHAR	Again
	)

Definition at line 89 of file vgamp.c.

{
    VP_STATUS Status;
 
    /* FIXME: Determine if the adapter is present  */
    *Again = FALSE;
 
    if (ConfigInfo->Length < sizeof(VIDEO_PORT_CONFIG_INFO))
        return ERROR_INVALID_PARAMETER;
 
    Status = VideoPortVerifyAccessRanges(DeviceExtension, ARRAYSIZE(VGAAccessRange), VGAAccessRange);
    if (Status != NO_ERROR)
        return Status;
 
    ConfigInfo->VdmPhysicalVideoMemoryAddress = VGAAccessRange[2].RangeStart;
    ConfigInfo->VdmPhysicalVideoMemoryLength = VGAAccessRange[2].RangeLength;
    return NO_ERROR;
 
  /* FIXME: Claim any necessary memory/IO resources for the adapter  */
  /* FIXME: Map resources into system memory for the adapter  */
  /* FIXME: Fill in relevant information in the VIDEO_PORT_CONFIG_INFO buffer  */
  /* FIXME: Update registry settings for adapter specifics.  */
//  return  NO_ERROR;
}

Referenced by DriverEntry().

VGAInitialize()

BOOLEAN NTAPI VGAInitialize

(

PVOID

DeviceExtension

)

Definition at line 132 of file vgamp.c.

{
  return  TRUE;
}

Referenced by DriverEntry().

VGAMapVideoMemory()

BOOLEAN VGAMapVideoMemory	(	IN PVOID	DeviceExtension,
		IN PVIDEO_MEMORY	RequestedAddress,
		OUT PVIDEO_MEMORY_INFORMATION	MapInformation,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 426 of file vgamp.c.

{
  ULONG ReturnedLength;
  PVOID ReturnedAddress;
  ULONG IoSpace;
  PHYSICAL_ADDRESS FrameBufferBase;
  ReturnedAddress = RequestedAddress->RequestedVirtualAddress;
  ReturnedLength = 256 * 1024;
  FrameBufferBase.QuadPart = 0xA0000;
  IoSpace = VIDEO_MEMORY_SPACE_MEMORY;
  StatusBlock->Status = VideoPortMapMemory(DeviceExtension,
                       FrameBufferBase,
                       &ReturnedLength,
                       &IoSpace,
                       &ReturnedAddress);
  if (StatusBlock->Status != 0)
    {
      StatusBlock->Information = 0;
      return TRUE;
    }
  MapInformation->VideoRamBase = MapInformation->FrameBufferBase =
    ReturnedAddress;
  MapInformation->VideoRamLength = MapInformation->FrameBufferLength =
    ReturnedLength;
  StatusBlock->Information = sizeof(VIDEO_MEMORY_INFORMATION);
  return TRUE;
}

Referenced by VGAStartIO().

VGAQueryAvailModes()

BOOLEAN VGAQueryAvailModes	(	OUT PVIDEO_MODE_INFORMATION	ReturnedModes,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 457 of file vgamp.c.

{
  /* Only one mode exists in VGA (640x480), so use VGAQueryCurrentMode */
  return VGAQueryCurrentMode(ReturnedModes, StatusBlock);
}

Referenced by VGAStartIO().

VGAQueryCurrentMode()

BOOLEAN VGAQueryCurrentMode	(	OUT PVIDEO_MODE_INFORMATION	CurrentMode,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 464 of file vgamp.c.

{
  CurrentMode->Length = sizeof(VIDEO_MODE_INFORMATION);
  CurrentMode->ModeIndex = 2;
  CurrentMode->VisScreenWidth = 640;
  CurrentMode->VisScreenHeight = 480;
  CurrentMode->ScreenStride = 80;
  CurrentMode->NumberOfPlanes = 4;
  CurrentMode->BitsPerPlane = 1;
  CurrentMode->Frequency = 60;
  CurrentMode->XMillimeter = 320;
  CurrentMode->YMillimeter = 240;
  CurrentMode->NumberRedBits =
  CurrentMode->NumberGreenBits =
  CurrentMode->NumberBlueBits = 6;
  CurrentMode->RedMask =
  CurrentMode->GreenMask =
  CurrentMode->BlueMask = 0;
  CurrentMode->VideoMemoryBitmapWidth = 640;
  CurrentMode->VideoMemoryBitmapHeight = 480;
  CurrentMode->AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR |
      VIDEO_MODE_NO_OFF_SCREEN;
  CurrentMode->DriverSpecificAttributeFlags = 0;
 
  StatusBlock->Information = sizeof(VIDEO_MODE_INFORMATION);
  return TRUE;
}

Referenced by VGAQueryAvailModes(), and VGAStartIO().

VGAQueryNumAvailModes()

BOOLEAN VGAQueryNumAvailModes	(	OUT PVIDEO_NUM_MODES	NumberOfModes,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 493 of file vgamp.c.

{
  NumberOfModes->NumModes = 1;
  NumberOfModes->ModeInformationLength = sizeof(VIDEO_MODE_INFORMATION);
  StatusBlock->Information = sizeof(VIDEO_NUM_MODES);
  return TRUE;
}

Referenced by VGAStartIO().

VGAResetHw()

BOOLEAN NTAPI VGAResetHw	(	PVOID	DeviceExtension,
		ULONG	Columns,
		ULONG	Rows
	)

Definition at line 397 of file vgamp.c.

{
  /* We don't anything to the vga that int10 can't cope with. */
  return(FALSE);
}

Referenced by DriverEntry().

VGASetColorRegisters()

BOOLEAN VGASetColorRegisters	(	IN PVIDEO_CLUT	ColorLookUpTable,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 531 of file vgamp.c.

{
  int i;
 
  for (i=ColorLookUpTable->FirstEntry; i<ColorLookUpTable->NumEntries; i++)
  {
    VideoPortWritePortUchar((PUCHAR)0x03c8, i);
    VideoPortWritePortUchar((PUCHAR)0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Red);
    VideoPortWritePortUchar((PUCHAR)0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Green);
    VideoPortWritePortUchar((PUCHAR)0x03c9, ColorLookUpTable->LookupTable[i].RgbArray.Blue);
  }
 
  return TRUE;
}

Referenced by VGAStartIO().

VGASetCurrentMode()

BOOLEAN VGASetCurrentMode	(	IN PVIDEO_MODE	RequestedMode,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 547 of file vgamp.c.

{
  if(RequestedMode->RequestedMode == 2)
  {
    InitVGAMode();
    return TRUE;
  } else {
    VideoPortDebugPrint(Warn, "Unrecognised mode for VGASetCurrentMode\n");
    return FALSE;
  }
}

Referenced by VGAStartIO().

VGASetPaletteRegisters()

BOOLEAN VGASetPaletteRegisters	(	IN PUSHORT	PaletteRegisters,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 502 of file vgamp.c.

{
  ;
 
/*
  We don't need the following code because the palette registers are set correctly on VGA initialization.
  Still, we may include\test this is in the future.
 
  int i, j = 2;
  char tmp, v;
 
  tmp = VideoPortReadPortUchar(0x03da);
  v = VideoPortReadPortUchar(0x03c0);
 
  // Set the first 16 palette registers to map to the first 16 palette colors
  for (i=PaletteRegisters[1]; i<PaletteRegisters[0]; i++)
  {
    tmp = VideoPortReadPortUchar(0x03da);
    VideoPortWritePortUchar(0x03c0, i);
    VideoPortWritePortUchar(0x03c0, PaletteRegisters[j++]);
  }
 
  tmp = VideoPortReadPortUchar(0x03da);
  VideoPortWritePortUchar(0x03d0, v | 0x20);
*/
  return TRUE;
}

Referenced by VGAStartIO().

VGAShareVideoMemory()

BOOLEAN VGAShareVideoMemory	(	_In_ PVOID	DeviceExtension,
		_In_ PVIDEO_SHARE_MEMORY	RequestedMemory,
		_Out_ PVIDEO_MEMORY_INFORMATION	ReturnedMemory,
		_Out_ PSTATUS_BLOCK	StatusBlock
	)

Shares a portion of VGA video memory with a VDM.

Parameters

[in]	DeviceExtension	Miniport device extension.
[in]	RequestedMemory	Specifies the process, offset, size, and requested virtual address of the shared view.
[out]	ReturnedMemory	Receives the base and length of the mapped shared view.
[out]	StatusBlock	Receives the operation status.

Returns

TRUE always. Failure is returned through StatusBlock->Status.

Definition at line 581 of file vgamp.c.

{
    ULONG ReturnedLength;
    PVOID ReturnedAddress;
    ULONG IoSpace;
    PHYSICAL_ADDRESS FrameBufferBase;
 
    /* Requested view must fall in the 64K VGA gap at 0xA0000 */
    if (RequestedMemory->ViewOffset + RequestedMemory->ViewSize > 0x10000)
    {
        StatusBlock->Status = ERROR_INVALID_PARAMETER;
        StatusBlock->Information = 0;
        return TRUE;
    }
 
    ReturnedAddress = RequestedMemory->RequestedVirtualAddress;
    ReturnedLength = RequestedMemory->ViewSize;
    FrameBufferBase.QuadPart = 0xA0000 + RequestedMemory->ViewOffset;
    IoSpace = VIDEO_MEMORY_SPACE_MEMORY;
 
    StatusBlock->Status = VideoPortMapMemory(DeviceExtension,
                                              FrameBufferBase,
                                              &ReturnedLength,
                                              &IoSpace,
                                              &ReturnedAddress);
    if (StatusBlock->Status != NO_ERROR)
    {
        StatusBlock->Information = 0;
        return TRUE;
    }
 
    ReturnedMemory->VideoRamBase = ReturnedMemory->FrameBufferBase = ReturnedAddress;
    ReturnedMemory->VideoRamLength = ReturnedMemory->FrameBufferLength = ReturnedLength;
    StatusBlock->Information = sizeof(VIDEO_MEMORY_INFORMATION);
 
    return TRUE;
}

Referenced by VGAStartIO().

VGAStartIO()

BOOLEAN NTAPI VGAStartIO	(	PVOID	DeviceExtension,
		PVIDEO_REQUEST_PACKET	RequestPacket
	)

Definition at line 189 of file vgamp.c.

{
  BOOLEAN Result;
 
  RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
 
  switch (RequestPacket->IoControlCode)
    {
    case  IOCTL_VIDEO_MAP_VIDEO_MEMORY:
      if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MEMORY_INFORMATION) ||
          RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAMapVideoMemory(DeviceExtension,
            (PVIDEO_MEMORY) RequestPacket->InputBuffer,
                         (PVIDEO_MEMORY_INFORMATION)
                         RequestPacket->OutputBuffer,
                         RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_QUERY_AVAIL_MODES:
      if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MODE_INFORMATION))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAQueryAvailModes((PVIDEO_MODE_INFORMATION) RequestPacket->OutputBuffer,
                         RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_QUERY_CURRENT_MODE:
      if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MODE_INFORMATION))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAQueryCurrentMode((PVIDEO_MODE_INFORMATION) RequestPacket->OutputBuffer,
                          RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES:
      if (RequestPacket->OutputBufferLength < sizeof(VIDEO_NUM_MODES))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAQueryNumAvailModes((PVIDEO_NUM_MODES) RequestPacket->OutputBuffer,
                            RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_RESET_DEVICE:
      VGAResetDevice(RequestPacket->StatusBlock);
      Result = TRUE;
      break;
 
    case  IOCTL_VIDEO_SET_COLOR_REGISTERS:
      if (RequestPacket->InputBufferLength < sizeof(VIDEO_CLUT) ||
          RequestPacket->InputBufferLength <
          (((PVIDEO_CLUT)RequestPacket->InputBuffer)->NumEntries * sizeof(ULONG)) +
          FIELD_OFFSET(VIDEO_CLUT, LookupTable))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGASetColorRegisters((PVIDEO_CLUT) RequestPacket->InputBuffer,
                           RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_SET_CURRENT_MODE:
      if (RequestPacket->InputBufferLength < sizeof(VIDEO_MODE))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGASetCurrentMode((PVIDEO_MODE) RequestPacket->InputBuffer,
                        RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_SHARE_VIDEO_MEMORY:
      if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MEMORY_INFORMATION) ||
          RequestPacket->InputBufferLength < sizeof(VIDEO_SHARE_MEMORY))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAShareVideoMemory(DeviceExtension,
                          (PVIDEO_SHARE_MEMORY) RequestPacket->InputBuffer,
                          (PVIDEO_MEMORY_INFORMATION) RequestPacket->OutputBuffer,
                          RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_UNMAP_VIDEO_MEMORY:
      if (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAUnmapVideoMemory(DeviceExtension,
              (PVIDEO_MEMORY) RequestPacket->InputBuffer,
                          RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY:
      if (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY))
      {
        RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
        return TRUE;
      }
      Result = VGAUnshareVideoMemory((PVIDEO_MEMORY) RequestPacket->InputBuffer,
                            RequestPacket->StatusBlock);
      break;
    case  IOCTL_VIDEO_SET_PALETTE_REGISTERS:
      Result = VGASetPaletteRegisters((PUSHORT) RequestPacket->InputBuffer,
                             RequestPacket->StatusBlock);
      break;
 
#if 0
    case  IOCTL_VIDEO_DISABLE_CURSOR:
    case  IOCTL_VIDEO_DISABLE_POINTER:
    case  IOCTL_VIDEO_ENABLE_CURSOR:
    case  IOCTL_VIDEO_ENABLE_POINTER:
 
    case  IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES:
      VGAFreePublicAccessRanges((PVIDEO_PUBLIC_ACCESS_RANGES)
                                  RequestPacket->InputBuffer,
                                RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_GET_BANK_SELECT_CODE:
    case  IOCTL_VIDEO_GET_POWER_MANAGEMENT:
    case  IOCTL_VIDEO_LOAD_AND_SET_FONT:
    case  IOCTL_VIDEO_QUERY_CURSOR_POSITION:
    case  IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES:
    case  IOCTL_VIDEO_QUERY_CURSOR_ATTR:
    case  IOCTL_VIDEO_QUERY_POINTER_ATTR:
    case  IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES:
    case  IOCTL_VIDEO_QUERY_POINTER_POSITION:
 
    case  IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES:
      VGAQueryPublicAccessRanges((PVIDEO_PUBLIC_ACCESS_RANGES)
                                   RequestPacket->OutputBuffer,
                                 RequestPacket->StatusBlock);
      break;
 
    case  IOCTL_VIDEO_RESTORE_HARDWARE_STATE:
    case  IOCTL_VIDEO_SAVE_HARDWARE_STATE:
    case  IOCTL_VIDEO_SET_CURSOR_ATTR:
    case  IOCTL_VIDEO_SET_CURSOR_POSITION:
    case  IOCTL_VIDEO_SET_POINTER_ATTR:
    case  IOCTL_VIDEO_SET_POINTER_POSITION:
    case  IOCTL_VIDEO_SET_POWER_MANAGEMENT:
 
#endif
 
    default:
      RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
      return FALSE;
    }
 
  if (Result)
    RequestPacket->StatusBlock->Status = NO_ERROR;
 
  return TRUE;
}

Referenced by DriverEntry().

VGAUnmapVideoMemory()

BOOLEAN VGAUnmapVideoMemory	(	IN PVOID	DeviceExtension,
		IN PVIDEO_MEMORY	MemoryToUnmap,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 623 of file vgamp.c.

{
  if (VideoPortUnmapMemory(DeviceExtension,
               MemoryToUnmap->RequestedVirtualAddress,
               0) == NO_ERROR)
    return TRUE;
  else
    return FALSE;
}

Referenced by VGAStartIO().

VGAUnshareVideoMemory()

BOOLEAN VGAUnshareVideoMemory	(	IN PVIDEO_MEMORY	MemoryToUnshare,
		OUT PSTATUS_BLOCK	StatusBlock
	)

Definition at line 635 of file vgamp.c.

{
  UNIMPLEMENTED;
 
  StatusBlock->Status = ERROR_INVALID_FUNCTION;
  return FALSE;
}

Referenced by VGAStartIO().

Variable Documentation

VGAAccessRange

VIDEO_ACCESS_RANGE VGAAccessRange[]

Initial value:

=
{
    { {{0x3b0}}, 0x3bb - 0x3b0 + 1, 1, 0, 0 },
    { {{0x3c0}}, 0x3df - 0x3c0 + 1, 1, 0, 0 },
    { {{0xa0000}}, 0x20000, 0, 0, 0 },
}

Definition at line 13 of file vgamp.c.

Referenced by DriverEntry(), and VGAFindAdapter().