videoprt.c File Reference

#include "videoprt.h"
#include <stdio.h>
#include <ndk/exfuncs.h>
#include <ndk/obfuncs.h>
#include <ndk/rtlfuncs.h>
#include <debug.h>

Include dependency graph for videoprt.c:

Go to the source code of this file.

Classes
struct	QueryRegistryCallbackContext

Macros
#define	NDEBUG

Typedefs
typedef struct QueryRegistryCallbackContext	QUERY_REGISTRY_CALLBACK_CONTEXT
typedef struct QueryRegistryCallbackContext *	PQUERY_REGISTRY_CALLBACK_CONTEXT

Functions
	RTL_STATIC_LIST_HEAD (HwResetAdaptersList)
ULONG NTAPI	DriverEntry (IN PVOID Context1, IN PVOID Context2)
static NTSTATUS	IntVideoPortAddDeviceMapLink (PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
PVOID NTAPI	IntVideoPortImageDirectoryEntryToData (PVOID BaseAddress, ULONG Directory)
VOID NTAPI	IntVideoPortDeferredRoutine (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
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)
VOID FASTCALL	IntAttachToCSRSS (PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
VOID FASTCALL	IntDetachFromCSRSS (PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
VOID FASTCALL	IntLoadRegistryParameters (VOID)
ULONG NTAPI	VideoPortInitialize (IN PVOID Context1, IN PVOID Context2, IN PVIDEO_HW_INITIALIZATION_DATA HwInitializationData, IN PVOID HwContext)
VOID	VideoPortDebugPrint (IN VIDEO_DEBUG_LEVEL DebugPrintLevel, IN PCHAR DebugMessage,...)
VOID NTAPI	VideoPortLogError (IN PVOID HwDeviceExtension, IN PVIDEO_REQUEST_PACKET Vrp OPTIONAL, IN VP_STATUS ErrorCode, IN ULONG UniqueId)
UCHAR NTAPI	VideoPortGetCurrentIrql (VOID)
static NTSTATUS NTAPI	QueryRegistryCallback (IN PWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData, IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
VP_STATUS NTAPI	VideoPortGetRegistryParameters (IN PVOID HwDeviceExtension, IN PWSTR ParameterName, IN UCHAR IsParameterFileName, IN PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine, IN PVOID HwContext)
VP_STATUS NTAPI	VideoPortSetRegistryParameters (IN PVOID HwDeviceExtension, IN PWSTR ValueName, IN PVOID ValueData, IN ULONG ValueLength)
VP_STATUS NTAPI	VideoPortGetVgaStatus (IN PVOID HwDeviceExtension, OUT PULONG VgaStatus)
PVOID NTAPI	VideoPortGetRomImage (IN PVOID HwDeviceExtension, IN PVOID Unused1, IN ULONG Unused2, IN ULONG Length)
BOOLEAN NTAPI	VideoPortScanRom (IN PVOID HwDeviceExtension, IN PUCHAR RomBase, IN ULONG RomLength, IN PUCHAR String)
BOOLEAN NTAPI	VideoPortSynchronizeExecution (IN PVOID HwDeviceExtension, IN VIDEO_SYNCHRONIZE_PRIORITY Priority, IN PMINIPORT_SYNCHRONIZE_ROUTINE SynchronizeRoutine, OUT PVOID Context)
NTSTATUS NTAPI	IntVideoPortEnumerateChildren (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VP_STATUS NTAPI	VideoPortEnumerateChildren (IN PVOID HwDeviceExtension, IN PVOID Reserved)
VP_STATUS NTAPI	VideoPortCreateSecondaryDisplay (IN PVOID HwDeviceExtension, IN OUT PVOID *SecondaryDeviceExtension, IN ULONG Flag)
BOOLEAN NTAPI	VideoPortQueueDpc (IN PVOID HwDeviceExtension, IN PMINIPORT_DPC_ROUTINE CallbackRoutine, IN PVOID Context)
PVOID NTAPI	VideoPortGetAssociatedDeviceExtension (IN PVOID DeviceObject)
VP_STATUS NTAPI	VideoPortGetVersion (IN PVOID HwDeviceExtension, IN OUT PVPOSVERSIONINFO VpOsVersionInfo)
BOOLEAN NTAPI	VideoPortCheckForDeviceExistence (IN PVOID HwDeviceExtension, IN USHORT VendorId, IN USHORT DeviceId, IN UCHAR RevisionId, IN USHORT SubVendorId, IN USHORT SubSystemId, IN ULONG Flags)
VP_STATUS NTAPI	VideoPortRegisterBugcheckCallback (IN PVOID HwDeviceExtension, IN ULONG BugcheckCode, IN PVIDEO_BUGCHECK_CALLBACK Callback, IN ULONG BugcheckDataSize)
LONGLONG NTAPI	VideoPortQueryPerformanceCounter (IN PVOID HwDeviceExtension, OUT PLONGLONG PerformanceFrequency OPTIONAL)
VOID NTAPI	VideoPortAcquireDeviceLock (IN PVOID HwDeviceExtension)
VOID NTAPI	VideoPortReleaseDeviceLock (IN PVOID HwDeviceExtension)
VOID NTAPI	VpNotifyEaData (IN PDEVICE_OBJECT DeviceObject, IN PVOID Data)
PVOID NTAPI	VideoPortAllocateContiguousMemory (IN PVOID HwDeviceExtension, IN ULONG NumberOfBytes, IN PHYSICAL_ADDRESS HighestAcceptableAddress)
BOOLEAN NTAPI	VideoPortIsNoVesa (VOID)

Variables
ULONG	VideoDebugLevel = 0
BOOLEAN	VpBaseVideo = FALSE
BOOLEAN	VpNoVesa = FALSE
PKPROCESS	CsrProcess = NULL
static ULONG	VideoPortMaxObjectNumber = -1
KMUTEX	VideoPortInt10Mutex
KSPIN_LOCK	HwResetAdaptersLock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file videoprt.c.

Typedef Documentation

PQUERY_REGISTRY_CALLBACK_CONTEXT

typedef struct QueryRegistryCallbackContext * PQUERY_REGISTRY_CALLBACK_CONTEXT

QUERY_REGISTRY_CALLBACK_CONTEXT

typedef struct QueryRegistryCallbackContext QUERY_REGISTRY_CALLBACK_CONTEXT

Function Documentation

DriverEntry()

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

Definition at line 49 of file videoprt.c.

{
    return STATUS_SUCCESS;
}

IntAttachToCSRSS()

VOID FASTCALL IntAttachToCSRSS	(	PKPROCESS *	CallingProcess,
		PKAPC_STATE	ApcState
	)

Definition at line 490 of file videoprt.c.

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

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

IntDetachFromCSRSS()

VOID FASTCALL IntDetachFromCSRSS	(	PKPROCESS *	CallingProcess,
		PKAPC_STATE	ApcState
	)

Definition at line 503 of file videoprt.c.

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

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

IntLoadRegistryParameters()

VOID FASTCALL IntLoadRegistryParameters

(

VOID

)

Definition at line 515 of file videoprt.c.

{
    NTSTATUS Status;
    HANDLE KeyHandle;
    UNICODE_STRING Path = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control");
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SystemStartOptions");
    OBJECT_ATTRIBUTES ObjectAttributes;
    PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
    ULONG Length, NewLength;

    /* Initialize object attributes with the path we want */
    InitializeObjectAttributes(&ObjectAttributes,
                               &Path,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);

    /* Open the key */
    Status = ZwOpenKey(&KeyHandle,
                       KEY_QUERY_VALUE,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        VideoPortDebugPrint(Error, "ZwOpenKey failed (0x%x)\n", Status);
        return;
    }

    /* Find out how large our buffer should be */
    Status = ZwQueryValueKey(KeyHandle,
                             &ValueName,
                             KeyValuePartialInformation,
                             NULL,
                             0,
                             &Length);
    if (Status != STATUS_BUFFER_OVERFLOW && Status != STATUS_BUFFER_TOO_SMALL)
    {
        VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
        ObCloseHandle(KeyHandle, KernelMode);
        return;
    }

    /* Allocate it */
    KeyInfo = ExAllocatePoolWithTag(PagedPool, Length, TAG_VIDEO_PORT);
    if (!KeyInfo)
    {
        VideoPortDebugPrint(Error, "Out of memory\n");
        ObCloseHandle(KeyHandle, KernelMode);
        return;
    }

    /* Now for real this time */
    Status = ZwQueryValueKey(KeyHandle,
                             &ValueName,
                             KeyValuePartialInformation,
                             KeyInfo,
                             Length,
                             &NewLength);
    ObCloseHandle(KeyHandle, KernelMode);

    if (!NT_SUCCESS(Status))
    {
        VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
        ExFreePoolWithTag(KeyInfo, TAG_VIDEO_PORT);
        return;
    }

    /* Sanity check */
    if (KeyInfo->Type != REG_SZ)
    {
        VideoPortDebugPrint(Error, "Invalid type for SystemStartOptions\n");
        ExFreePoolWithTag(KeyInfo, TAG_VIDEO_PORT);
        return;
    }

    /* Check if BASEVIDEO or NOVESA is present in the start options */
    if (wcsstr((PWCHAR)KeyInfo->Data, L"BASEVIDEO"))
        VpBaseVideo = TRUE;
    if (wcsstr((PWCHAR)KeyInfo->Data, L"NOVESA"))
        VpNoVesa = TRUE;

    ExFreePoolWithTag(KeyInfo, TAG_VIDEO_PORT);

    /* FIXME: Old ReactOS-compatibility... */
    if (VpBaseVideo) VpNoVesa = TRUE;

    if (VpNoVesa)
        VideoPortDebugPrint(Info, "VESA mode disabled\n");
    else
        VideoPortDebugPrint(Info, "VESA mode enabled\n");

    /* If we are in BASEVIDEO, create the volatile registry key for Win32k */
    if (VpBaseVideo)
    {
        RtlInitUnicodeString(&Path, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\GraphicsDrivers\\BaseVideo");

        InitializeObjectAttributes(&ObjectAttributes,
                                   &Path,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL);

        Status = ZwCreateKey(&KeyHandle,
                             READ_CONTROL, // Non-0 placeholder: no use for this handle.
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_VOLATILE,
                             NULL);
        if (NT_SUCCESS(Status))
            ObCloseHandle(KeyHandle, KernelMode);
        else
            ERR_(VIDEOPRT, "Failed to create the BaseVideo key (0x%x)\n", Status);
    }

    return;
}

Referenced by VideoPortInitialize().

IntVideoPortAddDeviceMapLink()

static NTSTATUS IntVideoPortAddDeviceMapLink ( PVIDEO_PORT_DEVICE_EXTENSION  DeviceExtension )

static

Definition at line 58 of file videoprt.c.

{
    WCHAR DeviceBuffer[20];
    UNICODE_STRING DeviceName;
    WCHAR SymlinkBuffer[20];
    UNICODE_STRING SymlinkName;
    ULONG DeviceNumber;
    NTSTATUS Status;

    /* Create a unicode device name. */
    DeviceNumber = DeviceExtension->DeviceNumber;
    swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);

    /* Add entry to DEVICEMAP\VIDEO key in registry. */
    Status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP,
                                   L"VIDEO",
                                   DeviceBuffer,
                                   REG_SZ,
                                   DeviceExtension->NewRegistryPath.Buffer,
                                   DeviceExtension->NewRegistryPath.Length + sizeof(UNICODE_NULL));
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "Failed to create DEViCEMAP registry entry: 0x%X\n", Status);
        return Status;
    }

    Status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP,
                                   L"VIDEO",
                                   L"MaxObjectNumber",
                                   REG_DWORD,
                                   &DeviceNumber,
                                   sizeof(DeviceNumber));
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "Failed to write MaxObjectNumber: 0x%X\n", Status);
        return Status;
    }

    /* Create symbolic link "\??\DISPLAYx" */
    swprintf(SymlinkBuffer, L"\\??\\DISPLAY%lu", DeviceNumber + 1);
    RtlInitUnicodeString(&SymlinkName, SymlinkBuffer);
    RtlInitUnicodeString(&DeviceName, DeviceBuffer);
    Status = IoCreateSymbolicLink(&SymlinkName, &DeviceName);
    if (!NT_SUCCESS(Status))
    {
        ERR_(VIDEOPRT, "Failed to create symbolic link: 0x%X\n", Status);
        return Status;
    }

    /* Update MaxObjectNumber */
    VideoPortMaxObjectNumber = DeviceNumber;

    return STATUS_SUCCESS;
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

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 152 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    ULONG DeviceNumber;
    ULONG PciSlotNumber;
    PCI_SLOT_NUMBER SlotNumber;
    ULONG Size;
    NTSTATUS Status;
    WCHAR DeviceBuffer[20];
    UNICODE_STRING DeviceName;
    PDEVICE_OBJECT DeviceObject_;

    if (DeviceObject == NULL)
        DeviceObject = &DeviceObject_;

    /*
     * Find the first free device number that can be used for video device
     * object names and symlinks.
     */
    DeviceNumber = VideoPortMaxObjectNumber + 1;
    if (DeviceNumber == (ULONG)-1)
    {
        WARN_(VIDEOPRT, "Can't find free device number\n");
        return STATUS_UNSUCCESSFUL;
    }

    /*
     * Create the device object.
     */

    /* Create a unicode device name. */
    swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
    RtlInitUnicodeString(&DeviceName, DeviceBuffer);

    INFO_(VIDEOPRT, "HwDeviceExtension size is: 0x%x\n",
          DriverExtension->InitializationData.HwDeviceExtensionSize);

    /* Create the device object. */
    Size = sizeof(VIDEO_PORT_DEVICE_EXTENSION) +
        DriverExtension->InitializationData.HwDeviceExtensionSize;
    Status = IoCreateDevice(DriverObject,
                            Size,
                            &DeviceName,
                            FILE_DEVICE_VIDEO,
                            0,
                            TRUE,
                            DeviceObject);

    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "IoCreateDevice call failed with status 0x%08x\n", Status);
        return Status;
    }

    /*
     * Set the buffering strategy here. If you change this, remember
     * to change VidDispatchDeviceControl too.
     */

    (*DeviceObject)->Flags |= DO_BUFFERED_IO;

    /* Initialize device extension. */
    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)((*DeviceObject)->DeviceExtension);
    DeviceExtension->Common.Fdo = TRUE;
    DeviceExtension->DeviceNumber = DeviceNumber;
    DeviceExtension->DriverObject = DriverObject;
    DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
    DeviceExtension->FunctionalDeviceObject = *DeviceObject;
    DeviceExtension->DriverExtension = DriverExtension;
    DeviceExtension->SessionId = -1;
    DeviceExtension->AdapterNumber = AdapterNumber;
    DeviceExtension->DisplayNumber = DisplayNumber;

    InitializeListHead(&DeviceExtension->ChildDeviceList);

    /* Get the registry path associated with this device. */
    Status = IntCreateRegistryPath(&DriverExtension->RegistryPath,
                                   DeviceExtension->AdapterNumber,
                                   &DeviceExtension->RegistryPath);
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "IntCreateRegistryPath() call failed with status 0x%08x\n", Status);
        IoDeleteDevice(*DeviceObject);
        *DeviceObject = NULL;
        return Status;
    }

    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);
        IoDeleteDevice(*DeviceObject);
        *DeviceObject = NULL;
        return Status;
    }

    IntSetupDeviceSettingsKey(DeviceExtension);

    /* Remove the initailizing 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);
        IoDeleteDevice(*DeviceObject);
        *DeviceObject = NULL;
        return Status;
    }

    if (DisplayNumber == 0)
    {
        DriverExtension->InitializationData.StartingDeviceNumber++;
    }

    return STATUS_SUCCESS;
}

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

IntVideoPortDeferredRoutine()

VOID NTAPI IntVideoPortDeferredRoutine	(	IN PKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 139 of file videoprt.c.

{
    PVOID HwDeviceExtension =
        &((PVIDEO_PORT_DEVICE_EXTENSION)DeferredContext)->MiniPortDeviceExtension;
    ((PMINIPORT_DPC_ROUTINE)SystemArgument1)(HwDeviceExtension, SystemArgument2);
}

Referenced by IntVideoPortCreateAdapterDeviceObject().

IntVideoPortEnumerateChildren()

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

Definition at line 1171 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    ULONG Status;
    VIDEO_CHILD_ENUM_INFO ChildEnumInfo;
    BOOLEAN bHaveLastMonitorID = FALSE;
    UCHAR LastMonitorID[10];
    ULONG Unused;
    UINT i;
    PDEVICE_OBJECT ChildDeviceObject;
    PVIDEO_PORT_CHILD_EXTENSION ChildExtension;

    INFO_(VIDEOPRT, "Starting child device probe\n");
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor == NULL)
    {
        WARN_(VIDEOPRT, "Miniport's HwGetVideoChildDescriptor is NULL!\n");
        return STATUS_SUCCESS;
    }

    if (!IsListEmpty(&DeviceExtension->ChildDeviceList))
    {
        ERR_(VIDEOPRT, "FIXME: Support calling VideoPortEnumerateChildren again!\n");
        return STATUS_SUCCESS;
    }

    /* Enumerate the children */
    for (i = 1; ; i++)
    {
        Status = IoCreateDevice(DeviceExtension->DriverObject,
                                sizeof(VIDEO_PORT_CHILD_EXTENSION) +
                                DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize,
                                NULL,
                                FILE_DEVICE_CONTROLLER,
                                FILE_DEVICE_SECURE_OPEN,
                                FALSE,
                                &ChildDeviceObject);
        if (!NT_SUCCESS(Status))
            return Status;

        ChildExtension = ChildDeviceObject->DeviceExtension;

        RtlZeroMemory(ChildExtension,
                      sizeof(VIDEO_PORT_CHILD_EXTENSION) +
                        DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize);

        ChildExtension->Common.Fdo = FALSE;
        ChildExtension->ChildId = i;
        ChildExtension->PhysicalDeviceObject = ChildDeviceObject;
        ChildExtension->DriverObject = DeviceExtension->DriverObject;

        /* Setup the ChildEnumInfo */
        ChildEnumInfo.Size = sizeof(ChildEnumInfo);
        ChildEnumInfo.ChildDescriptorSize = sizeof(ChildExtension->ChildDescriptor);
        ChildEnumInfo.ACPIHwId = 0;

        if (DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize)
            ChildEnumInfo.ChildHwDeviceExtension = VIDEO_PORT_GET_CHILD_EXTENSION(ChildExtension);
        else
            ChildEnumInfo.ChildHwDeviceExtension = NULL;

        ChildEnumInfo.ChildIndex = ChildExtension->ChildId;

        INFO_(VIDEOPRT, "Probing child: %d\n", ChildEnumInfo.ChildIndex);
        Status = DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor(
                     DeviceExtension->MiniPortDeviceExtension,
                     &ChildEnumInfo,
                     &ChildExtension->ChildType,
                     ChildExtension->ChildDescriptor,
                     &ChildExtension->ChildId,
                     &Unused);
        if (Status == VIDEO_ENUM_MORE_DEVICES)
        {
            if (ChildExtension->ChildType == Monitor)
            {
                // Check if the EDID is valid
                if (ChildExtension->ChildDescriptor[0] == 0x00 &&
                        ChildExtension->ChildDescriptor[1] == 0xFF &&
                        ChildExtension->ChildDescriptor[2] == 0xFF &&
                        ChildExtension->ChildDescriptor[3] == 0xFF &&
                        ChildExtension->ChildDescriptor[4] == 0xFF &&
                        ChildExtension->ChildDescriptor[5] == 0xFF &&
                        ChildExtension->ChildDescriptor[6] == 0xFF &&
                        ChildExtension->ChildDescriptor[7] == 0x00)
                {
                    if (bHaveLastMonitorID)
                    {
                        // Compare the previous monitor ID with the current one, break the loop if they are identical
                        if (RtlCompareMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID)) == sizeof(LastMonitorID))
                        {
                            INFO_(VIDEOPRT, "Found identical Monitor ID two times, stopping enumeration\n");
                            IoDeleteDevice(ChildDeviceObject);
                            break;
                        }
                    }

                    // Copy 10 bytes from the EDID, which can be used to uniquely identify the monitor
                    RtlCopyMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID));
                    bHaveLastMonitorID = TRUE;

                    /* Mark it valid */
                    ChildExtension->EdidValid = TRUE;
                }
                else
                {
                    /* Mark it invalid */
                    ChildExtension->EdidValid = FALSE;
                }
            }
        }
        else if (Status == VIDEO_ENUM_INVALID_DEVICE)
        {
            WARN_(VIDEOPRT, "Child device %d is invalid!\n", ChildEnumInfo.ChildIndex);
            IoDeleteDevice(ChildDeviceObject);
            continue;
        }
        else if (Status == VIDEO_ENUM_NO_MORE_DEVICES)
        {
            INFO_(VIDEOPRT, "End of child enumeration! (%d children enumerated)\n", i - 1);
            IoDeleteDevice(ChildDeviceObject);
            break;
        }
        else
        {
            WARN_(VIDEOPRT, "HwGetVideoChildDescriptor returned unknown status code 0x%x!\n", Status);
            IoDeleteDevice(ChildDeviceObject);
            break;
        }

        if (ChildExtension->ChildType == Monitor)
        {
            UINT j;
            PUCHAR p = ChildExtension->ChildDescriptor;
            INFO_(VIDEOPRT, "Monitor device enumerated! (ChildId = 0x%x)\n", ChildExtension->ChildId);
            for (j = 0; j < sizeof (ChildExtension->ChildDescriptor); j += 8)
            {
                INFO_(VIDEOPRT, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
                      p[j + 0], p[j + 1], p[j + 2], p[j + 3],
                      p[j + 4], p[j + 5], p[j + 6], p[j + 7]);
            }
        }
        else if (ChildExtension->ChildType == Other)
        {
            INFO_(VIDEOPRT, "\"Other\" device enumerated: DeviceId = %S\n", (PWSTR)ChildExtension->ChildDescriptor);
        }
        else
        {
            ERR_(VIDEOPRT, "HwGetVideoChildDescriptor returned unsupported type: %d\n", ChildExtension->ChildType);
        }

        /* Clear the init flag */
        ChildDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

        InsertTailList(&DeviceExtension->ChildDeviceList,
                       &ChildExtension->ListEntry);
    }

    return STATUS_SUCCESS;
}

