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)
BOOLEAN FASTCALL	IntAttachToCSRSS (_Outptr_ PKPROCESS *CallingProcess, _Out_ PKAPC_STATE ApcState)
	Attach the current thread to the CSRSS process. The caller must detach from the process by invoking IntDetachFromCSRSS() after operating in its context.
VOID FASTCALL	IntDetachFromCSRSS (_In_ PKPROCESS CallingProcess, _In_ PKAPC_STATE ApcState)
	Detach the current thread from the CSRSS process. This routine is to be invoked after a previous successful IntAttachToCSRSS() call.
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	IntInitializeInt10 (VOID)
VP_STATUS NTAPI	IntInt10AllocateBuffer (_In_ PVOID Context, _Out_ PUSHORT Seg, _Out_ PUSHORT Off, _Inout_ 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_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length)
VP_STATUS NTAPI	IntInt10WriteMemory (_In_ PVOID Context, _In_ USHORT Seg, _In_ USHORT Off, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length)
VP_STATUS NTAPI	IntInt10CallBios (_In_ PVOID Context, _Inout_ 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
KSPIN_LOCK	HwResetAdaptersLock
LIST_ENTRY	HwResetAdaptersList
KMUTEX	VgaSyncLock
PVIDEO_PORT_DEVICE_EXTENSION	VgaDeviceExtension
PVIDEO_ACCESS_RANGE	VgaRanges
ULONG	NumOfVgaRanges
KMUTEX	VideoPortInt10Mutex

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 139 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 145 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()

BOOLEAN FASTCALL IntAttachToCSRSS	(	_Outptr_ PKPROCESS *	CallingProcess,
		_Out_ PKAPC_STATE	ApcState
	)

Attach the current thread to the CSRSS process. The caller must detach from the process by invoking IntDetachFromCSRSS() after operating in its context.

Parameters

[out]	CallingProcess	Pointer to a PKPROCESS variable that receives the current process.
[out]	ApcState	Pointer to a caller-provided KAPC_STATE structure that will be initialized.

Returns

TRUE if attachment succeeded (the CSRSS process exists); FALSE if not.

Definition at line 736 of file videoprt.c.

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

Referenced by VideoPortGetRomImage().

IntCopyRegistryKey()

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

Definition at line 34 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 233 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 408 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, 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 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 to create key '%wZ', status 0x%lx\n",
                 &DeviceExtension->NewRegistryPath, Status);
            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 603 of file registry.c.

{
    static const WCHAR RegistryMachineSystem[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\";
    static const WCHAR CurrentControlSet[] = L"CURRENTCONTROLSET\\";
    static const WCHAR ControlSet[] = L"CONTROLSET";
    static const WCHAR Insert1[] = L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
    static const 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) &&
             _wcsnicmp(DriverRegistryPath->Buffer, RegistryMachineSystem,
                       CONST_STR_LEN(RegistryMachineSystem)) == 0);
    if (Valid)
    {
        AfterControlSet.Buffer += CONST_STR_LEN(RegistryMachineSystem);
        AfterControlSet.Length -= CONST_STR_SIZE(RegistryMachineSystem);
 
        /* Check if path contains CURRENTCONTROLSET */
        if (AfterControlSet.Length > sizeof(CurrentControlSet) &&
            _wcsnicmp(AfterControlSet.Buffer, CurrentControlSet, CONST_STR_LEN(CurrentControlSet)) == 0)
        {
            AfterControlSet.Buffer += CONST_STR_LEN(CurrentControlSet);
            AfterControlSet.Length -= CONST_STR_SIZE(CurrentControlSet);
        }
        /* Check if path contains CONTROLSETnum */
        else if (AfterControlSet.Length > sizeof(ControlSet) &&
                 _wcsnicmp(AfterControlSet.Buffer, ControlSet, CONST_STR_LEN(ControlSet)) == 0)
        {
            AfterControlSet.Buffer += CONST_STR_LEN(ControlSet);
            AfterControlSet.Length -= CONST_STR_SIZE(ControlSet);
            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 = (ULONG_PTR)AfterControlSet.Buffer - (ULONG_PTR)DriverRegistryPath->Buffer;
            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);
    }
 
    INFO_(VIDEOPRT, "Formatted registry key '%wZ' -> '%wZ'\n",
          DriverRegistryPath, DeviceRegistryPath);
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

