videoprt.h File Reference

#include <ntifs.h>
#include <miniport.h>
#include <video.h>
#include <ntagp.h>
#include <dderror.h>
#include <windef.h>
#include <wdmguid.h>
#include <pseh/pseh2.h>

Include dependency graph for videoprt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_VIDEO_PORT_ADDRESS_MAPPING
struct	_VIDEO_PORT_AGP_MAPPING
struct	_VIDEO_PORT_AGP_VIRTUAL_MAPPING
struct	_VIDEO_PORT_DRIVER_EXTENSION
struct	_VIDEO_PORT_COMMON_EXTENSION
struct	_VIDEO_PORT_DEVICE_EXTENSTION
struct	_VIDEO_PORT_CHILD_EXTENSION
struct	_VIDEO_PORT_EVENT

Macros
#define	__BROKEN__
#define	TAG_VIDEO_PORT   'PDIV'
#define	TAG_VIDEO_PORT_BUFFER   '\0mpV'
#define	TAG_REQUEST_PACKET   'qRpV'
#define	GUID_STRING_LENGTH   (38 * sizeof(WCHAR))
#define	VIDEO_PORT_GET_CHILD_EXTENSION(MiniportExtension)
#define	VIDEO_PORT_GET_DEVICE_EXTENSION(MiniportExtension)

Typedefs
typedef struct _VIDEO_PORT_ADDRESS_MAPPING	VIDEO_PORT_ADDRESS_MAPPING
typedef struct _VIDEO_PORT_ADDRESS_MAPPING *	PVIDEO_PORT_ADDRESS_MAPPING
typedef struct _VIDEO_PORT_AGP_MAPPING	VIDEO_PORT_AGP_MAPPING
typedef struct _VIDEO_PORT_AGP_MAPPING *	PVIDEO_PORT_AGP_MAPPING
typedef struct _VIDEO_PORT_AGP_VIRTUAL_MAPPING	VIDEO_PORT_AGP_VIRTUAL_MAPPING
typedef struct _VIDEO_PORT_AGP_VIRTUAL_MAPPING *	PVIDEO_PORT_AGP_VIRTUAL_MAPPING
typedef struct _VIDEO_PORT_DRIVER_EXTENSION	VIDEO_PORT_DRIVER_EXTENSION
typedef struct _VIDEO_PORT_DRIVER_EXTENSION *	PVIDEO_PORT_DRIVER_EXTENSION
typedef struct _VIDEO_PORT_COMMON_EXTENSION	VIDEO_PORT_COMMON_EXTENSION
typedef struct _VIDEO_PORT_COMMON_EXTENSION *	PVIDEO_PORT_COMMON_EXTENSION
typedef struct _VIDEO_PORT_DEVICE_EXTENSTION	VIDEO_PORT_DEVICE_EXTENSION
typedef struct _VIDEO_PORT_DEVICE_EXTENSTION *	PVIDEO_PORT_DEVICE_EXTENSION
typedef struct _VIDEO_PORT_CHILD_EXTENSION	VIDEO_PORT_CHILD_EXTENSION
typedef struct _VIDEO_PORT_CHILD_EXTENSION *	PVIDEO_PORT_CHILD_EXTENSION
typedef struct _VIDEO_PORT_EVENT	VIDEO_PORT_EVENT
typedef struct _VIDEO_PORT_EVENT *	PVIDEO_PORT_EVENT