Referenced by IntVideoPortQueryBusRelations().

IntVideoPortFindAdapter()

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

Definition at line 341 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    VP_STATUS vpStatus;
    VIDEO_PORT_CONFIG_INFO ConfigInfo;
    SYSTEM_BASIC_INFORMATION SystemBasicInfo;
    UCHAR Again = FALSE;
    BOOL LegacyDetection = FALSE;

    DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

    /* Setup a ConfigInfo structure that we will pass to HwFindAdapter. */
    RtlZeroMemory(&ConfigInfo, sizeof(VIDEO_PORT_CONFIG_INFO));
    ConfigInfo.Length = sizeof(VIDEO_PORT_CONFIG_INFO);
    ConfigInfo.AdapterInterfaceType = DeviceExtension->AdapterInterfaceType;
    if (ConfigInfo.AdapterInterfaceType == PCIBus)
        ConfigInfo.InterruptMode = LevelSensitive;
    else
        ConfigInfo.InterruptMode = Latched;
    ConfigInfo.DriverRegistryPath = DriverExtension->RegistryPath.Buffer;
    ConfigInfo.VideoPortGetProcAddress = IntVideoPortGetProcAddress;
    ConfigInfo.SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
    ConfigInfo.BusInterruptLevel = DeviceExtension->InterruptLevel;
    ConfigInfo.BusInterruptVector = DeviceExtension->InterruptVector;

    Status = ZwQuerySystemInformation(SystemBasicInformation,
                                      &SystemBasicInfo,
                                      sizeof(SystemBasicInfo),
                                      NULL);
    if (NT_SUCCESS(Status))
    {
        ConfigInfo.SystemMemorySize = SystemBasicInfo.NumberOfPhysicalPages *
                                      SystemBasicInfo.PageSize;
    }

    // FIXME: Check the adapter key and update VideoDebugLevel variable.

    /*
     * Call miniport HwVidFindAdapter entry point to detect if
     * particular device is present. There are two possible code
     * paths. The first one is for Legacy drivers (NT4) and cases
     * when we don't have information about what bus we're on. The
     * second case is the standard one for Plug & Play drivers.
     */
    if (DeviceExtension->PhysicalDeviceObject == NULL)
    {
        LegacyDetection = TRUE;
    }

    if (LegacyDetection)
    {
        ULONG BusNumber, MaxBuses;

        MaxBuses = DeviceExtension->AdapterInterfaceType == PCIBus ? PCI_MAX_BRIDGE_NUMBER : 1;

        for (BusNumber = 0; BusNumber < MaxBuses; BusNumber++)
        {
            DeviceExtension->SystemIoBusNumber =
                ConfigInfo.SystemIoBusNumber = BusNumber;

            RtlZeroMemory(&DeviceExtension->MiniPortDeviceExtension,
                          DriverExtension->InitializationData.HwDeviceExtensionSize);

            /* 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 == ERROR_DEV_NOT_EXIST)
            {
                continue;
            }
            else
            {
                break;
            }
        }
    }
    else
    {
        /* FIXME: Need to figure out what string to pass as param 3. */
        vpStatus = DriverExtension->InitializationData.HwFindAdapter(
                     &DeviceExtension->MiniPortDeviceExtension,
                     DriverExtension->HwContext,
                     NULL,
                     &ConfigInfo,
                     &Again);
    }

    if (vpStatus != NO_ERROR)
    {
        ERR_(VIDEOPRT, "HwFindAdapter call failed with error 0x%X\n", vpStatus);
        Status = STATUS_UNSUCCESSFUL;
        goto Failure;
    }

    /*
     * Now we know the device is present, so let's do all additional tasks
     * such as creating symlinks or setting up interrupts and timer.
     */

    /* FIXME: Allocate hardware resources for device. */

    /* Allocate interrupt for device. */
    if (!IntVideoPortSetupInterrupt(DeviceObject, DriverExtension, &ConfigInfo))
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }

    /* Allocate timer for device. */
    if (!IntVideoPortSetupTimer(DeviceObject, DriverExtension))
    {
        if (DeviceExtension->InterruptObject != NULL)
            IoDisconnectInterrupt(DeviceExtension->InterruptObject);
        ERR_(VIDEOPRT, "IntVideoPortSetupTimer failed\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }

    /* If the device can be reset, insert it in the list of resettable adapters */
    InitializeListHead(&DeviceExtension->HwResetListEntry);
    if (DriverExtension->InitializationData.HwResetHw != NULL)
    {
        ExInterlockedInsertTailList(&HwResetAdaptersList,
                                    &DeviceExtension->HwResetListEntry,
                                    &HwResetAdaptersLock);
    }

    INFO_(VIDEOPRT, "STATUS_SUCCESS\n");
    return STATUS_SUCCESS;

Failure:
    RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
    if (DeviceExtension->NextDeviceObject)
        IoDetachDevice(DeviceExtension->NextDeviceObject);
    IoDeleteDevice(DeviceObject);
    return Status;
}

Referenced by IntVideoPortPnPStartDevice(), and VideoPortInitialize().

IntVideoPortImageDirectoryEntryToData()

PVOID NTAPI IntVideoPortImageDirectoryEntryToData	(	PVOID	BaseAddress,
		ULONG	Directory
	)

Definition at line 116 of file videoprt.c.

{
    PIMAGE_NT_HEADERS NtHeader;
    ULONG Va;

    NtHeader = RtlImageNtHeader(BaseAddress);
    if (NtHeader == NULL)
        return NULL;

    if (Directory >= NtHeader->OptionalHeader.NumberOfRvaAndSizes)
        return NULL;

    Va = NtHeader->OptionalHeader.DataDirectory[Directory].VirtualAddress;
    if (Va == 0)
        return NULL;

    return (PVOID)((ULONG_PTR)BaseAddress + Va);
}

QueryRegistryCallback()

static NTSTATUS NTAPI QueryRegistryCallback ( IN PWSTR  ValueName, IN ULONG  ValueType, IN PVOID  ValueData, IN ULONG  ValueLength, IN PVOID  Context, IN PVOID  EntryContext  )

static

Definition at line 895 of file videoprt.c.

{
    PQUERY_REGISTRY_CALLBACK_CONTEXT CallbackContext = (PQUERY_REGISTRY_CALLBACK_CONTEXT) Context;

    INFO_(VIDEOPRT, "Found registry value for name %S: type %d, length %d\n",
          ValueName, ValueType, ValueLength);
    return (*(CallbackContext->HwGetRegistryRoutine))(
               CallbackContext->HwDeviceExtension,
               CallbackContext->HwContext,
               ValueName,
               ValueData,
               ValueLength);
}

Referenced by VideoPortGetRegistryParameters().

RTL_STATIC_LIST_HEAD()

RTL_STATIC_LIST_HEAD

(

HwResetAdaptersList

)

VideoPortAcquireDeviceLock()

VOID NTAPI VideoPortAcquireDeviceLock

(

IN PVOID

HwDeviceExtension

)

Definition at line 1571 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;

    TRACE_(VIDEOPRT, "VideoPortAcquireDeviceLock\n");
    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    KeWaitForMutexObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
    // ASSERT(Status == STATUS_SUCCESS);
}