IntDetachFromCSRSS()

VOID FASTCALL IntDetachFromCSRSS	(	_In_ PKPROCESS	CallingProcess,
		_In_ PKAPC_STATE	ApcState
	)

Detach the current thread from the CSRSS process. This routine is to be invoked after a previous successful IntAttachToCSRSS() call.

Parameters

[in]	CallingProcess	The calling process that previously invoked IntAttachToCSRSS().
[in]	ApcState	Pointer to the KAPC_STATE structure that was initialized by a previous IntAttachToCSRSS() call.

Definition at line 763 of file videoprt.c.

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

Referenced by VideoPortGetRomImage().

IntInitializeInt10()

NTSTATUS IntInitializeInt10

(

VOID

)

Definition at line 766 of file int10.c.

{
    static BOOLEAN FirstInitialization = FALSE;
 
    if (!FirstInitialization)
    {
        FirstInitialization = TRUE;
#ifdef _M_IX86
        /* Initialize the x86 emulator if necessary, otherwise fall back to V86 mode */
        if (!VideoPortDisableX86Emulator)
        {
            /* Use the emulation routines */
            //Int10Vtbl = &Int10IFace[0];
            if (IntInitializeX86Emu())
                return STATUS_SUCCESS;
            DPRINT1("Could not initialize the x86 emulator; falling back to V86 mode\n");
            VideoPortDisableX86Emulator = TRUE;
        }
 
        /* Fall back to the V86 routines */
        Int10Vtbl = &Int10IFace[1];
        return STATUS_SUCCESS;
#else
        /* Initialize the x86 emulator */
        return (IntInitializeX86Emu() ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED);
#endif
    }
 
    /* We should only do that for CSRSS */
    ASSERT(PsGetCurrentProcess() == (PEPROCESS)CsrProcess);
#ifdef _M_IX86
    return IntInitializeVideoAddressSpace();
#else
    return STATUS_SUCCESS;
#endif
}

Referenced by IntVideoPortDispatchOpen(), and VideoPortInitialize().

IntInt10AllocateBuffer()

VP_STATUS NTAPI IntInt10AllocateBuffer	(	_In_ PVOID	Context,
		_Out_ PUSHORT	Seg,
		_Out_ PUSHORT	Off,
		_Inout_ PULONG	Length
	)

Definition at line 375 of file int10.c.

{
    VP_STATUS Status;
 
    TRACE_(VIDEOPRT, "IntInt10AllocateBuffer\n");
 
    Status = INT10(AllocateBuffer)(Context, Seg, Off, Length);
    if (Status == NO_ERROR)
    {
        INFO_(VIDEOPRT, "- Segment: 0x%x\n", *Seg);
        INFO_(VIDEOPRT, "- Offset : 0x%x\n", *Off);
        INFO_(VIDEOPRT, "- Length : 0x%x\n", *Length);
    }
    return Status;
}

Referenced by VideoPortQueryServices().

IntInt10CallBios()

VP_STATUS NTAPI IntInt10CallBios	(	_In_ PVOID	Context,
		_Inout_ PINT10_BIOS_ARGUMENTS	BiosArguments
	)

Definition at line 737 of file int10.c.

{
    return INT10(CallBios)(Context, BiosArguments);
}

Referenced by VideoPortInt10(), and VideoPortQueryServices().

IntInt10FreeBuffer()

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

Definition at line 444 of file int10.c.

{
    TRACE_(VIDEOPRT, "IntInt10FreeBuffer\n");
    INFO_(VIDEOPRT, "- Segment: 0x%x\n", Seg);
    INFO_(VIDEOPRT, "- Offset : 0x%x\n", Off);
 
    return INT10(FreeBuffer)(Context, Seg, Off);
}

Referenced by VideoPortQueryServices().

IntInt10ReadMemory()

VP_STATUS NTAPI IntInt10ReadMemory	(	_In_ PVOID	Context,
		_In_ USHORT	Seg,
		_In_ USHORT	Off,
		_Out_writes_bytes_(Length) PVOID	Buffer,
		_In_ ULONG	Length
	)

Definition at line 507 of file int10.c.