Functions
NTSTATUS	IopInitiatePnpIrp (PDEVICE_OBJECT DeviceObject, PIO_STATUS_BLOCK IoStatusBlock, UCHAR MinorFunction, PIO_STACK_LOCATION Stack OPTIONAL)
NTSTATUS NTAPI	IntAgpGetInterface (IN PVOID HwDeviceExtension, IN OUT PINTERFACE Interface)
NTSTATUS NTAPI	IntVideoPortDispatchPdoPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS NTAPI	IntVideoPortDispatchOpen (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchCleanup (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchPower (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntVideoPortDispatchSystemControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	IntVideoPortUnload (PDRIVER_OBJECT DriverObject)
BOOLEAN NTAPI	IntVideoPortSetupTimer (IN PDEVICE_OBJECT DeviceObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension)
BOOLEAN NTAPI	IntVideoPortSetupInterrupt (IN PDEVICE_OBJECT DeviceObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PVIDEO_PORT_CONFIG_INFO ConfigInfo)
NTSTATUS NTAPI	IntVideoPortFilterResourceRequirements (IN PDEVICE_OBJECT DeviceObject, IN PIO_STACK_LOCATION IrpStack, IN PIRP Irp)
VOID	IntVideoPortReleaseResources (_In_ PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	IntVideoPortMapPhysicalMemory (IN HANDLE Process, IN PHYSICAL_ADDRESS PhysicalAddress, IN ULONG SizeInBytes, IN ULONG Protect, IN OUT PVOID *VirtualAddress OPTIONAL)
VOID FASTCALL	IntAttachToCSRSS (PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
VOID FASTCALL	IntDetachFromCSRSS (PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
NTSTATUS NTAPI	IntVideoPortCreateAdapterDeviceObject (_In_ PDRIVER_OBJECT DriverObject, _In_ PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ USHORT AdapterNumber, _In_ USHORT DisplayNumber, _Out_opt_ PDEVICE_OBJECT *DeviceObject)
NTSTATUS NTAPI	IntVideoPortFindAdapter (IN PDRIVER_OBJECT DriverObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PDEVICE_OBJECT DeviceObject)
PVOID NTAPI	IntVideoPortGetProcAddress (IN PVOID HwDeviceExtension, IN PUCHAR FunctionName)
NTSTATUS NTAPI	IntVideoPortEnumerateChildren (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IntInitializeVideoAddressSpace (VOID)
VP_STATUS NTAPI	IntInt10AllocateBuffer (IN PVOID Context, OUT PUSHORT Seg, OUT PUSHORT Off, IN OUT PULONG Length)
VP_STATUS NTAPI	IntInt10FreeBuffer (IN PVOID Context, IN USHORT Seg, IN USHORT Off)
VP_STATUS NTAPI	IntInt10ReadMemory (IN PVOID Context, IN USHORT Seg, IN USHORT Off, OUT PVOID Buffer, IN ULONG Length)
VP_STATUS NTAPI	IntInt10WriteMemory (IN PVOID Context, IN USHORT Seg, IN USHORT Off, IN PVOID Buffer, IN ULONG Length)
VP_STATUS NTAPI	IntInt10CallBios (IN PVOID Context, IN OUT PINT10_BIOS_ARGUMENTS BiosArguments)
NTSTATUS NTAPI	IntCopyRegistryKey (_In_ HANDLE SourceKeyHandle, _In_ HANDLE DestKeyHandle)
NTSTATUS NTAPI	IntCopyRegistryValue (HANDLE SourceKeyHandle, HANDLE DestKeyHandle, PWSTR ValueName)
NTSTATUS NTAPI	IntSetupDeviceSettingsKey (PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	IntCreateNewRegistryPath (PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	IntCreateRegistryPath (IN PCUNICODE_STRING DriverRegistryPath, IN ULONG DeviceNumber, OUT PUNICODE_STRING DeviceRegistryPath)

Variables
PKPROCESS	CsrProcess
ULONG	VideoPortDeviceNumber
BOOLEAN	VideoPortUseNewKey
KMUTEX	VideoPortInt10Mutex
KSPIN_LOCK	HwResetAdaptersLock
LIST_ENTRY	HwResetAdaptersList

Macro Definition Documentation

__BROKEN__

#define __BROKEN__

Definition at line 27 of file videoprt.h.

GUID_STRING_LENGTH

#define GUID_STRING_LENGTH   (38 * sizeof(WCHAR))

Definition at line 42 of file videoprt.h.

TAG_REQUEST_PACKET

#define TAG_REQUEST_PACKET   'qRpV'

Definition at line 40 of file videoprt.h.

TAG_VIDEO_PORT

#define TAG_VIDEO_PORT   'PDIV'

Definition at line 38 of file videoprt.h.

TAG_VIDEO_PORT_BUFFER

#define TAG_VIDEO_PORT_BUFFER   '\0mpV'

Definition at line 39 of file videoprt.h.

VIDEO_PORT_GET_CHILD_EXTENSION

#define VIDEO_PORT_GET_CHILD_EXTENSION

(

MiniportExtension

)

Value:

   CONTAINING_RECORD( \
       MiniportExtension, \
       VIDEO_PORT_CHILD_EXTENSION, \
       ChildDeviceExtension)

Definition at line 134 of file videoprt.h.

VIDEO_PORT_GET_DEVICE_EXTENSION

#define VIDEO_PORT_GET_DEVICE_EXTENSION

(

MiniportExtension

)

Value:

   CONTAINING_RECORD( \
      MiniportExtension, \
      VIDEO_PORT_DEVICE_EXTENSION, \
      MiniPortDeviceExtension)

Definition at line 140 of file videoprt.h.

Typedef Documentation

PVIDEO_PORT_ADDRESS_MAPPING

typedef struct _VIDEO_PORT_ADDRESS_MAPPING * PVIDEO_PORT_ADDRESS_MAPPING

PVIDEO_PORT_AGP_MAPPING

typedef struct _VIDEO_PORT_AGP_MAPPING * PVIDEO_PORT_AGP_MAPPING

PVIDEO_PORT_AGP_VIRTUAL_MAPPING

typedef struct _VIDEO_PORT_AGP_VIRTUAL_MAPPING * PVIDEO_PORT_AGP_VIRTUAL_MAPPING

PVIDEO_PORT_CHILD_EXTENSION

typedef struct _VIDEO_PORT_CHILD_EXTENSION * PVIDEO_PORT_CHILD_EXTENSION

PVIDEO_PORT_COMMON_EXTENSION

typedef struct _VIDEO_PORT_COMMON_EXTENSION * PVIDEO_PORT_COMMON_EXTENSION

PVIDEO_PORT_DEVICE_EXTENSION

typedef struct _VIDEO_PORT_DEVICE_EXTENSTION * PVIDEO_PORT_DEVICE_EXTENSION

PVIDEO_PORT_DRIVER_EXTENSION

typedef struct _VIDEO_PORT_DRIVER_EXTENSION * PVIDEO_PORT_DRIVER_EXTENSION

PVIDEO_PORT_EVENT

typedef struct _VIDEO_PORT_EVENT * PVIDEO_PORT_EVENT

VIDEO_PORT_ADDRESS_MAPPING

typedef struct _VIDEO_PORT_ADDRESS_MAPPING VIDEO_PORT_ADDRESS_MAPPING

VIDEO_PORT_AGP_MAPPING

typedef struct _VIDEO_PORT_AGP_MAPPING VIDEO_PORT_AGP_MAPPING

VIDEO_PORT_AGP_VIRTUAL_MAPPING

typedef struct _VIDEO_PORT_AGP_VIRTUAL_MAPPING VIDEO_PORT_AGP_VIRTUAL_MAPPING

VIDEO_PORT_CHILD_EXTENSION

typedef struct _VIDEO_PORT_CHILD_EXTENSION VIDEO_PORT_CHILD_EXTENSION

VIDEO_PORT_COMMON_EXTENSION

typedef struct _VIDEO_PORT_COMMON_EXTENSION VIDEO_PORT_COMMON_EXTENSION

VIDEO_PORT_DEVICE_EXTENSION

typedef struct _VIDEO_PORT_DEVICE_EXTENSTION VIDEO_PORT_DEVICE_EXTENSION

VIDEO_PORT_DRIVER_EXTENSION

typedef struct _VIDEO_PORT_DRIVER_EXTENSION VIDEO_PORT_DRIVER_EXTENSION

VIDEO_PORT_EVENT

typedef struct _VIDEO_PORT_EVENT VIDEO_PORT_EVENT

Function Documentation

IntAgpGetInterface()

NTSTATUS NTAPI IntAgpGetInterface	(	IN PVOID	HwDeviceExtension,
		IN OUT PINTERFACE	Interface
	)

Definition at line 496 of file agp.c.

{
   IO_STATUS_BLOCK IoStatusBlock;
   IO_STACK_LOCATION IoStack;
   NTSTATUS Status;
   PVIDEO_PORT_AGP_INTERFACE_2 AgpInterface;
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
   PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
 
   DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
   AgpBusInterface = &DeviceExtension->AgpInterface;
   AgpInterface = (PVIDEO_PORT_AGP_INTERFACE_2)Interface;
 
   ASSERT(Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_2 ||
          Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1);
   if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_2)
   {
       ASSERT(Interface->Size >= sizeof(VIDEO_PORT_AGP_INTERFACE_2));
   }
   else if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1)
   {
       ASSERT(Interface->Size >= sizeof(VIDEO_PORT_AGP_INTERFACE));
   }
 
   if (DeviceExtension->NextDeviceObject == NULL)
   {
      WARN_(VIDEOPRT, "DeviceExtension->NextDeviceObject is NULL!\n");
      return STATUS_UNSUCCESSFUL;
   }
 
   /* Query the interface from the AGP bus driver */
   if (DeviceExtension->AgpInterface.Size == 0)
   {
      AgpBusInterface->Size = sizeof(AGP_BUS_INTERFACE_STANDARD);
      if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1)
         AgpBusInterface->Version = AGP_BUS_INTERFACE_V1;
      else /* if (InterfaceVersion == VIDEO_PORT_AGP_INTERFACE_VERSION_2) */
         AgpBusInterface->Version = AGP_BUS_INTERFACE_V2;
      IoStack.Parameters.QueryInterface.Size = AgpBusInterface->Size;
      IoStack.Parameters.QueryInterface.Version = AgpBusInterface->Version;
      IoStack.Parameters.QueryInterface.Interface = (PINTERFACE)AgpBusInterface;
      IoStack.Parameters.QueryInterface.InterfaceType =
         &GUID_AGP_TARGET_BUS_INTERFACE_STANDARD;
      Status = IopInitiatePnpIrp(DeviceExtension->NextDeviceObject,
         &IoStatusBlock, IRP_MN_QUERY_INTERFACE, &IoStack);
      if (!NT_SUCCESS(Status))
      {
         WARN_(VIDEOPRT, "IopInitiatePnpIrp() failed! (Status 0x%x)\n", Status);
         return Status;
      }
      INFO_(VIDEOPRT, "Got AGP driver interface!\n");
   }
 
   /* FIXME: Not sure if we should wrap the reference/dereference functions */
   AgpInterface->Context = AgpBusInterface->AgpContext;
   AgpInterface->InterfaceReference = AgpBusInterface->InterfaceReference;
   AgpInterface->InterfaceDereference = AgpBusInterface->InterfaceDereference;
   AgpInterface->AgpReservePhysical = IntAgpReservePhysical;
   AgpInterface->AgpReleasePhysical = IntAgpReleasePhysical;
   AgpInterface->AgpCommitPhysical = IntAgpCommitPhysical;
   AgpInterface->AgpFreePhysical = IntAgpFreePhysical;
   AgpInterface->AgpReserveVirtual = IntAgpReserveVirtual;
   AgpInterface->AgpReleaseVirtual = IntAgpReleaseVirtual;
   AgpInterface->AgpCommitVirtual = IntAgpCommitVirtual;
   AgpInterface->AgpFreeVirtual = IntAgpFreeVirtual;
   AgpInterface->AgpAllocationLimit = 0x1000000; /* FIXME: using 16 MB for now */
 
   if (AgpInterface->Version >= VIDEO_PORT_AGP_INTERFACE_VERSION_2)
   {
      AgpInterface->AgpSetRate = IntAgpSetRate;
   }
 
   return STATUS_SUCCESS;
}

Referenced by VideoPortQueryServices().

IntAttachToCSRSS()

VOID FASTCALL IntAttachToCSRSS	(	PKPROCESS *	CallingProcess,
		PKAPC_STATE	ApcState
	)

Definition at line 575 of file videoprt.c.

{
    *CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    if (*CallingProcess != CsrProcess)
    {
        KeStackAttachProcess(CsrProcess, ApcState);
    }
}

Referenced by IntInt10AllocateBuffer(), IntInt10CallBios(), IntInt10FreeBuffer(), IntInt10ReadMemory(), IntInt10WriteMemory(), and VideoPortGetRomImage().

IntCopyRegistryKey()

NTSTATUS NTAPI IntCopyRegistryKey	(	_In_ HANDLE	SourceKeyHandle,
		_In_ HANDLE	DestKeyHandle
	)

Definition at line 31 of file registry.c.

{
    PVOID InfoBuffer;
    PKEY_BASIC_INFORMATION KeyInformation;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
    OBJECT_ATTRIBUTES ObjectAttributes;
    ULONG Index, InformationLength, RequiredLength;
    UNICODE_STRING NameString;
    NTSTATUS Status;
    HANDLE SourceSubKeyHandle, DestSubKeyHandle;
 
    /* Start with no buffer, set initial size */
    InfoBuffer = NULL;
    InformationLength = 256;
 
    /* Start looping with key index 0 */
    Index = 0;
    while (TRUE)
    {
        /* Check if we have no buffer */
        if (InfoBuffer == NULL)
        {
            /* Allocate a new buffer */
            InfoBuffer = ExAllocatePoolWithTag(PagedPool,
                                               InformationLength,
                                               TAG_VIDEO_PORT_BUFFER);
            if (InfoBuffer == NULL)
            {
                ERR_(VIDEOPRT, "Could not allocate buffer for key info\n");
                return STATUS_INSUFFICIENT_RESOURCES;
            }
        }
 
        /* Enumerate the next sub-key */
        KeyInformation = InfoBuffer;
        Status = ZwEnumerateKey(SourceKeyHandle,
                                Index,
                                KeyBasicInformation,
                                KeyInformation,
                                InformationLength,
                                &RequiredLength);
        if ((Status == STATUS_BUFFER_OVERFLOW) ||
            (Status == STATUS_BUFFER_TOO_SMALL))
        {
            /* Free the buffer and remember the required size */
            ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
            InfoBuffer = NULL;
            InformationLength = RequiredLength;
 
            /* Try again */
            continue;
        }
        else if (Status == STATUS_NO_MORE_ENTRIES)
        {
            /* We are done with the sub-keys */
            break;
        }
        else if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "ZwEnumerateKey failed, status 0x%lx\n", Status);
            goto Cleanup;
        }
 
        /* Initialize a unicode string from the key name */
        NameString.Buffer = KeyInformation->Name;
        NameString.Length = (USHORT)KeyInformation->NameLength;
        NameString.MaximumLength = NameString.Length;
 
        /* Initialize object attributes and open the source sub-key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &NameString,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   SourceKeyHandle,
                                   NULL);
        Status = ZwOpenKey(&SourceSubKeyHandle, KEY_READ, &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "failed to open the source key.\n");
            goto Cleanup;
        }
 
        /* Initialize object attributes and create the dest sub-key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &NameString,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   DestKeyHandle,
                                   NULL);
        Status = ZwCreateKey(&DestSubKeyHandle,
                             KEY_WRITE,
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             NULL);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "failed to create the destination key.\n");
            ObCloseHandle(SourceSubKeyHandle, KernelMode);
            goto Cleanup;
        }
 
        /* Recursively copy the sub-key */
        Status = IntCopyRegistryKey(SourceSubKeyHandle, DestSubKeyHandle);
        if (!NT_SUCCESS(Status))
        {
            /* Just warn, but continue with the remaining sub-keys */
            WARN_(VIDEOPRT, "failed to copy subkey '%wZ'.\n", &NameString);
        }
 
        /* Close the sub-key handles */
        ObCloseHandle(SourceSubKeyHandle, KernelMode);
        ObCloseHandle(DestSubKeyHandle, KernelMode);
 
        /* Next sub-key */
        Index++;
    }
 
    /* Start looping with value index 0 */
    Index = 0;
    while (TRUE)
    {
        /* Check if we have no buffer */
        if (InfoBuffer == NULL)
        {
            /* Allocate a new buffer */
            InfoBuffer = ExAllocatePoolWithTag(PagedPool,
                                               InformationLength,
                                               TAG_VIDEO_PORT_BUFFER);
            if (InfoBuffer == NULL)
            {
                ERR_(VIDEOPRT, "Could not allocate buffer for key values\n");
                return Status;
            }
        }
 
        /* Enumerate the next value */
        KeyValueInformation = InfoBuffer;
        Status = ZwEnumerateValueKey(SourceKeyHandle,
                                     Index,
                                     KeyValueFullInformation,
                                     KeyValueInformation,
                                     InformationLength,
                                     &RequiredLength);
        if ((Status == STATUS_BUFFER_OVERFLOW) ||
            (Status == STATUS_BUFFER_TOO_SMALL))
        {
            /* Free the buffer and remember the required size */
            ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
            InfoBuffer = NULL;
            InformationLength = RequiredLength;
 
            /* Try again */
            continue;
        }
        else if (Status == STATUS_NO_MORE_ENTRIES)
        {
            /* We are done with the values */
            Status = STATUS_SUCCESS;
            break;
        }
        else if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "ZwEnumerateValueKey failed, status 0x%lx\n", Status);
            goto Cleanup;
        }
 
        /* Initialize a unicode string from the value name */
        NameString.Buffer = KeyValueInformation->Name;
        NameString.Length = (USHORT)KeyValueInformation->NameLength;
        NameString.MaximumLength = NameString.Length;
 
        /* Create the key value in the destination key */
        Status = ZwSetValueKey(DestKeyHandle,
                               &NameString,
                               KeyValueInformation->TitleIndex,
                               KeyValueInformation->Type,
                               (PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset,
                               KeyValueInformation->DataLength);
        if (!NT_SUCCESS(Status))
        {
            /* Just warn, but continue with the remaining sub-keys */
            WARN_(VIDEOPRT, "failed to set value '%wZ'.\n", &NameString);
        }
 
        /* Next subkey */
        Index++;
    }
 
Cleanup:
    /* Free the buffer and return the failure code */
    if (InfoBuffer != NULL)
        ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
    return Status;
}

Referenced by IntCopyRegistryKey(), and IntCreateNewRegistryPath().

IntCopyRegistryValue()

NTSTATUS NTAPI IntCopyRegistryValue	(	HANDLE	SourceKeyHandle,
		HANDLE	DestKeyHandle,
		PWSTR	ValueName
	)

Definition at line 230 of file registry.c.

{
    PKEY_VALUE_PARTIAL_INFORMATION ValueInformation;
    UNICODE_STRING ValueNameString;
    ULONG Length;
    NTSTATUS Status;
 
    RtlInitUnicodeString(&ValueNameString, ValueName);
 
    /* Query the value length */
    Status = ZwQueryValueKey(SourceKeyHandle,
                             &ValueNameString,
                             KeyValuePartialInformation,
                             NULL,
                             0,
                             &Length);
    if ((Status != STATUS_BUFFER_OVERFLOW) &&
        (Status != STATUS_BUFFER_TOO_SMALL))
    {
        /* The key seems not present */
        NT_ASSERT(!NT_SUCCESS(Status));
        return Status;
    }
 
    /* Allocate a buffer */
    ValueInformation = ExAllocatePoolWithTag(PagedPool, Length, TAG_VIDEO_PORT_BUFFER);
    if (ValueInformation == NULL)
    {
        return Status;
    }
 
    /* Query the value */
    Status = ZwQueryValueKey(SourceKeyHandle,
                             &ValueNameString,
                             KeyValuePartialInformation,
                             ValueInformation,
                             Length,
                             &Length);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(ValueInformation, TAG_VIDEO_PORT_BUFFER);
        return Status;
    }
 
    /* Write the registry value */
    Status = ZwSetValueKey(DestKeyHandle,
                           &ValueNameString,
                           ValueInformation->TitleIndex,
                           ValueInformation->Type,
                           ValueInformation->Data,
                           ValueInformation->DataLength);
 
    ExFreePoolWithTag(ValueInformation, TAG_VIDEO_PORT_BUFFER);
 
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "ZwSetValueKey failed: status 0x%lx\n", Status);
    }
 
    return Status;
}