VideoPortAllocateContiguousMemory()

PVOID NTAPI VideoPortAllocateContiguousMemory	(	IN PVOID	HwDeviceExtension,
		IN ULONG	NumberOfBytes,
		IN PHYSICAL_ADDRESS	HighestAcceptableAddress
	)

Definition at line 1615 of file videoprt.c.

{
    return MmAllocateContiguousMemory(NumberOfBytes, HighestAcceptableAddress);
}

VideoPortCheckForDeviceExistence()

BOOLEAN NTAPI VideoPortCheckForDeviceExistence	(	IN PVOID	HwDeviceExtension,
		IN USHORT	VendorId,
		IN USHORT	DeviceId,
		IN UCHAR	RevisionId,
		IN USHORT	SubVendorId,
		IN USHORT	SubSystemId,
		IN ULONG	Flags
	)

Definition at line 1479 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    PCI_DEVICE_PRESENT_INTERFACE PciDevicePresentInterface;
    IO_STATUS_BLOCK IoStatusBlock;
    IO_STACK_LOCATION IoStack;
    ULONG PciFlags = 0;
    NTSTATUS Status;
    BOOL DevicePresent;

    TRACE_(VIDEOPRT, "VideoPortCheckForDeviceExistence\n");

    if (Flags & ~(CDE_USE_REVISION | CDE_USE_SUBSYSTEM_IDS))
    {
        WARN_(VIDEOPRT, "VideoPortCheckForDeviceExistence: Unknown flags 0x%lx\n", Flags & ~(CDE_USE_REVISION | CDE_USE_SUBSYSTEM_IDS));
        return FALSE;
    }

    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);

    PciDevicePresentInterface.Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
    PciDevicePresentInterface.Version = 1;
    IoStack.Parameters.QueryInterface.Size = PciDevicePresentInterface.Size;
    IoStack.Parameters.QueryInterface.Version = PciDevicePresentInterface.Version;
    IoStack.Parameters.QueryInterface.Interface = (PINTERFACE)&PciDevicePresentInterface;
    IoStack.Parameters.QueryInterface.InterfaceType =
        &GUID_PCI_DEVICE_PRESENT_INTERFACE;
    Status = IopInitiatePnpIrp(DeviceExtension->NextDeviceObject,
                               &IoStatusBlock, IRP_MN_QUERY_INTERFACE, &IoStack);
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "IopInitiatePnpIrp() failed! (Status 0x%lx)\n", Status);
        return FALSE;
    }

    if (Flags & CDE_USE_REVISION)
        PciFlags |= PCI_USE_REVISION;
    if (Flags & CDE_USE_SUBSYSTEM_IDS)
        PciFlags |= PCI_USE_SUBSYSTEM_IDS;

    DevicePresent = PciDevicePresentInterface.IsDevicePresent(
                        VendorId, DeviceId, RevisionId,
                        SubVendorId, SubSystemId, PciFlags);

    PciDevicePresentInterface.InterfaceDereference(PciDevicePresentInterface.Context);

    return DevicePresent;
}