{
    TRACE_(VIDEOPRT, "IntInt10ReadMemory\n");
    INFO_(VIDEOPRT, "- Segment: 0x%x\n", Seg);
    INFO_(VIDEOPRT, "- Offset : 0x%x\n", Off);
    INFO_(VIDEOPRT, "- Buffer : 0x%x\n", Buffer);
    INFO_(VIDEOPRT, "- Length : 0x%x\n", Length);
 
    return INT10(ReadMemory)(Context, Seg, Off, Buffer, Length);
}

Referenced by VideoPortQueryServices().

IntInt10WriteMemory()

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

Definition at line 574 of file int10.c.

{
    TRACE_(VIDEOPRT, "IntInt10WriteMemory\n");
    INFO_(VIDEOPRT, "- Segment: 0x%x\n", Seg);
    INFO_(VIDEOPRT, "- Offset : 0x%x\n", Off);
    INFO_(VIDEOPRT, "- Buffer : 0x%x\n", Buffer);
    INFO_(VIDEOPRT, "- Length : 0x%x\n", Length);
 
    return INT10(WriteMemory)(Context, Seg, Off, Buffer, Length);
}

Referenced by VideoPortQueryServices().

IntSetupDeviceSettingsKey()

NTSTATUS NTAPI IntSetupDeviceSettingsKey