Referenced by IntSetupDeviceSettingsKey().

IntCreateNewRegistryPath()

NTSTATUS NTAPI IntCreateNewRegistryPath

(

PVIDEO_PORT_DEVICE_EXTENSION

DeviceExtension

)

Todo:

HACK

Definition at line 407 of file registry.c.

{
    static UNICODE_STRING VideoIdValueName = RTL_CONSTANT_STRING(L"VideoId");
    static UNICODE_STRING ControlVideoPathName =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Video\\");
    HANDLE DevInstRegKey, SettingsKey, NewKey;
    UCHAR VideoIdBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + GUID_STRING_LENGTH];
    UNICODE_STRING VideoIdString;
    UUID VideoId;
    PKEY_VALUE_PARTIAL_INFORMATION ValueInformation ;
    NTSTATUS Status;
    ULONG ResultLength;
    USHORT KeyMaxLength;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PWCHAR InstanceIdBuffer;
 
    if (!DeviceExtension->PhysicalDeviceObject)
    {
        Status = IntDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
                                           &DeviceExtension->RegistryPath,
                                           &DeviceExtension->NewRegistryPath);
        if (!NT_SUCCESS(Status))
            ERR_(VIDEOPRT, "IntDuplicateUnicodeString() failed with status 0x%lx\n", Status);
        return Status;
    }
 
    /* Open the hardware key: HKLM\System\CurrentControlSet\Enum\... */
    Status = IoOpenDeviceRegistryKey(DeviceExtension->PhysicalDeviceObject,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_ALL_ACCESS,
                                     &DevInstRegKey);
    if (Status != STATUS_SUCCESS)
    {
        ERR_(VIDEOPRT, "IoOpenDeviceRegistryKey failed: status 0x%lx\n", Status);
        return Status;
    }
 
    /* Query the VideoId value */
    ValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION)VideoIdBuffer;
    Status = ZwQueryValueKey(DevInstRegKey,
                             &VideoIdValueName,
                             KeyValuePartialInformation,
                             ValueInformation,
                             sizeof(VideoIdBuffer),
                             &ResultLength);
    if (!NT_SUCCESS(Status))
    {
        /* Create a new video Id */
        Status = ExUuidCreate(&VideoId);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "ExUuidCreate failed: status 0x%lx\n", Status);
            ObCloseHandle(DevInstRegKey, KernelMode);
            return Status;
        }
 
        /* Convert the GUID into a string */
        Status = RtlStringFromGUID(&VideoId, &VideoIdString);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "RtlStringFromGUID failed: status 0x%lx\n", Status);
            ObCloseHandle(DevInstRegKey, KernelMode);
            return Status;
        }
 
        /* Copy the GUID String to our buffer */
        ValueInformation->DataLength = min(VideoIdString.Length, GUID_STRING_LENGTH);
        RtlCopyMemory(ValueInformation->Data,
                      VideoIdString.Buffer,
                      ValueInformation->DataLength);
 
        /* Free the GUID string */
        RtlFreeUnicodeString(&VideoIdString);
 
        /* Write the VideoId registry value */
        Status = ZwSetValueKey(DevInstRegKey,
                               &VideoIdValueName,
                               0,
                               REG_SZ,
                               ValueInformation->Data,
                               ValueInformation->DataLength);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "ZwSetValueKey failed: status 0x%lx\n", Status);
            ObCloseHandle(DevInstRegKey, KernelMode);
            return Status;
        }
    }
 
    /* Initialize the VideoId string from the registry data */
    VideoIdString.Buffer = (PWCHAR)ValueInformation->Data;
    VideoIdString.Length = (USHORT)ValueInformation->DataLength;
    VideoIdString.MaximumLength = VideoIdString.Length;
 
    /* Close the hardware key */
    ObCloseHandle(DevInstRegKey, KernelMode);
 
    /* Calculate the size needed for the new registry path name */
    KeyMaxLength = ControlVideoPathName.Length +
                   VideoIdString.Length +
                   sizeof(L"\\0000");
 
    /* Allocate the path name buffer */
    DeviceExtension->NewRegistryPath.Length = 0;
    DeviceExtension->NewRegistryPath.MaximumLength = KeyMaxLength;
    DeviceExtension->NewRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                                    KeyMaxLength,
                                                                    TAG_VIDEO_PORT);
    if (DeviceExtension->NewRegistryPath.Buffer == NULL)
    {
        ERR_(VIDEOPRT, "Failed to allocate key name buffer.\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Copy the root key name and append the VideoId string */
    RtlCopyUnicodeString(&DeviceExtension->NewRegistryPath,
                         &ControlVideoPathName);
    RtlAppendUnicodeStringToString(&DeviceExtension->NewRegistryPath,
                                   &VideoIdString);
 
    /* Check if we have the key already */
    Status = RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE,
                                 DeviceExtension->NewRegistryPath.Buffer);
    if (Status != STATUS_SUCCESS)
    {
        /* Try to create the new key */
        Status = RtlCreateRegistryKey(RTL_REGISTRY_ABSOLUTE,
                                      DeviceExtension->NewRegistryPath.Buffer);
    }
 
    /* Append a the instance path */ 
    RtlAppendUnicodeToString(&DeviceExtension->NewRegistryPath, L"\\");
    InstanceIdBuffer = DeviceExtension->NewRegistryPath.Buffer +
        DeviceExtension->NewRegistryPath.Length / sizeof(WCHAR);
    RtlAppendUnicodeToString(&DeviceExtension->NewRegistryPath, L"0000");
 
    /* Write instance ID */
    swprintf(InstanceIdBuffer, L"%04u", DeviceExtension->DisplayNumber);
 
    /* Check if the name exists */
    Status = RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE,
                                 DeviceExtension->NewRegistryPath.Buffer);
    if (Status != STATUS_SUCCESS)
    {
        /* Try to create the new key */
        Status = RtlCreateRegistryKey(RTL_REGISTRY_ABSOLUTE,
                                      DeviceExtension->NewRegistryPath.Buffer);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "Failed create key '%wZ'\n", &DeviceExtension->NewRegistryPath);
            return Status;
        }
 
        /* Open the new key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &DeviceExtension->NewRegistryPath,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = ZwOpenKey(&NewKey, KEY_WRITE, &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
            return Status;
        }
 
        /* Open the device profile key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &DeviceExtension->RegistryPath,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = ZwOpenKey(&SettingsKey, KEY_READ, &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
            ObCloseHandle(NewKey, KernelMode);
            return Status;
        }
 
        /* Copy the registry data from the legacy key */
        Status = IntCopyRegistryKey(SettingsKey, NewKey);
 
        /* Close the key handles */
        ObCloseHandle(SettingsKey, KernelMode);
        ObCloseHandle(NewKey, KernelMode);
    }
 
    return Status;
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

IntCreateRegistryPath()

NTSTATUS NTAPI IntCreateRegistryPath	(	IN PCUNICODE_STRING	DriverRegistryPath,
		IN ULONG	DeviceNumber,
		OUT PUNICODE_STRING	DeviceRegistryPath
	)

Definition at line 601 of file registry.c.

{
    static WCHAR RegistryMachineSystem[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\";
    static WCHAR CurrentControlSet[] = L"CURRENTCONTROLSET\\";
    static WCHAR ControlSet[] = L"CONTROLSET";
    static WCHAR Insert1[] = L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
    static WCHAR Insert2[] = L"\\Device";
    UNICODE_STRING DeviceNumberString;
    WCHAR DeviceNumberBuffer[20];
    BOOLEAN Valid;
    UNICODE_STRING AfterControlSet;
    NTSTATUS Status;
 
    AfterControlSet = *DriverRegistryPath;
 
    /* Convert DeviceNumber to string */
    DeviceNumberString.Length = 0;
    DeviceNumberString.MaximumLength = sizeof(DeviceNumberBuffer);
    DeviceNumberString.Buffer = DeviceNumberBuffer;
    Status = RtlIntegerToUnicodeString(DeviceNumber, 10, &DeviceNumberString);
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "RtlIntegerToUnicodeString(%u) returned 0x%08x\n", DeviceNumber, Status);
        return Status;
    }
 
    /* Check if path begins with \\REGISTRY\\MACHINE\\SYSTEM\\ */
    Valid = (DriverRegistryPath->Length > sizeof(RegistryMachineSystem) &&
             0 == _wcsnicmp(DriverRegistryPath->Buffer, RegistryMachineSystem,
                            wcslen(RegistryMachineSystem)));
    if (Valid)
    {
        AfterControlSet.Buffer += wcslen(RegistryMachineSystem);
        AfterControlSet.Length -= sizeof(RegistryMachineSystem) - sizeof(UNICODE_NULL);
 
        /* Check if path contains CURRENTCONTROLSET */
        if (AfterControlSet.Length > sizeof(CurrentControlSet) &&
            0 == _wcsnicmp(AfterControlSet.Buffer, CurrentControlSet, wcslen(CurrentControlSet)))
        {
            AfterControlSet.Buffer += wcslen(CurrentControlSet);
            AfterControlSet.Length -= sizeof(CurrentControlSet) - sizeof(UNICODE_NULL);
        }
        /* Check if path contains CONTROLSETnum */
        else if (AfterControlSet.Length > sizeof(ControlSet) &&
                 0 == _wcsnicmp(AfterControlSet.Buffer, ControlSet, wcslen(ControlSet)))
        {
            AfterControlSet.Buffer += wcslen(ControlSet);
            AfterControlSet.Length -= sizeof(ControlSet) - sizeof(UNICODE_NULL);
            while (AfterControlSet.Length > 0 &&
                    *AfterControlSet.Buffer >= L'0' &&
                    *AfterControlSet.Buffer <= L'9')
            {
                AfterControlSet.Buffer++;
                AfterControlSet.Length -= sizeof(WCHAR);
            }
 
            Valid = (AfterControlSet.Length > 0 && L'\\' == *AfterControlSet.Buffer);
            AfterControlSet.Buffer++;
            AfterControlSet.Length -= sizeof(WCHAR);
            AfterControlSet.MaximumLength = AfterControlSet.Length;
        }
        else
        {
            Valid = FALSE;
        }
    }
 
    if (!VideoPortUseNewKey)
    {
        INFO_(VIDEOPRT, "Using old registry key as 'UseNewKey' is FALSE\n");
        Valid = FALSE;
    }
    else if (Valid)
    {
        DeviceRegistryPath->MaximumLength = DriverRegistryPath->Length + sizeof(Insert1) + sizeof(Insert2)
                                          + DeviceNumberString.Length;
        DeviceRegistryPath->Buffer = ExAllocatePoolWithTag(PagedPool,
                                                           DeviceRegistryPath->MaximumLength,
                                                           TAG_VIDEO_PORT);
        if (DeviceRegistryPath->Buffer != NULL)
        {
            /* Build device path */
            wcsncpy(DeviceRegistryPath->Buffer,
                    DriverRegistryPath->Buffer,
                    AfterControlSet.Buffer - DriverRegistryPath->Buffer);
            DeviceRegistryPath->Length = (AfterControlSet.Buffer - DriverRegistryPath->Buffer) * sizeof(WCHAR);
            RtlAppendUnicodeToString(DeviceRegistryPath, Insert1);
            RtlAppendUnicodeStringToString(DeviceRegistryPath, &AfterControlSet);
            RtlAppendUnicodeToString(DeviceRegistryPath, Insert2);
            RtlAppendUnicodeStringToString(DeviceRegistryPath, &DeviceNumberString);
 
            /* Check if registry key exists */
            Valid = NT_SUCCESS(RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE, DeviceRegistryPath->Buffer));
 
            if (!Valid)
                ExFreePoolWithTag(DeviceRegistryPath->Buffer, TAG_VIDEO_PORT);
        }
        else
        {
            Valid = FALSE;
        }
    }
    else
    {
        WARN_(VIDEOPRT, "Unparsable registry path %wZ\n", DriverRegistryPath);
    }
 
    /* If path doesn't point to *ControlSet*, use DriverRegistryPath directly */
    if (!Valid)
    {
        DeviceRegistryPath->MaximumLength = DriverRegistryPath->Length + sizeof(Insert2) + DeviceNumberString.Length;
        DeviceRegistryPath->Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                                           DeviceRegistryPath->MaximumLength,
                                                           TAG_VIDEO_PORT);
 
        if (!DeviceRegistryPath->Buffer)
            return STATUS_NO_MEMORY;
 
        RtlCopyUnicodeString(DeviceRegistryPath, DriverRegistryPath);
        RtlAppendUnicodeToString(DeviceRegistryPath, Insert2);
        RtlAppendUnicodeStringToString(DeviceRegistryPath, &DeviceNumberString);
    }
 
    DPRINT("Formatted registry key '%wZ' -> '%wZ'\n",
           DriverRegistryPath, DeviceRegistryPath);
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