VideoPortCreateSecondaryDisplay()

VP_STATUS NTAPI VideoPortCreateSecondaryDisplay	(	IN PVOID	HwDeviceExtension,
		IN OUT PVOID *	SecondaryDeviceExtension,
		IN ULONG	Flag
	)

Definition at line 1358 of file videoprt.c.

{
    PDEVICE_OBJECT DeviceObject;
    PVIDEO_PORT_DEVICE_EXTENSION FirstDeviceExtension, DeviceExtension;
    NTSTATUS Status;

    ASSERT(SecondaryDeviceExtension);

    if (Flag != 0)
    {
        UNIMPLEMENTED;
    }

    FirstDeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);

    if (FirstDeviceExtension->DisplayNumber != 0)
    {
        DPRINT1("Calling VideoPortCreateSecondaryDisplay for InstanceId %lu\n",
                FirstDeviceExtension->DisplayNumber);
    }

    Status = IntVideoPortCreateAdapterDeviceObject(FirstDeviceExtension->DriverObject,
                                                   FirstDeviceExtension->DriverExtension,
                                                   FirstDeviceExtension->PhysicalDeviceObject,
                                                   FirstDeviceExtension->AdapterNumber,
                                                   FirstDeviceExtension->NumberOfSecondaryDisplays + 1,
                                                   &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IntVideoPortCreateAdapterDeviceObject() failed with status 0x%08x\n", Status);
        return ERROR_DEV_NOT_EXIST;
    }

    DeviceExtension = DeviceObject->DeviceExtension;

    /* Increment secondary display count */
    FirstDeviceExtension->NumberOfSecondaryDisplays++;

    *SecondaryDeviceExtension = DeviceExtension->MiniPortDeviceExtension;
    return NO_ERROR;
}