(

PVIDEO_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 298 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 171 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;
    DeviceExtension->IsVgaDriver = IntIsVgaSaveDriver(DriverObject);
 
    InitializeListHead(&DeviceExtension->ChildDeviceList);
 
    /* 
     * Miniport owns this blob; many miniports assume it's initially zeroed.
     * Removing this crashes the NVIDIA GPU driver.
     */
    RtlZeroMemory(DeviceExtension->MiniPortDeviceExtension,
                  DriverExtension->InitializationData.HwDeviceExtensionSize);
 
    /* 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 1214 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 434 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 766 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:
            INFO_(VIDEOPRT, "- IOCTL_VIDEO_ENUM_MONITOR_PDO\n");
            Status = VideoPortEnumMonitorPdo(DeviceObject,
                                             Irp->AssociatedIrp.SystemBuffer,
                                             &Irp->IoStatus.Information);
            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 is from the CSRSS process.
         * Get a reference to it for Int10 support. */
        INFO_(VIDEOPRT, "Referencing CSRSS\n");
        CsrProcess = (PKPROCESS)PsGetCurrentProcess();
        ObReferenceObject(CsrProcess);
        INFO_(VIDEOPRT, "CsrProcess 0x%p\n", CsrProcess);
 
        Status = IntInitializeInt10();
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "IntInitializeInt10(CSR) 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 404 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 1200 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 1232 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 1266 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 1489 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    ULONG Status;
    VIDEO_CHILD_ENUM_INFO ChildEnumInfo;
    BOOLEAN bHaveLastMonitorID = FALSE;
    UCHAR LastMonitorID[10];
    ULONG Uid, 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,
                     &Uid,
                     &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 81 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 434 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;
    BOOLEAN VgaResourcesReleased = FALSE;
 
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    DeviceExtension->IsVgaDetect = DeviceExtension->IsVgaDriver;
    DeviceExtension->IsLegacyDetect = FALSE;
    DeviceExtension->ReportDevice = FALSE;
 
    /* 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;
        DeviceExtension->IsLegacyDevice = TRUE;
        DeviceExtension->IsLegacyDetect = TRUE;
    }
    else
    {
        DeviceExtension->IsLegacyDevice = FALSE;
    }
 
     /* If we already have a VGA miniport and are about to probe for additional adapters,
      * release its resources temporarily so conflicts are visible during detection.
      * We'll reclaim them later if no new adapter successfully claims them. */
    KeWaitForMutexObject(&VgaSyncLock, Executive, KernelMode, FALSE, NULL);
    if (VgaDeviceExtension)
    {
        INFO_(VIDEOPRT, "Temporarily releasing VGA resources for adapter probing\n");
        IntVideoPortReleaseResources(VgaDeviceExtension);
        VgaResourcesReleased = TRUE;
    }
    KeReleaseMutex(&VgaSyncLock, FALSE);
 
    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 failed (vpStatus=0x%X) bus=%u iface=%u legacy=%u vga=%u detect(VGA=%u LEGACY=%u)\n",
              vpStatus,
              DeviceExtension->SystemIoBusNumber,
              DeviceExtension->AdapterInterfaceType,
              DeviceExtension->IsLegacyDevice,
              DeviceExtension->IsVgaDriver,
              DeviceExtension->IsVgaDetect,
              DeviceExtension->IsLegacyDetect);
        /* If we released VGA resources, reclaim them so VGA fallback still works */
        if (VgaResourcesReleased)
        {
            if (VgaDeviceExtension && VgaRanges && NumOfVgaRanges)
            {
                INFO_(VIDEOPRT, "Reclaiming VGA resources after failed probe\n");
                if (VideoPortVerifyAccessRanges(&VgaDeviceExtension->MiniPortDeviceExtension,
                                                NumOfVgaRanges,
                                                VgaRanges) != NO_ERROR)
                {
                    WARN_(VIDEOPRT, "Failed to reclaim VGA resources after probe failure\n");
                }
            }
        }
        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);
    }
 
    if (DeviceExtension->IsVgaDriver)
    {
        KeWaitForMutexObject(&VgaSyncLock, Executive, KernelMode, FALSE, NULL);
        if (VgaDeviceExtension == NULL)
        {
            VgaDeviceExtension = DeviceExtension;
        }
        KeReleaseMutex(&VgaSyncLock, FALSE);
    }
 
    DeviceExtension->IsVgaDetect = FALSE;
    DeviceExtension->IsLegacyDetect = FALSE;
 
    /* For legacy (non-PnP) adapters we should report a detected device so that
     * a PDO exists for higher layers to enumerate consistently (mirrors ScsiPort).*/
    if (DeviceExtension->IsLegacyDevice && !DeviceExtension->ReportDevice)
    {
        PDEVICE_OBJECT ReportedPdo = NULL;
        NTSTATUS repStatus = IoReportDetectedDevice(DriverObject,
                                                    DeviceExtension->AdapterInterfaceType,
                                                    DeviceExtension->SystemIoBusNumber,
                                                    DeviceExtension->SystemIoSlotNumber,
                                                    NULL,
                                                    NULL,
                                                    FALSE,
                                                    &ReportedPdo);
        if (!NT_SUCCESS(repStatus))
        {
            WARN_(VIDEOPRT, "IoReportDetectedDevice failed 0x%08lx (bus=%u slot=%u)\n",
                  repStatus,
                  DeviceExtension->SystemIoBusNumber,
                  DeviceExtension->SystemIoSlotNumber);
        }
        else
        {
            INFO_(VIDEOPRT, "Reported legacy adapter PDO %p (bus=%u slot=%u)\n",
                  ReportedPdo,
                  DeviceExtension->SystemIoBusNumber,
                  DeviceExtension->SystemIoSlotNumber);
            DeviceExtension->ReportDevice = TRUE;
        }
    }
 
    /* Attempt to reclaim VGA resources after probing if a VGA device exists */
    if (VgaDeviceExtension && VgaRanges && NumOfVgaRanges)
    {
        VP_STATUS vr;
        INFO_(VIDEOPRT, "Attempt VGA reclaim after probe (ranges=%lu)\n", NumOfVgaRanges);
        vr = VideoPortVerifyAccessRanges(&VgaDeviceExtension->MiniPortDeviceExtension,
                                         NumOfVgaRanges,
                                         VgaRanges);
        if (vr != NO_ERROR)
        {
            /* Another driver has taken VGA resources; drop fallback state */
            WARN_(VIDEOPRT, "VGA reclaim failed (vpStatus=0x%X); releasing fallback state\n", vr);
            KeWaitForMutexObject(&VgaSyncLock, Executive, KernelMode, FALSE, NULL);
            ExFreePoolWithTag(VgaRanges, TAG_VIDEO_PORT);
            VgaRanges = NULL;
            NumOfVgaRanges = 0;
            VgaDeviceExtension = NULL;
            KeReleaseMutex(&VgaSyncLock, FALSE);
 
        }
        else
        {
            INFO_(VIDEOPRT, "VGA reclaim succeeded\n");
        }
    }
 
    INFO_(VIDEOPRT, "STATUS_SUCCESS\n");
    return STATUS_SUCCESS;
 