IntDetachFromCSRSS()

VOID FASTCALL IntDetachFromCSRSS	(	PKPROCESS *	CallingProcess,
		PKAPC_STATE	ApcState
	)

Definition at line 588 of file videoprt.c.

{
    if (*CallingProcess != CsrProcess)
    {
        KeUnstackDetachProcess(ApcState);
    }
}

Referenced by IntInt10AllocateBuffer(), IntInt10CallBios(), IntInt10FreeBuffer(), IntInt10ReadMemory(), IntInt10WriteMemory(), and VideoPortGetRomImage().

IntInitializeVideoAddressSpace()

NTSTATUS NTAPI IntInitializeVideoAddressSpace

(

VOID

)

Definition at line 200 of file int10.c.

{
    UNIMPLEMENTED;
    NT_ASSERT(FALSE);
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by IntVideoPortDispatchOpen().

IntInt10AllocateBuffer()

VP_STATUS NTAPI IntInt10AllocateBuffer	(	IN PVOID	Context,
		OUT PUSHORT	Seg,
		OUT PUSHORT	Off,
		IN OUT PULONG	Length
	)

Definition at line 210 of file int10.c.

{
    NTSTATUS Status;
#ifdef _M_IX86
    PVOID MemoryAddress;
    PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    KAPC_STATE ApcState;
    SIZE_T Size;
 
    TRACE_(VIDEOPRT, "IntInt10AllocateBuffer\n");
 
    IntAttachToCSRSS(&CallingProcess, &ApcState);
 
    Size = *Length;
    MemoryAddress = (PVOID)0x20000;
 
    Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
                                     &MemoryAddress,
                                     0,
                                     &Size,
                                     MEM_COMMIT,
                                     PAGE_EXECUTE_READWRITE);
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "- ZwAllocateVirtualMemory failed\n");
        IntDetachFromCSRSS(&CallingProcess, &ApcState);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    if (MemoryAddress > (PVOID)(0x100000 - Size))
    {
        ZwFreeVirtualMemory(NtCurrentProcess(),
                            &MemoryAddress,
                            &Size,
                            MEM_RELEASE);
        WARN_(VIDEOPRT, "- Unacceptable memory allocated\n");
        IntDetachFromCSRSS(&CallingProcess, &ApcState);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    *Length = (ULONG)Size;
    *Seg = (USHORT)((ULONG_PTR)MemoryAddress >> 4);
    *Off = (USHORT)((ULONG_PTR)MemoryAddress & 0xF);
 
    INFO_(VIDEOPRT, "- Segment: %x\n", (ULONG_PTR)MemoryAddress >> 4);
    INFO_(VIDEOPRT, "- Offset: %x\n", (ULONG_PTR)MemoryAddress & 0xF);
    INFO_(VIDEOPRT, "- Length: %x\n", *Length);
 
    IntDetachFromCSRSS(&CallingProcess, &ApcState);
 
    return NO_ERROR;
#else
    Status = x86BiosAllocateBuffer(Length, Seg, Off);
    return NT_SUCCESS(Status) ? NO_ERROR : ERROR_NOT_ENOUGH_MEMORY;
#endif
}

Referenced by VideoPortQueryServices().

IntInt10CallBios()

VP_STATUS NTAPI IntInt10CallBios	(	IN PVOID	Context,
		IN OUT PINT10_BIOS_ARGUMENTS	BiosArguments
	)

Definition at line 380 of file int10.c.

{
#ifdef _M_AMD64
    X86_BIOS_REGISTERS BiosContext;
#else
    CONTEXT BiosContext;
#endif
    NTSTATUS Status;
    PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    KAPC_STATE ApcState;
 
    /* Attach to CSRSS */
    IntAttachToCSRSS(&CallingProcess, &ApcState);
 
    /* Clear the context */
    RtlZeroMemory(&BiosContext, sizeof(BiosContext));
 
    /* Fill out the bios arguments */
    BiosContext.Eax = BiosArguments->Eax;
    BiosContext.Ebx = BiosArguments->Ebx;
    BiosContext.Ecx = BiosArguments->Ecx;
    BiosContext.Edx = BiosArguments->Edx;
    BiosContext.Esi = BiosArguments->Esi;
    BiosContext.Edi = BiosArguments->Edi;
    BiosContext.Ebp = BiosArguments->Ebp;
    BiosContext.SegDs = BiosArguments->SegDs;
    BiosContext.SegEs = BiosArguments->SegEs;
 
    /* Do the ROM BIOS call */
    (void)KeWaitForMutexObject(&VideoPortInt10Mutex,
                               Executive,
                               KernelMode,
                               FALSE,
                               NULL);
 
    /* The kernel needs access here */
    UnprotectLowV86Mem();
#ifdef _M_AMD64
    Status = x86BiosCall(0x10, &BiosContext) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
#else
    Status = Ke386CallBios(0x10, &BiosContext);
#endif
    ProtectLowV86Mem();
 
    KeReleaseMutex(&VideoPortInt10Mutex, FALSE);
 
    /* Return the arguments */
    BiosArguments->Eax = BiosContext.Eax;
    BiosArguments->Ebx = BiosContext.Ebx;
    BiosArguments->Ecx = BiosContext.Ecx;
    BiosArguments->Edx = BiosContext.Edx;
    BiosArguments->Esi = BiosContext.Esi;
    BiosArguments->Edi = BiosContext.Edi;
    BiosArguments->Ebp = BiosContext.Ebp;
    BiosArguments->SegDs = (USHORT)BiosContext.SegDs;
    BiosArguments->SegEs = (USHORT)BiosContext.SegEs;
 
    /* Detach and return status */
    IntDetachFromCSRSS(&CallingProcess, &ApcState);
 
    if (NT_SUCCESS(Status))
    {
        return NO_ERROR;
    }
 
    return ERROR_INVALID_PARAMETER;
}

Referenced by VideoPortInt10(), and VideoPortQueryServices().

IntInt10FreeBuffer()

VP_STATUS NTAPI IntInt10FreeBuffer	(	IN PVOID	Context,
		IN USHORT	Seg,
		IN USHORT	Off
	)

Definition at line 273 of file int10.c.

{
    NTSTATUS Status;
#ifdef _M_IX86
    PVOID MemoryAddress = (PVOID)((ULONG_PTR)(Seg << 4) | Off);
    PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    KAPC_STATE ApcState;
    SIZE_T Size = 0;
 
    TRACE_(VIDEOPRT, "IntInt10FreeBuffer\n");
    INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
    INFO_(VIDEOPRT, "- Offset: %x\n", Off);
 
    IntAttachToCSRSS(&CallingProcess, &ApcState);
    Status = ZwFreeVirtualMemory(NtCurrentProcess(),
                                 &MemoryAddress,
                                 &Size,
                                 MEM_RELEASE);
 
    IntDetachFromCSRSS(&CallingProcess, &ApcState);
 
    return Status;
#else
    Status = x86BiosFreeBuffer(Seg, Off);
    return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
#endif
}

Referenced by VideoPortQueryServices().

IntInt10ReadMemory()

VP_STATUS NTAPI IntInt10ReadMemory	(	IN PVOID	Context,
		IN USHORT	Seg,
		IN USHORT	Off,
		OUT PVOID	Buffer,
		IN ULONG	Length
	)

Definition at line 306 of file int10.c.

{
#ifdef _M_IX86
    PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    KAPC_STATE ApcState;
 
    TRACE_(VIDEOPRT, "IntInt10ReadMemory\n");
    INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
    INFO_(VIDEOPRT, "- Offset: %x\n", Off);
    INFO_(VIDEOPRT, "- Buffer: %x\n", Buffer);
    INFO_(VIDEOPRT, "- Length: %x\n", Length);
 
    IntAttachToCSRSS(&CallingProcess, &ApcState);
 
    if (IsLowV86Mem(Seg, Off))
        UnprotectLowV86Mem();
    RtlCopyMemory(Buffer, (PVOID)((ULONG_PTR)(Seg << 4) | Off), Length);
    if (IsLowV86Mem(Seg, Off))
        ProtectLowV86Mem();
 
    IntDetachFromCSRSS(&CallingProcess, &ApcState);
 
    return NO_ERROR;
#else
    NTSTATUS Status;
 
    Status = x86BiosReadMemory(Seg, Off, Buffer, Length);
    return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
#endif
}

Referenced by VideoPortQueryServices().

IntInt10WriteMemory()

VP_STATUS NTAPI IntInt10WriteMemory	(	IN PVOID	Context,
		IN USHORT	Seg,
		IN USHORT	Off,
		IN PVOID	Buffer,
		IN ULONG	Length
	)

Definition at line 344 of file int10.c.

{
#ifdef _M_IX86
    PKPROCESS CallingProcess = (PKPROCESS)PsGetCurrentProcess();
    KAPC_STATE ApcState;
 
    TRACE_(VIDEOPRT, "IntInt10WriteMemory\n");
    INFO_(VIDEOPRT, "- Segment: %x\n", Seg);
    INFO_(VIDEOPRT, "- Offset: %x\n", Off);
    INFO_(VIDEOPRT, "- Buffer: %x\n", Buffer);
    INFO_(VIDEOPRT, "- Length: %x\n", Length);
 
    IntAttachToCSRSS(&CallingProcess, &ApcState);
    if (IsLowV86Mem(Seg, Off))
        UnprotectLowV86Mem();
    RtlCopyMemory((PVOID)((ULONG_PTR)(Seg << 4) | Off), Buffer, Length);
    if (IsLowV86Mem(Seg, Off))
        ProtectLowV86Mem();
    IntDetachFromCSRSS(&CallingProcess, &ApcState);
 
    return NO_ERROR;
#else
    NTSTATUS Status;
 
    Status = x86BiosWriteMemory(Seg, Off, Buffer, Length);
    return NT_SUCCESS(Status) ? NO_ERROR : ERROR_INVALID_PARAMETER;
#endif
}

Referenced by VideoPortQueryServices().

IntSetupDeviceSettingsKey()

NTSTATUS NTAPI IntSetupDeviceSettingsKey