VideoPortDebugPrint()

VOID VideoPortDebugPrint	(	IN VIDEO_DEBUG_LEVEL	DebugPrintLevel,
		IN PCHAR	DebugMessage,
			...
	)

Definition at line 841 of file videoprt.c.

{
    va_list ap;

    if (VideoDebugLevel >= DebugPrintLevel)
        DebugPrintLevel = Error;

    va_start(ap, DebugMessage);
    vDbgPrintEx(DPFLTR_IHVVIDEO_ID, DebugPrintLevel, DebugMessage, ap);
    va_end(ap);
}

Referenced by IntLoadRegistryParameters().

VideoPortEnumerateChildren()

VP_STATUS NTAPI VideoPortEnumerateChildren	(	IN PVOID	HwDeviceExtension,
		IN PVOID	Reserved
	)

Definition at line 1335 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;

    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    ASSERT(DeviceExtension);

    if (DeviceExtension->PhysicalDeviceObject)
    {
        /* Trigger reenumeration by the PnP manager */
        IoInvalidateDeviceRelations(DeviceExtension->PhysicalDeviceObject, BusRelations);
    }

    return NO_ERROR;
}

Referenced by IntVideoPortDispatchOpen(), and VBEInitialize().

VideoPortGetAssociatedDeviceExtension()