Failure:
    RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
    if (DeviceExtension->NextDeviceObject)
        IoDetachDevice(DeviceExtension->NextDeviceObject);
 
    /* Explicitly reclaim VGA resources on complete failure */
    if (VgaResourcesReleased)
    {
        if (VgaDeviceExtension && VgaRanges && NumOfVgaRanges)
        {
            INFO_(VIDEOPRT, "Final reclaim attempt of VGA resources during failure cleanup\n");
            if (VideoPortVerifyAccessRanges(&VgaDeviceExtension->MiniPortDeviceExtension,
                                            NumOfVgaRanges,
                                            VgaRanges) != NO_ERROR)
            {
                WARN_(VIDEOPRT, "VGA reclaim failed during failure cleanup\n");
            }
        }
    }
    IoDeleteDevice(DeviceObject);
    return Status;
}

Referenced by IntVideoPortPnPStartDevice(), and VideoPortInitialize().

IntVideoPortGetProcAddress()

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

Definition at line 106 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 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 244 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 198 of file resource.c.

{
    NTSTATUS Status;
    BOOLEAN ConflictDetected;
    // An empty CM_RESOURCE_LIST
    UCHAR EmptyResourceList[FIELD_OFFSET(CM_RESOURCE_LIST, List)] = {0};
 
    if (DeviceExtension->IsLegacyDevice || DeviceExtension->IsLegacyDetect || DeviceExtension->IsVgaDetect)
    {
        Status = IoReportResourceForDetection(
                    DeviceExtension->DriverObject,
                    NULL, 0, /* Driver List */
                    DeviceExtension->PhysicalDeviceObject,
                    (PCM_RESOURCE_LIST)EmptyResourceList,
                    sizeof(EmptyResourceList),
                    &ConflictDetected);
 
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT,
                 "VideoPortReleaseResources (Detect) failed with 0x%08lx ; ConflictDetected: %s\n",
                 Status, ConflictDetected ? "TRUE" : "FALSE");
        }
    }
    else
    {
        Status = IoReportResourceUsage(&VideoClassName,
                                       DeviceExtension->DriverObject,
                                       NULL,
                                       0,
                                       DeviceExtension->PhysicalDeviceObject,
                                       (PCM_RESOURCE_LIST)EmptyResourceList,
                                       sizeof(EmptyResourceList),
                                       FALSE,
                                       &ConflictDetected);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT,
                 "VideoPortReleaseResources (Usage) failed with 0x%08lx ; ConflictDetected: %s\n",
                 Status, ConflictDetected ? "TRUE" : "FALSE");
        }
    }
}

Referenced by IntVideoPortFindAdapter(), and 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 1288 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(), IntInitializeInt10(), IntVideoPortDispatchDeviceControl(), IntVideoPortDispatchOpen(), NotifyConsoleProcessForShutdown(), NotifyUserProcessForShutdown(), UserClientConnect(), UserClientShutdown(), 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().

NumOfVgaRanges

ULONG NumOfVgaRanges

extern

Definition at line 48 of file videoprt.c.

Referenced by IntVideoPortFindAdapter(), and VideoPortVerifyAccessRanges().

VgaDeviceExtension

PVIDEO_PORT_DEVICE_EXTENSION VgaDeviceExtension

extern

Definition at line 46 of file videoprt.c.

Referenced by IntVideoPortFindAdapter(), VbeSetMode(), and VideoPortVerifyAccessRanges().

VgaRanges

PVIDEO_ACCESS_RANGE VgaRanges

extern

Definition at line 47 of file videoprt.c.

Referenced by IntVideoPortFindAdapter(), and VideoPortVerifyAccessRanges().

VgaSyncLock

KMUTEX VgaSyncLock

extern

Definition at line 45 of file videoprt.c.

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

VideoPortDeviceNumber

ULONG VideoPortDeviceNumber

extern

VideoPortInt10Mutex

KMUTEX VideoPortInt10Mutex

extern

Definition at line 41 of file int10.c.

Referenced by IntInt10CallBiosEmu(), and VideoPortInitialize().

VideoPortUseNewKey

BOOLEAN VideoPortUseNewKey

extern

Definition at line 41 of file videoprt.c.

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