(

PVIDEO_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 297 of file registry.c.

{
    static UNICODE_STRING SettingsKeyName = RTL_CONSTANT_STRING(L"Settings");
    HANDLE DevInstRegKey, SourceKeyHandle, DestKeyHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
 
    if (!DeviceExtension->PhysicalDeviceObject)
        return STATUS_SUCCESS;
 
    /* Open the software key: HKLM\System\CurrentControlSet\Control\Class<ClassGUID><n> */
    Status = IoOpenDeviceRegistryKey(DeviceExtension->PhysicalDeviceObject,
                                     PLUGPLAY_REGKEY_DRIVER,
                                     KEY_ALL_ACCESS,
                                     &DevInstRegKey);
    if (Status != STATUS_SUCCESS)
    {
        ERR_(VIDEOPRT, "Failed to open device software key. Status 0x%lx\n", Status);
        return Status;
    }
 
    /* Open the 'Settings' sub-key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &SettingsKeyName,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               DevInstRegKey,
                               NULL);
    Status = ZwOpenKey(&DestKeyHandle, KEY_WRITE, &ObjectAttributes);
 
    /* Close the device software key */
    ObCloseHandle(DevInstRegKey, KernelMode);
 
    if (Status != STATUS_SUCCESS)
    {
        ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
        return Status;
    }
 
    /* Open the device profile key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &DeviceExtension->RegistryPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&SourceKeyHandle, KEY_READ, &ObjectAttributes);
    if (Status != STATUS_SUCCESS)
    {
        ERR_(VIDEOPRT, "ZwOpenKey failed for settings key: status 0x%lx\n", Status);
        ObCloseHandle(DestKeyHandle, KernelMode);
        return Status;
    }
 
    IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"InstalledDisplayDrivers");
    IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"Attach.ToDesktop");
 
    ObCloseHandle(SourceKeyHandle, KernelMode);
    ObCloseHandle(DestKeyHandle, KernelMode);
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

IntVideoPortAddDevice()

NTSTATUS NTAPI IntVideoPortAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	PhysicalDeviceObject
	)

Definition at line 334 of file dispatch.c.

{
    PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
    PDEVICE_OBJECT DeviceObject;
    NTSTATUS Status;
 
    /* Get the initialization data we saved in VideoPortInitialize. */
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 
    /* Create adapter device object. */
    Status = IntVideoPortCreateAdapterDeviceObject(DriverObject,
                                                   DriverExtension,
                                                   PhysicalDeviceObject,
                                                   DriverExtension->InitializationData.StartingDeviceNumber,
                                                   0,
                                                   &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "IntVideoPortCreateAdapterDeviceObject() failed with status 0x%lx\n", Status);
    }
    return Status;
}

Referenced by VideoPortInitialize().

IntVideoPortCreateAdapterDeviceObject()

NTSTATUS NTAPI IntVideoPortCreateAdapterDeviceObject	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PVIDEO_PORT_DRIVER_EXTENSION	DriverExtension,
		_In_opt_ PDEVICE_OBJECT	PhysicalDeviceObject,
		_In_ USHORT	AdapterNumber,
		_In_ USHORT	DisplayNumber,
		_Out_opt_ PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 159 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    ULONG DeviceNumber;
    ULONG PciSlotNumber;
    PCI_SLOT_NUMBER SlotNumber;
    ULONG Size;
    NTSTATUS Status;
    WCHAR DeviceBuffer[20];
    UNICODE_STRING DeviceName;
    PDEVICE_OBJECT DeviceObject_;
 
    if (DeviceObject == NULL)
        DeviceObject = &DeviceObject_;
 
    /*
     * Find the first free device number that can be used for video device
     * object names and symlinks.
     */
    DeviceNumber = VideoPortMaxObjectNumber + 1;
    if (DeviceNumber == (ULONG)-1)
    {
        WARN_(VIDEOPRT, "Can't find free device number\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    /*
     * Create the device object.
     */
 
    /* Create a unicode device name. */
    swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
    RtlInitUnicodeString(&DeviceName, DeviceBuffer);
 
    INFO_(VIDEOPRT, "HwDeviceExtension size is: 0x%x\n",
          DriverExtension->InitializationData.HwDeviceExtensionSize);
 
    /* Create the device object. */
    Size = sizeof(VIDEO_PORT_DEVICE_EXTENSION) +
        DriverExtension->InitializationData.HwDeviceExtensionSize;
    Status = IoCreateDevice(DriverObject,
                            Size,
                            &DeviceName,
                            FILE_DEVICE_VIDEO,
                            0,
                            TRUE,
                            DeviceObject);
 
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "IoCreateDevice call failed with status 0x%08x\n", Status);
        return Status;
    }
 
    /*
     * Set the buffering strategy here. If you change this, remember
     * to change VidDispatchDeviceControl too.
     */
 
    (*DeviceObject)->Flags |= DO_BUFFERED_IO;
 
    /* Initialize device extension. */
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)((*DeviceObject)->DeviceExtension);
    DeviceExtension->Common.Fdo = TRUE;
    DeviceExtension->DeviceNumber = DeviceNumber;
    DeviceExtension->DriverObject = DriverObject;
    DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
    DeviceExtension->FunctionalDeviceObject = *DeviceObject;
    DeviceExtension->DriverExtension = DriverExtension;
    DeviceExtension->SessionId = -1;
    DeviceExtension->AdapterNumber = AdapterNumber;
    DeviceExtension->DisplayNumber = DisplayNumber;
 
    InitializeListHead(&DeviceExtension->ChildDeviceList);
 
    /* Get the registry path associated with this device. */
    Status = IntCreateRegistryPath(&DriverExtension->RegistryPath,
                                   DeviceExtension->AdapterNumber,
                                   &DeviceExtension->RegistryPath);
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "IntCreateRegistryPath() call failed with status 0x%08x\n", Status);
        goto Failure;
    }
 
    if (PhysicalDeviceObject != NULL)
    {
        /* Get bus number from the upper level bus driver. */
        Size = sizeof(ULONG);
        Status = IoGetDeviceProperty(PhysicalDeviceObject,
                                     DevicePropertyBusNumber,
                                     Size,
                                     &DeviceExtension->SystemIoBusNumber,
                                     &Size);
        if (!NT_SUCCESS(Status))
        {
            WARN_(VIDEOPRT, "Couldn't get an information from bus driver. We will try to\n"
                  "use legacy detection method, but even that doesn't mean that\n"
                  "it will work.\n");
            DeviceExtension->PhysicalDeviceObject = NULL;
        }
    }
 
    DeviceExtension->AdapterInterfaceType =
        DriverExtension->InitializationData.AdapterInterfaceType;
 
    if (PhysicalDeviceObject != NULL)
    {
        /* Get bus type from the upper level bus driver. */
        Size = sizeof(ULONG);
        IoGetDeviceProperty(PhysicalDeviceObject,
                            DevicePropertyLegacyBusType,
                            Size,
                            &DeviceExtension->AdapterInterfaceType,
                            &Size);
 
        /* Get bus device address from the upper level bus driver. */
        Size = sizeof(ULONG);
        IoGetDeviceProperty(PhysicalDeviceObject,
                            DevicePropertyAddress,
                            Size,
                            &PciSlotNumber,
                            &Size);
 
        /* Convert slotnumber to PCI_SLOT_NUMBER */
        SlotNumber.u.AsULONG = 0;
        SlotNumber.u.bits.DeviceNumber = (PciSlotNumber >> 16) & 0xFFFF;
        SlotNumber.u.bits.FunctionNumber = PciSlotNumber & 0xFFFF;
        DeviceExtension->SystemIoSlotNumber = SlotNumber.u.AsULONG;
    }
 
    InitializeListHead(&DeviceExtension->AddressMappingListHead);
    InitializeListHead(&DeviceExtension->DmaAdapterList);
 
    KeInitializeDpc(&DeviceExtension->DpcObject,
                    IntVideoPortDeferredRoutine,
                    DeviceExtension);
 
    KeInitializeMutex(&DeviceExtension->DeviceLock, 0);
 
    /* Attach the device. */
    if ((PhysicalDeviceObject != NULL) && (DisplayNumber == 0))
        DeviceExtension->NextDeviceObject = IoAttachDeviceToDeviceStack(
                                                *DeviceObject,
                                                PhysicalDeviceObject);
 
    Status = IntCreateNewRegistryPath(DeviceExtension);
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "IntCreateNewRegistryPath() failed with status 0x%08x\n", Status);
        goto Failure;
    }
 
    IntSetupDeviceSettingsKey(DeviceExtension);
 
    /* Remove the initializing flag */
    (*DeviceObject)->Flags &= ~DO_DEVICE_INITIALIZING;
 
    /* Set up the VIDEO/DEVICEMAP registry keys */
    Status = IntVideoPortAddDeviceMapLink(DeviceExtension);
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "IntVideoPortAddDeviceMapLink() failed with status 0x%08x\n", Status);
        goto Failure;
    }
 
    if (DisplayNumber == 0)
    {
        DriverExtension->InitializationData.StartingDeviceNumber++;
    }
 
    return STATUS_SUCCESS;
 
Failure:
    if (DeviceExtension->NextDeviceObject)
        IoDetachDevice(DeviceExtension->NextDeviceObject);
    IoDeleteDevice(*DeviceObject);
    *DeviceObject = NULL;
    return Status;
}

Referenced by IntVideoPortAddDevice(), VideoPortCreateSecondaryDisplay(), and VideoPortInitialize().

IntVideoPortDispatchCleanup()

NTSTATUS NTAPI IntVideoPortDispatchCleanup	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1123 of file dispatch.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
 
    DeviceExtension = DeviceObject->DeviceExtension;
    RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

IntVideoPortDispatchClose()

NTSTATUS NTAPI IntVideoPortDispatchClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 436 of file dispatch.c.

{
    TRACE_(VIDEOPRT, "IntVideoPortDispatchClose\n");
 
    IntVideoPortInbvCleanup(DeviceObject);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

Referenced by VideoPortInitialize().

IntVideoPortDispatchDeviceControl()

NTSTATUS NTAPI IntVideoPortDispatchDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 723 of file dispatch.c.

{
    PIO_STACK_LOCATION IrpStack;
    NTSTATUS Status;
    ULONG IoControlCode;
 
    TRACE_(VIDEOPRT, "IntVideoPortDispatchDeviceControl\n");
 
    IrpStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpStack->MajorFunction)
    {
        case IRP_MJ_DEVICE_CONTROL:
            /* This is the main part of this function and is handled below */
            break;
 
        case IRP_MJ_SHUTDOWN:
        {
            /* Dereference CSRSS */
            PKPROCESS OldCsrProcess;
            OldCsrProcess = InterlockedExchangePointer((PVOID*)&CsrProcess, NULL);
            if (OldCsrProcess)
                ObDereferenceObject(OldCsrProcess);
 
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_SUCCESS;
        }
 
        default:
            ERR_(VIDEOPRT, "- Unknown MajorFunction 0x%x\n", IrpStack->MajorFunction);
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_SUCCESS;
    }
 
    IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
 
    INFO_(VIDEOPRT, "- IoControlCode: 0x%x: %s\n", IoControlCode, IoctlName(IoControlCode));
 
    switch (IoControlCode)
    {
        case IOCTL_VIDEO_ENABLE_VDM:
        case IOCTL_VIDEO_DISABLE_VDM:
        case IOCTL_VIDEO_REGISTER_VDM:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_*_VDM are UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_SET_OUTPUT_DEVICE_POWER_STATE:
        case IOCTL_VIDEO_GET_OUTPUT_DEVICE_POWER_STATE:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_GET/SET_OUTPUT_DEVICE_POWER_STATE are UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_SET_POWER_MANAGEMENT:
        case IOCTL_VIDEO_GET_POWER_MANAGEMENT:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_GET/SET_POWER_MANAGEMENT are UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_QUERY_SUPPORTED_BRIGHTNESS:
        case IOCTL_VIDEO_QUERY_DISPLAY_BRIGHTNESS:
        case IOCTL_VIDEO_SET_DISPLAY_BRIGHTNESS:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_*_BRIGHTNESS are UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_ENUM_MONITOR_PDO:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_ENUM_MONITOR_PDO is UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_INIT_WIN32K_CALLBACKS:
            INFO_(VIDEOPRT, "- IOCTL_VIDEO_INIT_WIN32K_CALLBACKS\n");
            Status = VideoPortInitWin32kCallbacks(DeviceObject,
                                                  Irp->AssociatedIrp.SystemBuffer,
                                                  IrpStack->Parameters.DeviceIoControl.InputBufferLength,
                                                  &Irp->IoStatus.Information);
            break;
 
        case IOCTL_VIDEO_IS_VGA_DEVICE:
            WARN_(VIDEOPRT, "- IOCTL_VIDEO_IS_VGA_DEVICE is UNIMPLEMENTED!\n");
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_VIDEO_USE_DEVICE_IN_SESSION:
            INFO_(VIDEOPRT, "- IOCTL_VIDEO_USE_DEVICE_IN_SESSION\n");
            Status = VideoPortUseDeviceInSession(DeviceObject,
                                                 Irp->AssociatedIrp.SystemBuffer,
                                                 IrpStack->Parameters.DeviceIoControl.InputBufferLength,
                                                 &Irp->IoStatus.Information);
            break;
 
        case IOCTL_VIDEO_PREPARE_FOR_EARECOVERY:
            INFO_(VIDEOPRT, "- IOCTL_VIDEO_PREPARE_FOR_EARECOVERY\n");
            /*
             * The Win32k Watchdog Timer detected that a thread spent more time
             * in a display driver than the allotted time its threshold specified,
             * and thus is going to attempt to recover by switching to VGA mode.
             * If this attempt fails, the watchdog generates bugcheck 0xEA
             * "THREAD_STUCK_IN_DEVICE_DRIVER".
             *
             * Prepare the recovery by resetting the display adapters to
             * standard VGA 80x25 text mode.
             */
            IntVideoPortResetDisplayParametersEx(80, 25, FALSE);
            Status = STATUS_SUCCESS;
            break;
 
        default:
            /* Forward to the Miniport Driver */
            Status = VideoPortForwardDeviceControl(DeviceObject, Irp);
            break;
    }
 
    INFO_(VIDEOPRT, "- Returned status: 0x%x\n", Status);
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_VIDEO_INCREMENT);
    return Status;
}