PVOID NTAPI VideoPortGetAssociatedDeviceExtension

(

IN PVOID

DeviceObject

)

Definition at line 1424 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;

    TRACE_(VIDEOPRT, "VideoPortGetAssociatedDeviceExtension\n");
    DeviceExtension = ((PDEVICE_OBJECT)DeviceObject)->DeviceExtension;
    if (!DeviceExtension)
        return NULL;
    return DeviceExtension->MiniPortDeviceExtension;
}

VideoPortGetCurrentIrql()

UCHAR NTAPI VideoPortGetCurrentIrql

(

VOID

)

Definition at line 880 of file videoprt.c.

{
    return KeGetCurrentIrql();
}

VideoPortGetRegistryParameters()

VP_STATUS NTAPI VideoPortGetRegistryParameters	(	IN PVOID	HwDeviceExtension,
		IN PWSTR	ParameterName,
		IN UCHAR	IsParameterFileName,
		IN PMINIPORT_GET_REGISTRY_ROUTINE	GetRegistryRoutine,
		IN PVOID	HwContext
	)

Definition at line 921 of file videoprt.c.

{
    RTL_QUERY_REGISTRY_TABLE QueryTable[2] = {{0}};
    QUERY_REGISTRY_CALLBACK_CONTEXT Context;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;

    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);

    TRACE_(VIDEOPRT, "VideoPortGetRegistryParameters ParameterName %S, RegPath: %wZ\n",
           ParameterName, &DeviceExtension->RegistryPath);

    Context.HwDeviceExtension = HwDeviceExtension;
    Context.HwContext = HwContext;
    Context.HwGetRegistryRoutine = GetRegistryRoutine;

    QueryTable[0].QueryRoutine = QueryRegistryCallback;
    QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    QueryTable[0].Name = ParameterName;

    Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                    DeviceExtension->RegistryPath.Buffer,
                                    QueryTable,
                                    &Context,
                                    NULL);
    if (!NT_SUCCESS(Status))
    {
        WARN_(VIDEOPRT, "VideoPortGetRegistryParameters could not find the "
              "requested parameter\n");
        return ERROR_INVALID_PARAMETER;
    }

    if (IsParameterFileName)
    {
        /* FIXME: need to read the contents of the file */
        UNIMPLEMENTED;
    }

    return NO_ERROR;
}

VideoPortGetRomImage()

PVOID NTAPI VideoPortGetRomImage	(	IN PVOID	HwDeviceExtension,
		IN PVOID	Unused1,
		IN ULONG	Unused2,
		IN ULONG	Length
	)

Definition at line 1031 of file videoprt.c.

{
    static PVOID RomImageBuffer = NULL;
    PKPROCESS CallingProcess;
    KAPC_STATE ApcState;

    TRACE_(VIDEOPRT, "VideoPortGetRomImage(HwDeviceExtension 0x%X Length 0x%X)\n",
           HwDeviceExtension, Length);

    /* If the length is zero then free the existing buffer. */
    if (Length == 0)
    {
        if (RomImageBuffer != NULL)
        {
            ExFreePool(RomImageBuffer);
            RomImageBuffer = NULL;
        }
        return NULL;
    }
    else
    {
        /*
         * The DDK says we shouldn't use the legacy C0000 method but get the
         * rom base address from the corresponding pci or acpi register but
         * lets ignore that and use C0000 anyway. We have already mapped the
         * bios area into memory so we'll copy from there.
         */

        /* Copy the bios. */
        Length = min(Length, 0x10000);
        if (RomImageBuffer != NULL)
        {
            ExFreePool(RomImageBuffer);
        }

        RomImageBuffer = ExAllocatePool(PagedPool, Length);
        if (RomImageBuffer == NULL)
        {
            return NULL;
        }

        IntAttachToCSRSS(&CallingProcess, &ApcState);
        RtlCopyMemory(RomImageBuffer, (PUCHAR)0xC0000, Length);
        IntDetachFromCSRSS(&CallingProcess, &ApcState);

        return RomImageBuffer;
    }
}

VideoPortGetVersion()

VP_STATUS NTAPI VideoPortGetVersion	(	IN PVOID	HwDeviceExtension,
		IN OUT PVPOSVERSIONINFO	VpOsVersionInfo
	)

Definition at line 1441 of file videoprt.c.

{
    RTL_OSVERSIONINFOEXW Version;

    Version.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
    if (VpOsVersionInfo->Size >= sizeof(VPOSVERSIONINFO))
    {
#if 1
        if (NT_SUCCESS(RtlGetVersion((PRTL_OSVERSIONINFOW)&Version)))
        {
            VpOsVersionInfo->MajorVersion = Version.dwMajorVersion;
            VpOsVersionInfo->MinorVersion = Version.dwMinorVersion;
            VpOsVersionInfo->BuildNumber = Version.dwBuildNumber;
            VpOsVersionInfo->ServicePackMajor = Version.wServicePackMajor;
            VpOsVersionInfo->ServicePackMinor = Version.wServicePackMinor;
            return NO_ERROR;
        }
        return ERROR_INVALID_PARAMETER;
#else
        VpOsVersionInfo->MajorVersion = 5;
        VpOsVersionInfo->MinorVersion = 0;
        VpOsVersionInfo->BuildNumber = 2195;
        VpOsVersionInfo->ServicePackMajor = 4;
        VpOsVersionInfo->ServicePackMinor = 0;
        return NO_ERROR;
#endif
    }

    return ERROR_INVALID_PARAMETER;
}

VideoPortGetVgaStatus()

VP_STATUS NTAPI VideoPortGetVgaStatus	(	IN PVOID	HwDeviceExtension,
		OUT PULONG	VgaStatus
	)

Definition at line 1003 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;

    TRACE_(VIDEOPRT, "VideoPortGetVgaStatus\n");

    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    if (KeGetCurrentIrql() == PASSIVE_LEVEL)
    {
        if (DeviceExtension->AdapterInterfaceType == PCIBus)
        {
            /* VgaStatus: 0 == VGA not enabled, 1 == VGA enabled. */
            /* Assumed for now */
            *VgaStatus = 1;
            return NO_ERROR;
        }
    }

    return ERROR_INVALID_FUNCTION;
}

VideoPortInitialize()

ULONG NTAPI VideoPortInitialize	(	IN PVOID	Context1,
		IN PVOID	Context2,
		IN PVIDEO_HW_INITIALIZATION_DATA	HwInitializationData,
		IN PVOID	HwContext
	)

Definition at line 639 of file videoprt.c.

{
    PDRIVER_OBJECT DriverObject = Context1;
    PUNICODE_STRING RegistryPath = Context2;
    NTSTATUS Status;
    PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
    BOOLEAN PnpDriver = FALSE, LegacyDetection = FALSE;
    static BOOLEAN FirstInitialization;

    TRACE_(VIDEOPRT, "VideoPortInitialize\n");

    if (!FirstInitialization)
    {
        FirstInitialization = TRUE;
        KeInitializeMutex(&VideoPortInt10Mutex, 0);
        KeInitializeSpinLock(&HwResetAdaptersLock);
        IntLoadRegistryParameters();
    }

    /* As a first thing do parameter checks. */
    if (HwInitializationData->HwInitDataSize > sizeof(VIDEO_HW_INITIALIZATION_DATA))
    {
        ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
        return STATUS_REVISION_MISMATCH;
    }

    if ((HwInitializationData->HwFindAdapter == NULL) ||
        (HwInitializationData->HwInitialize == NULL) ||
        (HwInitializationData->HwStartIO == NULL))
    {
        ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
        return STATUS_INVALID_PARAMETER;
    }

    switch (HwInitializationData->HwInitDataSize)
    {
            /*
             * NT4 drivers are special case, because we must use legacy method
             * of detection instead of the Plug & Play one.
             */
        case SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA:
            INFO_(VIDEOPRT, "We were loaded by a Windows NT miniport driver.\n");
            break;

        case SIZE_OF_W2K_VIDEO_HW_INITIALIZATION_DATA:
            INFO_(VIDEOPRT, "We were loaded by a Windows 2000 miniport driver.\n");
            break;

        case sizeof(VIDEO_HW_INITIALIZATION_DATA):
            INFO_(VIDEOPRT, "We were loaded by a Windows XP or later miniport driver.\n");
            break;

        default:
            ERR_(VIDEOPRT, "Invalid HwInitializationData size.\n");
            return STATUS_UNSUCCESSFUL;
    }

    /* Set dispatching routines */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = IntVideoPortDispatchOpen;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = IntVideoPortDispatchClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
        IntVideoPortDispatchDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] =
        IntVideoPortDispatchDeviceControl;
    DriverObject->DriverUnload = IntVideoPortUnload;

    /* Determine type of the miniport driver */
    if ((HwInitializationData->HwInitDataSize >=
            FIELD_OFFSET(VIDEO_HW_INITIALIZATION_DATA, HwQueryInterface)) &&
        (HwInitializationData->HwSetPowerState != NULL) &&
        (HwInitializationData->HwGetPowerState != NULL) &&
        (HwInitializationData->HwGetVideoChildDescriptor != NULL))
    {
        INFO_(VIDEOPRT, "The miniport is a PnP miniport driver\n");
        PnpDriver = TRUE;
    }

    /* Check if legacy detection should be applied */
    if (!PnpDriver || HwContext)
    {
        INFO_(VIDEOPRT, "Legacy detection for adapter interface %d\n",
              HwInitializationData->AdapterInterfaceType);

        /* FIXME: Move the code for legacy detection
           to another function and call it here */
        LegacyDetection = TRUE;
    }

    /*
     * NOTE:
     * The driver extension can be already allocated in case that we were
     * called by legacy driver and failed detecting device. Some miniport
     * drivers in that case adjust parameters and call VideoPortInitialize
     * again.
     */
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
    if (DriverExtension == NULL)
    {
        Status = IoAllocateDriverObjectExtension(DriverObject,
                                                 DriverObject,
                                                 sizeof(VIDEO_PORT_DRIVER_EXTENSION),
                                                 (PVOID *)&DriverExtension);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "IoAllocateDriverObjectExtension failed 0x%x\n", Status);
            return Status;
        }

        /*
         * Save the registry path. This should be done only once even if
         * VideoPortInitialize is called multiple times.
         */
        if (RegistryPath->Length != 0)
        {
            DriverExtension->RegistryPath.Length = 0;
            DriverExtension->RegistryPath.MaximumLength =
                RegistryPath->Length + sizeof(UNICODE_NULL);
            DriverExtension->RegistryPath.Buffer =
                ExAllocatePoolWithTag(
                    PagedPool,
                    DriverExtension->RegistryPath.MaximumLength,
                    'RTSU');
            if (DriverExtension->RegistryPath.Buffer == NULL)
            {
                RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            RtlCopyUnicodeString(&DriverExtension->RegistryPath, RegistryPath);
            INFO_(VIDEOPRT, "RegistryPath: %wZ\n", &DriverExtension->RegistryPath);
        }
        else
        {
            RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
        }
    }

    /* Copy the correct miniport initialization data to the device extension. */
    RtlCopyMemory(&DriverExtension->InitializationData,
                  HwInitializationData,
                  HwInitializationData->HwInitDataSize);
    if (HwInitializationData->HwInitDataSize <
            sizeof(VIDEO_HW_INITIALIZATION_DATA))
    {
        RtlZeroMemory((PVOID)((ULONG_PTR)&DriverExtension->InitializationData +
                              HwInitializationData->HwInitDataSize),
                      sizeof(VIDEO_HW_INITIALIZATION_DATA) -
                      HwInitializationData->HwInitDataSize);
    }
    DriverExtension->HwContext = HwContext;

    /*
     * Plug & Play drivers registers the device in AddDevice routine.
     * For legacy drivers we must do it now.
     */
    if (LegacyDetection)
    {
        PDEVICE_OBJECT DeviceObject;

        if (HwInitializationData->HwInitDataSize != SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA)
        {
            /* Power management */
            DriverObject->MajorFunction[IRP_MJ_POWER] = IntVideoPortDispatchPower;
        }

        Status = IntVideoPortCreateAdapterDeviceObject(DriverObject,
                                                       DriverExtension,
                                                       NULL,
                                                       DriverExtension->InitializationData.StartingDeviceNumber,
                                                       0,
                                                       &DeviceObject);
        if (!NT_SUCCESS(Status))
        {
            ERR_(VIDEOPRT, "IntVideoPortCreateAdapterDeviceObject returned 0x%x\n", Status);
            return Status;
        }

        Status = IntVideoPortFindAdapter(DriverObject, DriverExtension, DeviceObject);
        if (!NT_SUCCESS(Status))
            ERR_(VIDEOPRT, "IntVideoPortFindAdapter returned 0x%x\n", Status);

        return Status;
    }
    else
    {
        DriverObject->DriverExtension->AddDevice = IntVideoPortAddDevice;
        DriverObject->MajorFunction[IRP_MJ_PNP] = IntVideoPortDispatchPnp;
        DriverObject->MajorFunction[IRP_MJ_POWER] = IntVideoPortDispatchPower;
        DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = IntVideoPortDispatchSystemControl;

        return STATUS_SUCCESS;
    }
}

Referenced by DriverEntry().

VideoPortIsNoVesa()

BOOLEAN NTAPI VideoPortIsNoVesa

(

VOID

)

Definition at line 1629 of file videoprt.c.

{
    return VpNoVesa;
}

Referenced by InitializeModeTable(), VBEFindAdapter(), and VBEInitialize().

VideoPortLogError()

VOID NTAPI VideoPortLogError	(	IN PVOID	HwDeviceExtension,
		IN PVIDEO_REQUEST_PACKET Vrp	OPTIONAL,
		IN VP_STATUS	ErrorCode,
		IN ULONG	UniqueId
	)

Definition at line 861 of file videoprt.c.