Referenced by VideoPortInitialize().

IntVideoPortDispatchOpen()

NTSTATUS NTAPI IntVideoPortDispatchOpen	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 369 of file dispatch.c.

{
    NTSTATUS Status;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
 
    TRACE_(VIDEOPRT, "IntVideoPortDispatchOpen\n");
 
    if (!CsrProcess)
    {
        /*
         * We know the first open call will be from the CSRSS process
         * to let us know its handle.
         */
        INFO_(VIDEOPRT, "Referencing CSRSS\n");
        CsrProcess = (PKPROCESS)PsGetCurrentProcess();
        ObReferenceObject(CsrProcess);
        INFO_(VIDEOPRT, "CsrProcess 0x%p\n", CsrProcess);
 
        Status = IntInitializeVideoAddressSpace();
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "IntInitializeVideoAddressSpace() failed: 0x%lx\n", Status);
            ObDereferenceObject(CsrProcess);
            CsrProcess = NULL;
            return Status;
        }
    }
 
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    DriverExtension = DeviceExtension->DriverExtension;
 
    // FIXME: (Re-)initialize INBV only if DeviceObject doesn't belong to a mirror driver.
    IntVideoPortInbvInitialize();
 
    if (DriverExtension->InitializationData.HwInitialize(&DeviceExtension->MiniPortDeviceExtension))
    {
        Status = STATUS_SUCCESS;
        InterlockedIncrement((PLONG)&DeviceExtension->DeviceOpened);
 
        /* Query children, now that device is opened */
        VideoPortEnumerateChildren(DeviceExtension->MiniPortDeviceExtension, NULL);
    }
    else
    {
        Status = STATUS_UNSUCCESSFUL;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = FILE_OPENED;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by VideoPortInitialize().

IntVideoPortDispatchPdoPnp()

NTSTATUS NTAPI IntVideoPortDispatchPdoPnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 386 of file child.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status = Irp->IoStatus.Status;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        case IRP_MN_STOP_DEVICE:
            /* Nothing to do */
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_RESOURCES:
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            /* None (keep old status) */
            break;
 
        case IRP_MN_QUERY_ID:
            /* Call our helper */
            Status = IntVideoPortChildQueryId(DeviceObject->DeviceExtension,
                                              Irp,
                                              IrpSp);
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
            /* Call our helper */
            Status = IntVideoPortChildQueryCapabilities(DeviceObject->DeviceExtension,
                                                        Irp,
                                                        IrpSp);
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
        case IRP_MN_QUERY_REMOVE_DEVICE:
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            IoDeleteDevice(DeviceObject);
            return STATUS_SUCCESS;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            /* Call our helper */
            Status = IntVideoPortChildQueryRelations(DeviceObject->DeviceExtension,
                                                     Irp,
                                                     IrpSp);
            break;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            /* Call our helper */
            Status = IntVideoPortChildQueryText(DeviceObject->DeviceExtension,
                                                Irp,
                                                IrpSp);
            break;
 
        default:
            break;
    }
 
    Irp->IoStatus.Status = Status;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by IntVideoPortDispatchPnp().

IntVideoPortDispatchPnp()

NTSTATUS NTAPI IntVideoPortDispatchPnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1109 of file dispatch.c.

{
    PVIDEO_PORT_COMMON_EXTENSION CommonExtension = DeviceObject->DeviceExtension;
 
    if (CommonExtension->Fdo)
        return IntVideoPortDispatchFdoPnp(DeviceObject, Irp);
    else
        return IntVideoPortDispatchPdoPnp(DeviceObject, Irp);
}

Referenced by VideoPortInitialize().

IntVideoPortDispatchPower()

NTSTATUS NTAPI IntVideoPortDispatchPower	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1141 of file dispatch.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status = Irp->IoStatus.Status;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    if (DeviceExtension->Common.Fdo)
    {
        PoStartNextPowerIrp(Irp);
        IoSkipCurrentIrpStackLocation(Irp);
        return PoCallDriver(DeviceExtension->NextDeviceObject, Irp);
    }
    else
    {
        switch (IrpSp->MinorFunction)
        {
            case IRP_MN_QUERY_POWER:
            case IRP_MN_SET_POWER:
                Status = STATUS_SUCCESS;
                break;
        }
        PoStartNextPowerIrp(Irp);
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

Referenced by VideoPortInitialize().

IntVideoPortDispatchSystemControl()

NTSTATUS NTAPI IntVideoPortDispatchSystemControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1175 of file dispatch.c.

{
    NTSTATUS Status;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
 
    if (DeviceExtension->Common.Fdo)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
    }
    else
    {
        Status = Irp->IoStatus.Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

Referenced by VideoPortInitialize().

IntVideoPortEnumerateChildren()

NTSTATUS NTAPI IntVideoPortEnumerateChildren	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1280 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    ULONG Status;
    VIDEO_CHILD_ENUM_INFO ChildEnumInfo;
    BOOLEAN bHaveLastMonitorID = FALSE;
    UCHAR LastMonitorID[10];
    ULONG Unused;
    UINT i;
    PDEVICE_OBJECT ChildDeviceObject;
    PVIDEO_PORT_CHILD_EXTENSION ChildExtension;
 
    INFO_(VIDEOPRT, "Starting child device probe\n");
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor == NULL)
    {
        WARN_(VIDEOPRT, "Miniport's HwGetVideoChildDescriptor is NULL!\n");
        return STATUS_SUCCESS;
    }
 
    if (!IsListEmpty(&DeviceExtension->ChildDeviceList))
    {
        ERR_(VIDEOPRT, "FIXME: Support calling VideoPortEnumerateChildren again!\n");
        return STATUS_SUCCESS;
    }
 
    /* Enumerate the children */
    for (i = 1; ; i++)
    {
        Status = IoCreateDevice(DeviceExtension->DriverObject,
                                sizeof(VIDEO_PORT_CHILD_EXTENSION) +
                                DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize,
                                NULL,
                                FILE_DEVICE_CONTROLLER,
                                FILE_DEVICE_SECURE_OPEN,
                                FALSE,
                                &ChildDeviceObject);
        if (!NT_SUCCESS(Status))
            return Status;
 
        ChildExtension = ChildDeviceObject->DeviceExtension;
 
        RtlZeroMemory(ChildExtension,
                      sizeof(VIDEO_PORT_CHILD_EXTENSION) +
                        DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize);
 
        ChildExtension->Common.Fdo = FALSE;
        ChildExtension->ChildId = i;
        ChildExtension->PhysicalDeviceObject = ChildDeviceObject;
        ChildExtension->DriverObject = DeviceExtension->DriverObject;
 
        /* Setup the ChildEnumInfo */
        ChildEnumInfo.Size = sizeof(ChildEnumInfo);
        ChildEnumInfo.ChildDescriptorSize = sizeof(ChildExtension->ChildDescriptor);
        ChildEnumInfo.ACPIHwId = 0;
 
        if (DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize)
            ChildEnumInfo.ChildHwDeviceExtension = VIDEO_PORT_GET_CHILD_EXTENSION(ChildExtension);
        else
            ChildEnumInfo.ChildHwDeviceExtension = NULL;
 
        ChildEnumInfo.ChildIndex = ChildExtension->ChildId;
 
        INFO_(VIDEOPRT, "Probing child: %d\n", ChildEnumInfo.ChildIndex);
        Status = DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor(
                     DeviceExtension->MiniPortDeviceExtension,
                     &ChildEnumInfo,
                     &ChildExtension->ChildType,
                     ChildExtension->ChildDescriptor,
                     &ChildExtension->ChildId,
                     &Unused);
        if (Status == VIDEO_ENUM_MORE_DEVICES)
        {
            if (ChildExtension->ChildType == Monitor)
            {
                // Check if the EDID is valid
                if (ChildExtension->ChildDescriptor[0] == 0x00 &&
                        ChildExtension->ChildDescriptor[1] == 0xFF &&
                        ChildExtension->ChildDescriptor[2] == 0xFF &&
                        ChildExtension->ChildDescriptor[3] == 0xFF &&
                        ChildExtension->ChildDescriptor[4] == 0xFF &&
                        ChildExtension->ChildDescriptor[5] == 0xFF &&
                        ChildExtension->ChildDescriptor[6] == 0xFF &&
                        ChildExtension->ChildDescriptor[7] == 0x00)
                {
                    if (bHaveLastMonitorID)
                    {
                        // Compare the previous monitor ID with the current one, break the loop if they are identical
                        if (RtlCompareMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID)) == sizeof(LastMonitorID))
                        {
                            INFO_(VIDEOPRT, "Found identical Monitor ID two times, stopping enumeration\n");
                            IoDeleteDevice(ChildDeviceObject);
                            break;
                        }
                    }
 
                    // Copy 10 bytes from the EDID, which can be used to uniquely identify the monitor
                    RtlCopyMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID));
                    bHaveLastMonitorID = TRUE;
 
                    /* Mark it valid */
                    ChildExtension->EdidValid = TRUE;
                }
                else
                {
                    /* Mark it invalid */
                    ChildExtension->EdidValid = FALSE;
                }
            }
        }
        else if (Status == VIDEO_ENUM_INVALID_DEVICE)
        {
            WARN_(VIDEOPRT, "Child device %d is invalid!\n", ChildEnumInfo.ChildIndex);
            IoDeleteDevice(ChildDeviceObject);
            continue;
        }
        else if (Status == VIDEO_ENUM_NO_MORE_DEVICES)
        {
            INFO_(VIDEOPRT, "End of child enumeration! (%d children enumerated)\n", i - 1);
            IoDeleteDevice(ChildDeviceObject);
            break;
        }
        else
        {
            WARN_(VIDEOPRT, "HwGetVideoChildDescriptor returned unknown status code 0x%x!\n", Status);
            IoDeleteDevice(ChildDeviceObject);
            break;
        }
 
        if (ChildExtension->ChildType == Monitor)
        {
            UINT j;
            PUCHAR p = ChildExtension->ChildDescriptor;
            INFO_(VIDEOPRT, "Monitor device enumerated! (ChildId = 0x%x)\n", ChildExtension->ChildId);
            for (j = 0; j < sizeof (ChildExtension->ChildDescriptor); j += 8)
            {
                INFO_(VIDEOPRT, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
                      p[j + 0], p[j + 1], p[j + 2], p[j + 3],
                      p[j + 4], p[j + 5], p[j + 6], p[j + 7]);
            }
        }
        else if (ChildExtension->ChildType == Other)
        {
            INFO_(VIDEOPRT, "\"Other\" device enumerated: DeviceId = %S\n", (PWSTR)ChildExtension->ChildDescriptor);
        }
        else
        {
            ERR_(VIDEOPRT, "HwGetVideoChildDescriptor returned unsupported type: %d\n", ChildExtension->ChildType);
        }
 
        /* Clear the init flag */
        ChildDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
        InsertTailList(&DeviceExtension->ChildDeviceList,
                       &ChildExtension->ListEntry);
    }
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortQueryBusRelations().