{
    UNIMPLEMENTED;

    INFO_(VIDEOPRT, "VideoPortLogError ErrorCode %d (0x%x) UniqueId %lu (0x%lx)\n",
          ErrorCode, ErrorCode, UniqueId, UniqueId);
    if (Vrp)
        INFO_(VIDEOPRT, "Vrp->IoControlCode %lu (0x%lx)\n", Vrp->IoControlCode, Vrp->IoControlCode);
}

VideoPortQueryPerformanceCounter()

LONGLONG NTAPI VideoPortQueryPerformanceCounter	(	IN PVOID	HwDeviceExtension,
		OUT PLONGLONG PerformanceFrequency	OPTIONAL
	)

Definition at line 1555 of file videoprt.c.

{
    LARGE_INTEGER Result;

    TRACE_(VIDEOPRT, "VideoPortQueryPerformanceCounter\n");
    Result = KeQueryPerformanceCounter((PLARGE_INTEGER)PerformanceFrequency);
    return Result.QuadPart;
}

VideoPortQueueDpc()

BOOLEAN NTAPI VideoPortQueueDpc	(	IN PVOID	HwDeviceExtension,
		IN PMINIPORT_DPC_ROUTINE	CallbackRoutine,
		IN PVOID	Context
	)

Definition at line 1408 of file videoprt.c.

{
    return KeInsertQueueDpc(
               &VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension)->DpcObject,
               (PVOID)CallbackRoutine,
               (PVOID)Context);
}

VideoPortRegisterBugcheckCallback()

VP_STATUS NTAPI VideoPortRegisterBugcheckCallback	(	IN PVOID	HwDeviceExtension,
		IN ULONG	BugcheckCode,
		IN PVIDEO_BUGCHECK_CALLBACK	Callback,
		IN ULONG	BugcheckDataSize
	)

Definition at line 1540 of file videoprt.c.

{
    UNIMPLEMENTED;
    return NO_ERROR;
}

VideoPortReleaseDeviceLock()

VOID NTAPI VideoPortReleaseDeviceLock

(

IN PVOID

HwDeviceExtension

)

Definition at line 1587 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;

    TRACE_(VIDEOPRT, "VideoPortReleaseDeviceLock\n");
    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    KeReleaseMutex(&DeviceExtension->DeviceLock, FALSE);
    //ASSERT(Status == STATUS_SUCCESS);
}

VideoPortScanRom()

BOOLEAN NTAPI VideoPortScanRom	(	IN PVOID	HwDeviceExtension,
		IN PUCHAR	RomBase,
		IN ULONG	RomLength,
		IN PUCHAR	String
	)

Definition at line 1089 of file videoprt.c.

{
    SIZE_T StringLength;
    BOOLEAN Found;
    PUCHAR SearchLocation;

    TRACE_(VIDEOPRT, "VideoPortScanRom RomBase %p RomLength 0x%x String %s\n", RomBase, RomLength, String);

    StringLength = strlen((PCHAR)String);
    Found = FALSE;
    for (SearchLocation = RomBase;
            !Found && SearchLocation < RomBase + RomLength - StringLength;
            SearchLocation++)
    {
        Found = (RtlCompareMemory(SearchLocation, String, StringLength) == StringLength);
        if (Found)
        {
            INFO_(VIDEOPRT, "Match found at %p\n", SearchLocation);
        }
    }

    return Found;
}

VideoPortSetRegistryParameters()

VP_STATUS NTAPI VideoPortSetRegistryParameters	(	IN PVOID	HwDeviceExtension,
		IN PWSTR	ValueName,
		IN PVOID	ValueData,
		IN ULONG	ValueLength
	)

Definition at line 972 of file videoprt.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    VP_STATUS Status;

    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    TRACE_(VIDEOPRT, "VideoPortSetRegistryParameters ParameterName %S, RegPath: %wZ\n",
           ValueName,
           &DeviceExtension->RegistryPath);
    ASSERT_IRQL_LESS_OR_EQUAL(PASSIVE_LEVEL);
    Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                   DeviceExtension->RegistryPath.Buffer,
                                   ValueName,
                                   REG_BINARY,
                                   ValueData,
                                   ValueLength);
    if (Status != NO_ERROR)
        WARN_(VIDEOPRT, "VideoPortSetRegistryParameters error 0x%x\n", Status);

    return Status;
}

Referenced by Pc98VidFindAdapter(), and VmxFindAdapter().

VideoPortSynchronizeExecution()

BOOLEAN NTAPI VideoPortSynchronizeExecution	(	IN PVOID	HwDeviceExtension,
		IN VIDEO_SYNCHRONIZE_PRIORITY	Priority,
		IN PMINIPORT_SYNCHRONIZE_ROUTINE	SynchronizeRoutine,
		OUT PVOID	Context
	)

Definition at line 1122 of file videoprt.c.

{
    BOOLEAN Ret;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    KIRQL OldIrql;

    switch (Priority)
    {
        case VpLowPriority:
            Ret = (*SynchronizeRoutine)(Context);
            break;

        case VpMediumPriority:
            DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
            if (DeviceExtension->InterruptObject == NULL)
                Ret = (*SynchronizeRoutine)(Context);
            else
                Ret = KeSynchronizeExecution(
                          DeviceExtension->InterruptObject,
                          SynchronizeRoutine,
                          Context);
            break;

        case VpHighPriority:
            OldIrql = KeGetCurrentIrql();
            if (OldIrql < SYNCH_LEVEL)
                KeRaiseIrql(SYNCH_LEVEL, &OldIrql);

            Ret = (*SynchronizeRoutine)(Context);

            if (OldIrql < SYNCH_LEVEL)
                KeLowerIrql(OldIrql);
            break;

        default:
            Ret = FALSE;
    }

    return Ret;
}

VpNotifyEaData()

VOID NTAPI VpNotifyEaData	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVOID	Data
	)

Definition at line 1603 of file videoprt.c.

{
    UNIMPLEMENTED;
}

Variable Documentation

CsrProcess

PKPROCESS CsrProcess = NULL

Definition at line 39 of file videoprt.c.

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

HwResetAdaptersLock

KSPIN_LOCK HwResetAdaptersLock

Definition at line 42 of file videoprt.c.

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

VideoDebugLevel

ULONG VideoDebugLevel = 0

Definition at line 34 of file videoprt.c.

Referenced by VideoPortDebugPrint().

VideoPortInt10Mutex

KMUTEX VideoPortInt10Mutex

Definition at line 41 of file videoprt.c.

Referenced by IntInt10CallBios(), and VideoPortInitialize().

VideoPortMaxObjectNumber

ULONG VideoPortMaxObjectNumber = -1

static

Definition at line 40 of file videoprt.c.

Referenced by IntVideoPortAddDeviceMapLink(), and IntVideoPortCreateAdapterDeviceObject().

VpBaseVideo

BOOLEAN VpBaseVideo = FALSE

Definition at line 36 of file videoprt.c.

Referenced by IntLoadRegistryParameters().

VpNoVesa

BOOLEAN VpNoVesa = FALSE

Definition at line 37 of file videoprt.c.

Referenced by IntLoadRegistryParameters(), and VideoPortIsNoVesa().