IntVideoPortFilterResourceRequirements()

NTSTATUS NTAPI IntVideoPortFilterResourceRequirements	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIO_STACK_LOCATION	IrpStack,
		IN PIRP	Irp
	)

Definition at line 77 of file resource.c.

{
    PDRIVER_OBJECT DriverObject;
    PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    PVIDEO_ACCESS_RANGE AccessRanges;
    ULONG AccessRangeCount, ListSize, i;
    PIO_RESOURCE_REQUIREMENTS_LIST ResList;
    PIO_RESOURCE_REQUIREMENTS_LIST OldResList = IrpStack->Parameters.FilterResourceRequirements.IoResourceRequirementList;
    PIO_RESOURCE_DESCRIPTOR CurrentDescriptor;
    NTSTATUS Status;
 
    DriverObject = DeviceObject->DriverObject;
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    Status = IntVideoPortGetLegacyResources(DriverExtension, DeviceExtension, &AccessRanges, &AccessRangeCount);
    if (!NT_SUCCESS(Status))
        return Status;
    if (!AccessRangeCount)
    {
        /* No legacy resources to report */
        return Irp->IoStatus.Status;
    }
 
    /* OK, we've got the access ranges now. Let's set up the resource requirements list */
 
    if (OldResList)
    {
        /* Already one there so let's add to it */
        ListSize = OldResList->ListSize + sizeof(IO_RESOURCE_DESCRIPTOR) * AccessRangeCount;
        ResList = ExAllocatePool(NonPagedPool,
                                 ListSize);
        if (!ResList) return STATUS_NO_MEMORY;
 
        RtlCopyMemory(ResList, OldResList, OldResList->ListSize);
 
        ASSERT(ResList->AlternativeLists == 1);
 
        ResList->ListSize = ListSize;
        ResList->List[0].Count += AccessRangeCount;
 
        CurrentDescriptor = (PIO_RESOURCE_DESCRIPTOR)((PUCHAR)ResList + OldResList->ListSize);
 
        ExFreePool(OldResList);
        Irp->IoStatus.Information = 0;
    }
    else
    {
        /* We need to make a new one */
        ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + sizeof(IO_RESOURCE_DESCRIPTOR) * (AccessRangeCount - 1);
        ResList = ExAllocatePool(NonPagedPool,
                                 ListSize);
        if (!ResList) return STATUS_NO_MEMORY;
 
        RtlZeroMemory(ResList, ListSize);
 
        /* We need to initialize some fields */
        ResList->ListSize = ListSize;
        ResList->InterfaceType = DeviceExtension->AdapterInterfaceType;
        ResList->BusNumber = DeviceExtension->SystemIoBusNumber;
        ResList->SlotNumber = DeviceExtension->SystemIoSlotNumber;
        ResList->AlternativeLists = 1;
        ResList->List[0].Version = 1;
        ResList->List[0].Revision = 1;
        ResList->List[0].Count = AccessRangeCount;
 
        CurrentDescriptor = ResList->List[0].Descriptors;
    }
 
    for (i = 0; i < AccessRangeCount; i++)
    {
        /* This is a required resource */
        CurrentDescriptor->Option = 0;
 
        if (AccessRanges[i].RangeInIoSpace)
            CurrentDescriptor->Type = CmResourceTypePort;
        else
            CurrentDescriptor->Type = CmResourceTypeMemory;
 
        CurrentDescriptor->ShareDisposition =
        (AccessRanges[i].RangeShareable ? CmResourceShareShared : CmResourceShareDeviceExclusive);
 
        CurrentDescriptor->Flags = 0;
 
        if (CurrentDescriptor->Type == CmResourceTypePort)
        {
            CurrentDescriptor->u.Port.Length = AccessRanges[i].RangeLength;
            CurrentDescriptor->u.Port.MinimumAddress = AccessRanges[i].RangeStart;
            CurrentDescriptor->u.Port.MaximumAddress.QuadPart = AccessRanges[i].RangeStart.QuadPart + AccessRanges[i].RangeLength - 1;
            CurrentDescriptor->u.Port.Alignment = 1;
            if (AccessRanges[i].RangePassive & VIDEO_RANGE_PASSIVE_DECODE)
                CurrentDescriptor->Flags |= CM_RESOURCE_PORT_PASSIVE_DECODE;
            if (AccessRanges[i].RangePassive & VIDEO_RANGE_10_BIT_DECODE)
                CurrentDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
        }
        else
        {
            CurrentDescriptor->u.Memory.Length = AccessRanges[i].RangeLength;
            CurrentDescriptor->u.Memory.MinimumAddress = AccessRanges[i].RangeStart;
            CurrentDescriptor->u.Memory.MaximumAddress.QuadPart = AccessRanges[i].RangeStart.QuadPart + AccessRanges[i].RangeLength - 1;
            CurrentDescriptor->u.Memory.Alignment = 1;
            CurrentDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
        }
 
        CurrentDescriptor++;
    }
 
    Irp->IoStatus.Information = (ULONG_PTR)ResList;
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortDispatchFdoPnp().

IntVideoPortFindAdapter()

NTSTATUS NTAPI IntVideoPortFindAdapter	(	IN PDRIVER_OBJECT	DriverObject,
		IN PVIDEO_PORT_DRIVER_EXTENSION	DriverExtension,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 414 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    VP_STATUS vpStatus;
    VIDEO_PORT_CONFIG_INFO ConfigInfo;
    SYSTEM_BASIC_INFORMATION SystemBasicInfo;
    UCHAR Again = FALSE;
    BOOL LegacyDetection = FALSE;
 
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* Setup a ConfigInfo structure that we will pass to HwFindAdapter. */
    RtlZeroMemory(&ConfigInfo, sizeof(VIDEO_PORT_CONFIG_INFO));
    ConfigInfo.Length = sizeof(VIDEO_PORT_CONFIG_INFO);
    ConfigInfo.AdapterInterfaceType = DeviceExtension->AdapterInterfaceType;
    if (ConfigInfo.AdapterInterfaceType == PCIBus)
        ConfigInfo.InterruptMode = LevelSensitive;
    else
        ConfigInfo.InterruptMode = Latched;
    ConfigInfo.DriverRegistryPath = DriverExtension->RegistryPath.Buffer;
    ConfigInfo.VideoPortGetProcAddress = IntVideoPortGetProcAddress;
    ConfigInfo.SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
    ConfigInfo.BusInterruptLevel = DeviceExtension->InterruptLevel;
    ConfigInfo.BusInterruptVector = DeviceExtension->InterruptVector;
 
    Status = ZwQuerySystemInformation(SystemBasicInformation,
                                      &SystemBasicInfo,
                                      sizeof(SystemBasicInfo),
                                      NULL);
    if (NT_SUCCESS(Status))
    {
        ConfigInfo.SystemMemorySize = SystemBasicInfo.NumberOfPhysicalPages *
                                      SystemBasicInfo.PageSize;
    }
 
    // FIXME: Check the adapter key and update VideoDebugLevel variable.
 
    /*
     * Call miniport HwVidFindAdapter entry point to detect if
     * particular device is present. There are two possible code
     * paths. The first one is for Legacy drivers (NT4) and cases
     * when we don't have information about what bus we're on. The
     * second case is the standard one for Plug & Play drivers.
     */
    if (DeviceExtension->PhysicalDeviceObject == NULL)
    {
        LegacyDetection = TRUE;
    }
 
    if (LegacyDetection)
    {
        ULONG BusNumber;
 
        /* Suppose first we may not find any suitable device */
        vpStatus = ERROR_DEV_NOT_EXIST; // ERROR_NO_MORE_DEVICES;
 
        /* Enumerate all buses of the given type, call HwFindAdapter for each
         * to find whether a video adapter is recognized there. Stop when an
         * adapter has been found. */
        for (BusNumber = 0;
             (BusNumber < MAXULONG) &&
             NT_SUCCESS(IntVideoPortEnumBuses(DeviceExtension->AdapterInterfaceType,
                                              &BusNumber));
             ++BusNumber)
        {
            DPRINT("Bus Type %lu, Number %lu\n",
                   DeviceExtension->AdapterInterfaceType, BusNumber);
 
            DeviceExtension->SystemIoBusNumber =
                ConfigInfo.SystemIoBusNumber = BusNumber;
 
            RtlZeroMemory(&DeviceExtension->MiniPortDeviceExtension,
                          DriverExtension->InitializationData.HwDeviceExtensionSize);
 
            /* FIXME: Need to figure out what string to pass as param 3. */
            // FIXME: Handle the 'Again' parameter for legacy detection.
            vpStatus = DriverExtension->InitializationData.HwFindAdapter(
                         &DeviceExtension->MiniPortDeviceExtension,
                         DriverExtension->HwContext,
                         NULL,
                         &ConfigInfo,
                         &Again);
 
            if (vpStatus == ERROR_DEV_NOT_EXIST)
            {
                continue;
            }
            else
            {
                break;
            }
        }
    }
    else
    {
        /* FIXME: Need to figure out what string to pass as param 3. */
        vpStatus = DriverExtension->InitializationData.HwFindAdapter(
                     &DeviceExtension->MiniPortDeviceExtension,
                     DriverExtension->HwContext,
                     NULL,
                     &ConfigInfo,
                     &Again);
    }
 
    if (vpStatus != NO_ERROR)
    {
        ERR_(VIDEOPRT, "HwFindAdapter call failed with error 0x%X\n", vpStatus);
        Status = STATUS_UNSUCCESSFUL;
        goto Failure;
    }
 
    /*
     * Now we know the device is present, so let's do all additional tasks
     * such as creating symlinks or setting up interrupts and timer.
     */
 
    /* FIXME: Allocate hardware resources for device. */
 
    /* Allocate interrupt for device. */
    if (!IntVideoPortSetupInterrupt(DeviceObject, DriverExtension, &ConfigInfo))
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
 
    /* Allocate timer for device. */
    if (!IntVideoPortSetupTimer(DeviceObject, DriverExtension))
    {
        if (DeviceExtension->InterruptObject != NULL)
            IoDisconnectInterrupt(DeviceExtension->InterruptObject);
        ERR_(VIDEOPRT, "IntVideoPortSetupTimer failed\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
 
    /* If the device can be reset, insert it in the list of resettable adapters */
    InitializeListHead(&DeviceExtension->HwResetListEntry);
    if (DriverExtension->InitializationData.HwResetHw != NULL)
    {
        ExInterlockedInsertTailList(&HwResetAdaptersList,
                                    &DeviceExtension->HwResetListEntry,
                                    &HwResetAdaptersLock);
    }
 
    INFO_(VIDEOPRT, "STATUS_SUCCESS\n");
    return STATUS_SUCCESS;
 
Failure:
    RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
    if (DeviceExtension->NextDeviceObject)
        IoDetachDevice(DeviceExtension->NextDeviceObject);
    IoDeleteDevice(DeviceObject);
    return Status;
}

Referenced by IntVideoPortPnPStartDevice(), and VideoPortInitialize().

IntVideoPortGetProcAddress()

PVOID NTAPI IntVideoPortGetProcAddress	(	IN PVOID	HwDeviceExtension,
		IN PUCHAR	FunctionName
	)

Definition at line 100 of file funclist.c.

{
    ULONG i;
 
    TRACE_(VIDEOPRT, "VideoPortGetProcAddress(%s)\n", FunctionName);
 
   /* Search by name */
    for (i = 0; i < ARRAYSIZE(VideoPortExports); i++)
    {
        if (!strcmp((PCHAR)FunctionName, VideoPortExports[i].Name))
        {
            return (PVOID)VideoPortExports[i].Address;
        }
    }
 
    ERR_(VIDEOPRT, "VideoPortGetProcAddress: Can't resolve symbol %s\n", FunctionName);
 
    return NULL;
}

Referenced by IntVideoPortFindAdapter().

IntVideoPortMapPhysicalMemory()

NTSTATUS NTAPI IntVideoPortMapPhysicalMemory	(	IN HANDLE	Process,
		IN PHYSICAL_ADDRESS	PhysicalAddress,
		IN ULONG	SizeInBytes,
		IN ULONG	Protect,
		IN OUT PVOID *VirtualAddress	OPTIONAL
	)

Definition at line 219 of file resource.c.

{
   OBJECT_ATTRIBUTES ObjAttribs;
   UNICODE_STRING UnicodeString;
   HANDLE hMemObj;
   NTSTATUS Status;
   SIZE_T Size;
 
   /* Initialize object attribs */
   RtlInitUnicodeString(&UnicodeString, L"\\Device\\PhysicalMemory");
   InitializeObjectAttributes(&ObjAttribs,
                              &UnicodeString,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL, NULL);
 
   /* Open physical memory section */
   Status = ZwOpenSection(&hMemObj, SECTION_ALL_ACCESS, &ObjAttribs);
   if (!NT_SUCCESS(Status))
   {
      WARN_(VIDEOPRT, "ZwOpenSection() failed! (0x%x)\n", Status);
      return Status;
   }
 
   /* Map view of section */
   Size = SizeInBytes;
   Status = ZwMapViewOfSection(hMemObj,
                               Process,
                               VirtualAddress,
                               0,
                               Size,
                               (PLARGE_INTEGER)(&PhysicalAddress),
                               &Size,
                               ViewUnmap,
                               0,
                               Protect);
   ZwClose(hMemObj);
   if (!NT_SUCCESS(Status))
   {
      WARN_(VIDEOPRT, "ZwMapViewOfSection() failed! (0x%x)\n", Status);
   }
 
   return Status;
}

Referenced by IntAgpCommitVirtual(), and IntVideoPortMapMemory().

IntVideoPortReleaseResources()

VOID IntVideoPortReleaseResources

(

_In_ PVIDEO_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 194 of file resource.c.

{
    NTSTATUS Status;
    BOOLEAN ConflictDetected;
    // An empty CM_RESOURCE_LIST
    UCHAR EmptyResourceList[FIELD_OFFSET(CM_RESOURCE_LIST, List)] = {0};
 
    Status = IoReportResourceForDetection(
                DeviceExtension->DriverObject,
                NULL, 0, /* Driver List */
                DeviceExtension->PhysicalDeviceObject,
                (PCM_RESOURCE_LIST)EmptyResourceList,
                sizeof(EmptyResourceList),
                &ConflictDetected);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("VideoPortReleaseResources IoReportResource failed with 0x%08lx ; ConflictDetected: %s\n",
                Status, ConflictDetected ? "TRUE" : "FALSE");
    }
    /* Ignore the returned status however... */
}

Referenced by VideoPortVerifyAccessRanges().

IntVideoPortSetupInterrupt()

BOOLEAN NTAPI IntVideoPortSetupInterrupt	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVIDEO_PORT_DRIVER_EXTENSION	DriverExtension,
		IN PVIDEO_PORT_CONFIG_INFO	ConfigInfo
	)

Definition at line 45 of file interrupt.c.

{
   NTSTATUS Status;
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
 
   DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
   /*
    * MSDN documentation for VIDEO_PORT_CONFIG_INFO states: "If a miniport driver's
    * HwVidFindAdapter function finds that the video adapter does not generate
    * interrupts or that it cannot determine a valid interrupt vector/level for
    * the adapter, HwVidFindAdapter should set both BusInterruptVector and
    * BusInterruptLevel to zero.
    */
 
   if (DriverExtension->InitializationData.HwInterrupt != NULL &&
       (ConfigInfo->BusInterruptLevel != 0 ||
       ConfigInfo->BusInterruptVector != 0))
   {
      ULONG InterruptVector;
      KIRQL Irql;
      KAFFINITY Affinity;
 
      InterruptVector = HalGetInterruptVector(
         ConfigInfo->AdapterInterfaceType,
         ConfigInfo->SystemIoBusNumber,
         ConfigInfo->BusInterruptLevel,
         ConfigInfo->BusInterruptVector,
         &Irql,
         &Affinity);
 
      if (InterruptVector == 0)
      {
         WARN_(VIDEOPRT, "HalGetInterruptVector failed\n");
         return FALSE;
      }
 
      KeInitializeSpinLock(&DeviceExtension->InterruptSpinLock);
      Status = IoConnectInterrupt(
         &DeviceExtension->InterruptObject,
         IntVideoPortInterruptRoutine,
         DeviceExtension,
         &DeviceExtension->InterruptSpinLock,
         InterruptVector,
         Irql,
         Irql,
         ConfigInfo->InterruptMode,
         DeviceExtension->InterruptShared,
         Affinity,
         FALSE);
 
      if (!NT_SUCCESS(Status))
      {
         WARN_(VIDEOPRT, "IoConnectInterrupt failed with status 0x%08x\n", Status);
         return FALSE;
      }
   }
 
   return TRUE;
}

Referenced by IntVideoPortFindAdapter().

IntVideoPortSetupTimer()

BOOLEAN NTAPI IntVideoPortSetupTimer	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVIDEO_PORT_DRIVER_EXTENSION	DriverExtension
	)

Definition at line 43 of file timer.c.

{
   NTSTATUS Status;
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
 
   DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
   if (DriverExtension->InitializationData.HwTimer != NULL)
   {
      INFO_(VIDEOPRT, "Initializing timer\n");
 
      Status = IoInitializeTimer(
         DeviceObject,
         IntVideoPortTimerRoutine,
         DeviceExtension);
 
      if (!NT_SUCCESS(Status))
      {
         ERR_(VIDEOPRT, "IoInitializeTimer failed with status 0x%08x\n", Status);
         return FALSE;
      }
   }
 
   return TRUE;
}

Referenced by IntVideoPortFindAdapter().

IntVideoPortUnload()

VOID NTAPI IntVideoPortUnload

(

PDRIVER_OBJECT

DriverObject

)

Definition at line 1197 of file dispatch.c.

{
}

Referenced by VideoPortInitialize().

IopInitiatePnpIrp()

NTSTATUS IopInitiatePnpIrp	(	PDEVICE_OBJECT	DeviceObject,
		PIO_STATUS_BLOCK	IoStatusBlock,
		UCHAR	MinorFunction,
		PIO_STACK_LOCATION Stack	OPTIONAL
	)

Definition at line 30 of file agp.c.

{
  PDEVICE_OBJECT TopDeviceObject;
  PIO_STACK_LOCATION IrpSp;
  NTSTATUS Status;
  KEVENT Event;
  PIRP Irp;
 
  /* Always call the top of the device stack */
  TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
 
  KeInitializeEvent(
    &Event,
    NotificationEvent,
    FALSE);
 
  Irp = IoBuildSynchronousFsdRequest(
    IRP_MJ_PNP,
    TopDeviceObject,
    NULL,
    0,
    NULL,
    &Event,
    IoStatusBlock);
 
  /* PNP IRPs are always initialized with a status code of
     STATUS_NOT_SUPPORTED */
  Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
  Irp->IoStatus.Information = 0;
 
  IrpSp = IoGetNextIrpStackLocation(Irp);
  IrpSp->MinorFunction = MinorFunction;
 
  if (Stack)
  {
    RtlMoveMemory(
      &IrpSp->Parameters,
      &Stack->Parameters,
      sizeof(Stack->Parameters));
  }
 
  Status = IoCallDriver(TopDeviceObject, Irp);
  if (Status == STATUS_PENDING)
    {
      KeWaitForSingleObject(
        &Event,
        Executive,
        KernelMode,
        FALSE,
        NULL);
      Status = IoStatusBlock->Status;
    }
 
  ObDereferenceObject(TopDeviceObject);
 
  return Status;
}

Referenced by IntAgpGetInterface().

Variable Documentation

CsrProcess

PKPROCESS CsrProcess

extern

Definition at line 39 of file videoprt.c.

Referenced by BaseClientConnectRoutine(), BaseClientDisconnectRoutine(), BaseSrvCleanupVDMResources(), ConsoleClientShutdown(), ConSrvConnect(), ConSrvDisconnect(), ConSrvSetProcessFocus(), CSR_API(), CsrAllocateProcess(), CsrAllocateThread(), CsrApiHandleConnectionRequest(), CsrApiRequestThread(), CsrCaptureArguments(), CsrCreateProcess(), CsrCreateRemoteThread(), CsrCreateThread(), CsrDeallocateProcess(), CsrDebugProcess(), CsrDebugProcessStop(), CsrDereferenceProcess(), CsrDestroyProcess(), CsrDestroyThread(), CsrInsertProcess(), CsrLocateThreadInProcess(), CsrLockedDereferenceProcess(), CsrLockedReferenceProcess(), CsrLockProcessByClientId(), CsrProcessRefcountZero(), CsrRemoveProcess(), CsrSbCreateSession(), CsrSetBackgroundPriority(), CsrSetForegroundPriority(), CsrShutdownProcesses(), CsrSrvAttachSharedSection(), CsrThreadRefcountZero(), CsrUnlockProcess(), FindProcessForShutdown(), IntAttachToCSRSS(), IntDetachFromCSRSS(), IntVideoPortDispatchDeviceControl(), IntVideoPortDispatchOpen(), NotifyConsoleProcessForShutdown(), NotifyUserProcessForShutdown(), ProtectLowV86Mem(), UnprotectLowV86Mem(), UserClientConnect(), UserClientShutdown(), VideoPortInt10(), and VideoPortWin32kCallout().

HwResetAdaptersList

LIST_ENTRY HwResetAdaptersList

extern

Referenced by IntVideoPortFindAdapter(), and IntVideoPortResetDisplayParametersEx().

HwResetAdaptersLock

KSPIN_LOCK HwResetAdaptersLock

extern

Definition at line 43 of file videoprt.c.

Referenced by IntVideoPortFindAdapter(), IntVideoPortResetDisplayParametersEx(), and VideoPortInitialize().

VideoPortDeviceNumber

ULONG VideoPortDeviceNumber

extern

VideoPortInt10Mutex

KMUTEX VideoPortInt10Mutex

extern

Definition at line 42 of file videoprt.c.

Referenced by IntInt10CallBios(), and VideoPortInitialize().

VideoPortUseNewKey

BOOLEAN VideoPortUseNewKey

extern

Definition at line 41 of file videoprt.c.

Referenced by IntCreateRegistryPath(), IntLoadRegistryParameters(), and IntVideoPortAddDeviceMapLink().