resource.c File Reference

#include "videoprt.h"
#include <debug.h>

Include dependency graph for resource.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	IntVideoPortGetLegacyResources (IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension, OUT PVIDEO_ACCESS_RANGE *AccessRanges, OUT PULONG AccessRangeCount)
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)
static BOOLEAN	IntAccessRangeIsInAllocatedResources (_In_ PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension, _In_ PVIDEO_ACCESS_RANGE Range)
PVOID NTAPI	IntVideoPortMapMemory (IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension, IN PHYSICAL_ADDRESS IoAddress, IN ULONG NumberOfUchars, IN ULONG InIoSpace, IN HANDLE ProcessHandle, OUT VP_STATUS *Status)
VOID NTAPI	IntVideoPortUnmapMemory (IN PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension, IN PVOID MappedAddress)
PVOID NTAPI	VideoPortGetDeviceBase (IN PVOID HwDeviceExtension, IN PHYSICAL_ADDRESS IoAddress, IN ULONG NumberOfUchars, IN UCHAR InIoSpace)
VOID NTAPI	VideoPortFreeDeviceBase (IN PVOID HwDeviceExtension, IN PVOID MappedAddress)
VP_STATUS NTAPI	VideoPortMapBankedMemory (IN PVOID HwDeviceExtension, IN PHYSICAL_ADDRESS PhysicalAddress, IN PULONG Length, IN PULONG InIoSpace, OUT PVOID *VirtualAddress, IN ULONG BankLength, IN UCHAR ReadWriteBank, IN PBANKED_SECTION_ROUTINE BankRoutine, IN PVOID Context)
VP_STATUS NTAPI	VideoPortMapMemory (IN PVOID HwDeviceExtension, IN PHYSICAL_ADDRESS PhysicalAddress, IN PULONG Length, IN PULONG InIoSpace, OUT PVOID *VirtualAddress)
VP_STATUS NTAPI	VideoPortUnmapMemory (IN PVOID HwDeviceExtension, IN PVOID VirtualAddress, IN HANDLE ProcessHandle)
VP_STATUS NTAPI	VideoPortGetAccessRanges (_In_ PVOID HwDeviceExtension, _In_opt_ ULONG NumRequestedResources, _In_reads_opt_(NumRequestedResources) PIO_RESOURCE_DESCRIPTOR RequestedResources, _In_ ULONG NumAccessRanges, _Out_writes_(NumAccessRanges) PVIDEO_ACCESS_RANGE AccessRanges, _In_ PVOID VendorId, _In_ PVOID DeviceId, _Out_ PULONG Slot)
	Retrieves bus-relative (mainly PCI) hardware resources access ranges and, if possible, claims these resources for the caller.
VP_STATUS NTAPI	VideoPortVerifyAccessRanges (_In_ PVOID HwDeviceExtension, _In_opt_ ULONG NumAccessRanges, _In_reads_opt_(NumAccessRanges) PVIDEO_ACCESS_RANGE AccessRanges)
	Claims or releases a range of hardware resources and checks for conflicts.
VP_STATUS NTAPI	VideoPortGetDeviceData (IN PVOID HwDeviceExtension, IN VIDEO_DEVICE_DATA_TYPE DeviceDataType, IN PMINIPORT_QUERY_DEVICE_ROUTINE CallbackRoutine, IN PVOID Context)
PVOID NTAPI	VideoPortAllocatePool (IN PVOID HwDeviceExtension, IN VP_POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
VOID NTAPI	VideoPortFreePool (IN PVOID HwDeviceExtension, IN PVOID Ptr)
VP_STATUS NTAPI	VideoPortAllocateBuffer (IN PVOID HwDeviceExtension, IN ULONG Size, OUT PVOID *Buffer)
VOID NTAPI	VideoPortReleaseBuffer (IN PVOID HwDeviceExtension, IN PVOID Ptr)
PVOID NTAPI	VideoPortLockBuffer (IN PVOID HwDeviceExtension, IN PVOID BaseAddress, IN ULONG Length, IN VP_LOCK_OPERATION Operation)
BOOLEAN NTAPI	VideoPortLockPages (IN PVOID HwDeviceExtension, IN OUT PVIDEO_REQUEST_PACKET pVrp, IN PEVENT pUEvent, IN PEVENT pDisplayEvent, IN DMA_FLAGS DmaFlags)
VOID NTAPI	VideoPortUnlockBuffer (IN PVOID HwDeviceExtension, IN PVOID Mdl)
VP_STATUS NTAPI	VideoPortSetTrappedEmulatorPorts (IN PVOID HwDeviceExtension, IN ULONG NumAccessRanges, IN PVIDEO_ACCESS_RANGE AccessRange)
ULONG NTAPI	VideoPortGetBusData (IN PVOID HwDeviceExtension, IN BUS_DATA_TYPE BusDataType, IN ULONG SlotNumber, OUT PVOID Buffer, IN ULONG Offset, IN ULONG Length)
ULONG NTAPI	VideoPortSetBusData (IN PVOID HwDeviceExtension, IN BUS_DATA_TYPE BusDataType, IN ULONG SlotNumber, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)

Variables
BOOLEAN	VpBaseVideo
static UNICODE_STRING	VideoClassName = RTL_CONSTANT_STRING(L"VIDEO")

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 24 of file resource.c.

Function Documentation

IntAccessRangeIsInAllocatedResources()

static BOOLEAN IntAccessRangeIsInAllocatedResources ( _In_ PVIDEO_PORT_DEVICE_EXTENSION  DeviceExtension, _In_ PVIDEO_ACCESS_RANGE  Range  )

static

Definition at line 294 of file resource.c.

{
    CM_RESOURCE_LIST *Res = DeviceExtension->AllocatedResources;
    CM_FULL_RESOURCE_DESCRIPTOR *Full;
    CM_PARTIAL_RESOURCE_DESCRIPTOR *Desc;
 
    if (!Res || Res->Count == 0)
        return FALSE;
    Full = &Res->List[0];
    for (Desc = Full->PartialResourceList.PartialDescriptors;
         Desc < Full->PartialResourceList.PartialDescriptors + Full->PartialResourceList.Count;
         ++Desc)
    {
        if (Range->RangeInIoSpace && Desc->Type == CmResourceTypePort)
        {
            if (Desc->u.Port.Start.QuadPart == Range->RangeStart.QuadPart &&
                Desc->u.Port.Length == Range->RangeLength)
                return TRUE;
        }
        else if (!Range->RangeInIoSpace && Desc->Type == CmResourceTypeMemory)
        {
            if (Desc->u.Memory.Start.QuadPart == Range->RangeStart.QuadPart &&
                Desc->u.Memory.Length == Range->RangeLength)
                return TRUE;
        }
    }
    return FALSE;
}

Referenced by VideoPortVerifyAccessRanges().

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().

IntVideoPortGetLegacyResources()

NTSTATUS NTAPI IntVideoPortGetLegacyResources	(	IN PVIDEO_PORT_DRIVER_EXTENSION	DriverExtension,
		IN PVIDEO_PORT_DEVICE_EXTENSION	DeviceExtension,
		OUT PVIDEO_ACCESS_RANGE *	AccessRanges,
		OUT PULONG	AccessRangeCount
	)

Definition at line 34 of file resource.c.

{
    PCI_COMMON_CONFIG PciConfig;
    ULONG ReadLength;
 
    if (!DriverExtension->InitializationData.HwGetLegacyResources &&
        !DriverExtension->InitializationData.HwLegacyResourceCount)
    {
        /* No legacy resources to report */
        *AccessRangeCount = 0;
        return STATUS_SUCCESS;
    }
 
    if (DriverExtension->InitializationData.HwGetLegacyResources)
    {
        ReadLength = HalGetBusData(PCIConfiguration,
                                   DeviceExtension->SystemIoBusNumber,
                                   DeviceExtension->SystemIoSlotNumber,
                                   &PciConfig,
                                   sizeof(PciConfig));
        if (ReadLength != sizeof(PciConfig))
        {
            /* This device doesn't exist */
            return STATUS_NO_SUCH_DEVICE;
        }
 
        DriverExtension->InitializationData.HwGetLegacyResources(PciConfig.VendorID,
                                                                 PciConfig.DeviceID,
                                                                 AccessRanges,
                                                                 AccessRangeCount);
    }
    else
    {
        *AccessRanges = DriverExtension->InitializationData.HwLegacyResourceList;
        *AccessRangeCount = DriverExtension->InitializationData.HwLegacyResourceCount;
    }
 
    INFO_(VIDEOPRT, "Got %d legacy access ranges\n", *AccessRangeCount);
 
    return STATUS_SUCCESS;
}

Referenced by IntVideoPortFilterResourceRequirements(), and VideoPortGetAccessRanges().

IntVideoPortMapMemory()

PVOID NTAPI IntVideoPortMapMemory	(	IN PVIDEO_PORT_DEVICE_EXTENSION	DeviceExtension,
		IN PHYSICAL_ADDRESS	IoAddress,
		IN ULONG	NumberOfUchars,
		IN ULONG	InIoSpace,
		IN HANDLE	ProcessHandle,
		OUT VP_STATUS *	Status
	)

Definition at line 327 of file resource.c.

{
   PHYSICAL_ADDRESS TranslatedAddress;
   PVIDEO_PORT_ADDRESS_MAPPING AddressMapping;
   ULONG AddressSpace;
   PVOID MappedAddress;
   PLIST_ENTRY Entry;
 
   INFO_(VIDEOPRT, "- IoAddress: %lx\n", IoAddress.u.LowPart);
   INFO_(VIDEOPRT, "- NumberOfUchars: %lx\n", NumberOfUchars);
   INFO_(VIDEOPRT, "- InIoSpace: %x\n", InIoSpace);
 
   InIoSpace &= ~VIDEO_MEMORY_SPACE_DENSE;
 
   if (ProcessHandle != NULL && (InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0)
   {
      INFO_(VIDEOPRT, "ProcessHandle is not NULL (0x%x) but InIoSpace does not have "
             "VIDEO_MEMORY_SPACE_USER_MODE set! Setting "
             "VIDEO_MEMORY_SPACE_USER_MODE.\n",
             ProcessHandle);
      InIoSpace |= VIDEO_MEMORY_SPACE_USER_MODE;
   }
   else if (ProcessHandle == NULL && (InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) != 0)
   {
      INFO_(VIDEOPRT, "ProcessHandle is NULL (0x%x) but InIoSpace does have "
             "VIDEO_MEMORY_SPACE_USER_MODE set! Setting ProcessHandle "
             "to NtCurrentProcess()\n",
             ProcessHandle);
      ProcessHandle = NtCurrentProcess();
   }
 
   if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0 &&
       !IsListEmpty(&DeviceExtension->AddressMappingListHead))
   {
      Entry = DeviceExtension->AddressMappingListHead.Flink;
      while (Entry != &DeviceExtension->AddressMappingListHead)
      {
         AddressMapping = CONTAINING_RECORD(
            Entry,
            VIDEO_PORT_ADDRESS_MAPPING,
            List);
         if (IoAddress.QuadPart == AddressMapping->IoAddress.QuadPart &&
             NumberOfUchars <= AddressMapping->NumberOfUchars)
         {
            {
               AddressMapping->MappingCount++;
               if (Status)
                  *Status = NO_ERROR;
               return AddressMapping->MappedAddress;
            }
         }
         Entry = Entry->Flink;
      }
   }
 
   AddressSpace = (ULONG)InIoSpace;
   AddressSpace &= ~(VIDEO_MEMORY_SPACE_USER_MODE | VIDEO_MEMORY_SPACE_P6CACHE);
   if (HalTranslateBusAddress(
          DeviceExtension->AdapterInterfaceType,
          DeviceExtension->SystemIoBusNumber,
          IoAddress,
          &AddressSpace,
          &TranslatedAddress) == FALSE)
   {
      if (Status)
         *Status = ERROR_INVALID_PARAMETER;
 
      return NULL;
   }
 
   /* I/O space */
   if (AddressSpace != 0)
   {
      ASSERT(0 == TranslatedAddress.u.HighPart);
      if (Status)
         *Status = NO_ERROR;
 
      return (PVOID)(ULONG_PTR)TranslatedAddress.u.LowPart;
   }
 
   /* user space */
   if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) != 0)
   {
      NTSTATUS NtStatus;
      ULONG Protect;
      if (InIoSpace & VIDEO_MEMORY_SPACE_P6CACHE)
          Protect = PAGE_READWRITE | PAGE_WRITECOMBINE;
      else
          Protect = PAGE_READWRITE | PAGE_NOCACHE;
      MappedAddress = NULL;
      NtStatus = IntVideoPortMapPhysicalMemory(ProcessHandle,
                                               TranslatedAddress,
                                               NumberOfUchars,
                                               Protect,
                                               &MappedAddress);
      if (!NT_SUCCESS(NtStatus))
      {
         ERR_(VIDEOPRT, "IntVideoPortMapPhysicalMemory() failed! (0x%x)\n", NtStatus);
         if (Status)
            *Status = ERROR_INVALID_PARAMETER;
         return NULL;
      }
      INFO_(VIDEOPRT, "Mapped user address = 0x%08x\n", MappedAddress);
   }
   else /* kernel space */
   {
      MappedAddress = MmMapIoSpace(
         TranslatedAddress,
         NumberOfUchars,
         MmNonCached);
   }
 
   if (MappedAddress != NULL)
   {
      if (Status)
      {
         *Status = NO_ERROR;
      }
      if ((InIoSpace & VIDEO_MEMORY_SPACE_USER_MODE) == 0)
      {
         AddressMapping = ExAllocatePoolWithTag(
            PagedPool,
            sizeof(VIDEO_PORT_ADDRESS_MAPPING),
            TAG_VIDEO_PORT);
 
         if (AddressMapping == NULL)
            return MappedAddress;
 
         RtlZeroMemory(AddressMapping, sizeof(VIDEO_PORT_ADDRESS_MAPPING));
         AddressMapping->NumberOfUchars = NumberOfUchars;
         AddressMapping->IoAddress = IoAddress;
         AddressMapping->SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
         AddressMapping->MappedAddress = MappedAddress;
         AddressMapping->MappingCount = 1;
         InsertHeadList(
            &DeviceExtension->AddressMappingListHead,
            &AddressMapping->List);
      }
 
      return MappedAddress;
   }
 
   ERR_(VIDEOPRT,
        "Couldn't map video memory. IoAddress: 0x%lx, NumberOfUchars: 0x%lx, InIoSpace: 0x%x\n",
        IoAddress.u.LowPart, NumberOfUchars, InIoSpace);
   if (Status)
      *Status = ERROR_INVALID_PARAMETER;
 
   return NULL;
}

Referenced by VideoPortGetDeviceBase(), and VideoPortMapMemory().

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().

IntVideoPortUnmapMemory()

VOID NTAPI IntVideoPortUnmapMemory	(	IN PVIDEO_PORT_DEVICE_EXTENSION	DeviceExtension,
		IN PVOID	MappedAddress
	)

Definition at line 485 of file resource.c.

{
   PVIDEO_PORT_ADDRESS_MAPPING AddressMapping;
   PLIST_ENTRY Entry;
   NTSTATUS Status;
 
   Entry = DeviceExtension->AddressMappingListHead.Flink;
   while (Entry != &DeviceExtension->AddressMappingListHead)
   {
      AddressMapping = CONTAINING_RECORD(
         Entry,
         VIDEO_PORT_ADDRESS_MAPPING,
         List);
      if (AddressMapping->MappedAddress == MappedAddress)
      {
         ASSERT(AddressMapping->MappingCount > 0);
         AddressMapping->MappingCount--;
         if (AddressMapping->MappingCount == 0)
         {
            MmUnmapIoSpace(
               AddressMapping->MappedAddress,
               AddressMapping->NumberOfUchars);
            RemoveEntryList(Entry);
            ExFreePool(AddressMapping);
         }
         return;
      }
 
      Entry = Entry->Flink;
   }
 
   /* If there was no kernelmode mapping for the given address found we assume
    * that the given address is a usermode mapping and try to unmap it.
    *
    * FIXME: Is it ok to use NtCurrentProcess?
    */
   Status = ZwUnmapViewOfSection(NtCurrentProcess(), MappedAddress);
   if (!NT_SUCCESS(Status))
   {
      WARN_(VIDEOPRT, "Warning: Mapping for address 0x%p not found!\n", MappedAddress);
   }
}

Referenced by VideoPortFreeDeviceBase(), and VideoPortUnmapMemory().

VideoPortAllocateBuffer()

VP_STATUS NTAPI VideoPortAllocateBuffer	(	IN PVOID	HwDeviceExtension,
		IN ULONG	Size,
		OUT PVOID *	Buffer
	)

Definition at line 1256 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortAllocateBuffer\n");
   *Buffer = ExAllocatePoolWithTag ( PagedPool, Size, TAG_VIDEO_PORT_BUFFER ) ;
   return *Buffer == NULL ? ERROR_NOT_ENOUGH_MEMORY : NO_ERROR;
}

VideoPortAllocatePool()

PVOID NTAPI VideoPortAllocatePool	(	IN PVOID	HwDeviceExtension,
		IN VP_POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes,
		IN ULONG	Tag
	)

Definition at line 1229 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortAllocatePool\n");
   return ExAllocatePoolWithTag(PoolType, NumberOfBytes, Tag);
}

Referenced by BochsInitialize(), InitializeModeTable(), VbeGetVideoMemoryBaseAddress(), VBEInitialize(), and VbeSetColorLookup().

VideoPortFreeDeviceBase()

VOID NTAPI VideoPortFreeDeviceBase	(	IN PVOID	HwDeviceExtension,
		IN PVOID	MappedAddress
	)

Definition at line 558 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortFreeDeviceBase\n");
   IntVideoPortUnmapMemory(
      VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
      MappedAddress);
}

Referenced by InitializeModeTable().

VideoPortFreePool()

VOID NTAPI VideoPortFreePool	(	IN PVOID	HwDeviceExtension,
		IN PVOID	Ptr
	)

Definition at line 1244 of file resource.c.

{
   ExFreePool(Ptr);
}

Referenced by BochsFreeResources(), InitializeModeTable(), VbeGetVideoMemoryBaseAddress(), and VbeSetColorLookup().

VideoPortGetAccessRanges()

VP_STATUS NTAPI VideoPortGetAccessRanges	(	_In_ PVOID	HwDeviceExtension,
		_In_opt_ ULONG	NumRequestedResources,
		_In_reads_opt_(NumRequestedResources) PIO_RESOURCE_DESCRIPTOR	RequestedResources,
		_In_ ULONG	NumAccessRanges,
		_Out_writes_(NumAccessRanges) PVIDEO_ACCESS_RANGE	AccessRanges,
		_In_ PVOID	VendorId,
		_In_ PVOID	DeviceId,
		_Out_ PULONG	Slot
	)

Retrieves bus-relative (mainly PCI) hardware resources access ranges and, if possible, claims these resources for the caller.

Parameters

[in]	HwDeviceExtension	The miniport device extension.
[in]	NumRequestedResources	The number of hardware resources in the RequestedResources array.
[in]	RequestedResources	An optional array of IO_RESOURCE_DESCRIPTOR elements describing hardware resources the miniport requires.
[in]	NumAccessRanges	The number of ranges in the AccessRanges array the miniport expects to retrieve.
[out]	AccessRanges	A pointer to an array of hardware resource ranges VideoPortGetAccessRanges fills with bus-relative device memory ACCESS_RANGE's for the adapter.
[in]	VendorId	For a PCI device, points to a USHORT-type value that identifies the PCI manufacturer of the adapter. Otherwise, should be NULL.
[in]	DeviceId	For a PCI device, points to a USHORT-type value that identifies a particular PCI adapter model, assigned by the manufacturer. Otherwise, should be NULL.
[out]	Slot	Points to a ULONG value that receives the logical slot / location of the adapter (bus-dependent). For a PCI adapter, Slot points to a PCI_SLOT_NUMBER structure that locates the adapter on the PCI bus.

Returns

• NO_ERROR if the resources have been successfully claimed or released.
• ERROR_INVALID_PARAMETER if an error or a conflict occurred.
• ERROR_DEV_NOT_EXIST if the device is not found.
• ERROR_MORE_DATA if there exist more device access ranges available than what is specified by NumAccessRanges.
• ERROR_NOT_ENOUGH_MEMORY if there is not enough memory available.

Definition at line 686 of file resource.c.

{
    PCI_SLOT_NUMBER PciSlotNumber;
    ULONG DeviceNumber;
    ULONG FunctionNumber;
    PCI_COMMON_CONFIG Config;
    PCM_RESOURCE_LIST AllocatedResources;
    NTSTATUS Status;
    UINT AssignedCount = 0;
    CM_FULL_RESOURCE_DESCRIPTOR *FullList;
    CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor;
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
    USHORT VendorIdToFind;
    USHORT DeviceIdToFind;
    ULONG ReturnedLength;
    PVIDEO_ACCESS_RANGE LegacyAccessRanges;
    ULONG LegacyAccessRangeCount;
    PDRIVER_OBJECT DriverObject;
    ULONG ListSize;
    PIO_RESOURCE_REQUIREMENTS_LIST ResReqList;
    BOOLEAN DeviceAndVendorFound = FALSE;
 
    TRACE_(VIDEOPRT, "VideoPortGetAccessRanges(%d, %p, %d, %p)\n",
        NumRequestedResources, RequestedResources, NumAccessRanges, AccessRanges);
 
    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
    DriverObject = DeviceExtension->DriverObject;
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 
    if (NumRequestedResources == 0)
    {
        AllocatedResources = DeviceExtension->AllocatedResources;
        if (AllocatedResources == NULL &&
            DeviceExtension->AdapterInterfaceType == PCIBus)
        {
            if (DeviceExtension->PhysicalDeviceObject != NULL)
            {
                PciSlotNumber.u.AsULONG = DeviceExtension->SystemIoSlotNumber;
 
                ReturnedLength = HalGetBusData(PCIConfiguration,
                                               DeviceExtension->SystemIoBusNumber,
                                               PciSlotNumber.u.AsULONG,
                                               &Config,
                                               sizeof(Config));
 
                if (ReturnedLength != sizeof(Config))
                {
                    return ERROR_NOT_ENOUGH_MEMORY;
                }
            }
            else
            {
                VendorIdToFind = VendorId != NULL ? *(PUSHORT)VendorId : 0;
                DeviceIdToFind = DeviceId != NULL ? *(PUSHORT)DeviceId : 0;
 
                if (VendorIdToFind == 0 && DeviceIdToFind == 0)
                {
                    /* We're screwed */
                    return ERROR_DEV_NOT_EXIST;
                }
 
                INFO_(VIDEOPRT, "Looking for VendorId 0x%04x DeviceId 0x%04x\n",
                      VendorIdToFind, DeviceIdToFind);
 
                /*
                 * Search for the device id and vendor id on this bus.
                 */
                PciSlotNumber.u.bits.Reserved = 0;
                for (DeviceNumber = 0; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
                {
                    PciSlotNumber.u.bits.DeviceNumber = DeviceNumber;
                    for (FunctionNumber = 0; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
                    {
                        INFO_(VIDEOPRT, "- Function number: %d\n", FunctionNumber);
                        PciSlotNumber.u.bits.FunctionNumber = FunctionNumber;
                        ReturnedLength = HalGetBusData(PCIConfiguration,
                                                       DeviceExtension->SystemIoBusNumber,
                                                       PciSlotNumber.u.AsULONG,
                                                       &Config,
                                                       sizeof(Config));
 
                        INFO_(VIDEOPRT, "- Length of data: %x\n", ReturnedLength);
 
                        if (ReturnedLength == sizeof(Config))
                        {
                            INFO_(VIDEOPRT, "- Slot 0x%02x (Device %d Function %d) VendorId 0x%04x "
                                  "DeviceId 0x%04x\n",
                                  PciSlotNumber.u.AsULONG,
                                  PciSlotNumber.u.bits.DeviceNumber,
                                  PciSlotNumber.u.bits.FunctionNumber,
                                  Config.VendorID,
                                  Config.DeviceID);
 
                            if ((VendorIdToFind == 0 || Config.VendorID == VendorIdToFind) &&
                                (DeviceIdToFind == 0 || Config.DeviceID == DeviceIdToFind))
                            {
                                DeviceAndVendorFound = TRUE;
                                break;
                            }
                        }
                    }
                    if (DeviceAndVendorFound)
                        break;
                }
                if (FunctionNumber == PCI_MAX_FUNCTION)
                {
                    WARN_(VIDEOPRT, "Didn't find device.\n");
                    return ERROR_DEV_NOT_EXIST;
                }
            }
 
            Status = HalAssignSlotResources(&DeviceExtension->RegistryPath,
                                            NULL,
                                            DeviceExtension->DriverObject,
                                            DeviceExtension->DriverObject->DeviceObject,
                                            DeviceExtension->AdapterInterfaceType,
                                            DeviceExtension->SystemIoBusNumber,
                                            PciSlotNumber.u.AsULONG,
                                            &AllocatedResources);
            if (!NT_SUCCESS(Status))
            {
                WARN_(VIDEOPRT, "HalAssignSlotResources failed with status %x.\n",Status);
                return Status;
            }
            DeviceExtension->AllocatedResources = AllocatedResources;
            DeviceExtension->SystemIoSlotNumber = PciSlotNumber.u.AsULONG;
 
            /* Add legacy resources to the resources from HAL */
            Status = IntVideoPortGetLegacyResources(DriverExtension, DeviceExtension,
                                                    &LegacyAccessRanges, &LegacyAccessRangeCount);
            if (!NT_SUCCESS(Status))
                return ERROR_DEV_NOT_EXIST;
 
            if (NumAccessRanges < LegacyAccessRangeCount)
            {
                ERR_(VIDEOPRT, "Too many legacy access ranges found\n");
                return ERROR_NOT_ENOUGH_MEMORY; // ERROR_MORE_DATA;
            }
 
            RtlCopyMemory(AccessRanges, LegacyAccessRanges, LegacyAccessRangeCount * sizeof(VIDEO_ACCESS_RANGE));
            AssignedCount = LegacyAccessRangeCount;
        }
    }
    else
    {
        ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + (NumRequestedResources - 1) * sizeof(IO_RESOURCE_DESCRIPTOR);
        ResReqList = ExAllocatePool(NonPagedPool, ListSize);
        if (!ResReqList)
            return ERROR_NOT_ENOUGH_MEMORY;
 
        ResReqList->ListSize = ListSize;
        ResReqList->InterfaceType = DeviceExtension->AdapterInterfaceType;
        ResReqList->BusNumber = DeviceExtension->SystemIoBusNumber;
        ResReqList->SlotNumber = DeviceExtension->SystemIoSlotNumber;
        ResReqList->AlternativeLists = 1;
        ResReqList->List[0].Version = 1;
        ResReqList->List[0].Revision = 1;
        ResReqList->List[0].Count = NumRequestedResources;
 
        /* Copy in the caller's resource list */
        RtlCopyMemory(ResReqList->List[0].Descriptors,
                      RequestedResources,
                      NumRequestedResources * sizeof(IO_RESOURCE_DESCRIPTOR));
 
        Status = IoAssignResources(&DeviceExtension->RegistryPath,
                                   NULL,
                                   DeviceExtension->DriverObject,
                                   DeviceExtension->PhysicalDeviceObject ?
                                   DeviceExtension->PhysicalDeviceObject :
                                   DeviceExtension->DriverObject->DeviceObject,
                                   ResReqList,
                                   &AllocatedResources);
 
        if (!NT_SUCCESS(Status))
            return Status;
 
        if (!DeviceExtension->AllocatedResources)
            DeviceExtension->AllocatedResources = AllocatedResources;
    }
 
    if (AllocatedResources == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    /* Return the slot number if the caller wants it */
    if (Slot != NULL) *Slot = DeviceExtension->SystemIoSlotNumber;
 
    FullList = AllocatedResources->List;
    ASSERT(AllocatedResources->Count == 1);
    INFO_(VIDEOPRT, "InterfaceType %u BusNumber List %u Device BusNumber %u Version %u Revision %u\n",
          FullList->InterfaceType, FullList->BusNumber, DeviceExtension->SystemIoBusNumber,
          FullList->PartialResourceList.Version, FullList->PartialResourceList.Revision);
 
    ASSERT(FullList->InterfaceType == PCIBus);
    ASSERT(FullList->BusNumber == DeviceExtension->SystemIoBusNumber);
    ASSERT(1 == FullList->PartialResourceList.Version);
    ASSERT(1 == FullList->PartialResourceList.Revision);
 
    for (Descriptor = FullList->PartialResourceList.PartialDescriptors;
         Descriptor < FullList->PartialResourceList.PartialDescriptors + FullList->PartialResourceList.Count;
         Descriptor++)
    {
        if ((Descriptor->Type == CmResourceTypeMemory ||
             Descriptor->Type == CmResourceTypePort) &&
            AssignedCount >= NumAccessRanges)
        {
            ERR_(VIDEOPRT, "Too many access ranges found\n");
            return ERROR_MORE_DATA;
        }
        else if (Descriptor->Type == CmResourceTypeMemory)
        {
            INFO_(VIDEOPRT, "Memory range starting at 0x%08x length 0x%08x\n",
                  Descriptor->u.Memory.Start.u.LowPart, Descriptor->u.Memory.Length);
            AccessRanges[AssignedCount].RangeStart = Descriptor->u.Memory.Start;
            AccessRanges[AssignedCount].RangeLength = Descriptor->u.Memory.Length;
            AccessRanges[AssignedCount].RangeInIoSpace = 0;
            AccessRanges[AssignedCount].RangeVisible = 0; /* FIXME: Just guessing */
            AccessRanges[AssignedCount].RangeShareable =
                (Descriptor->ShareDisposition == CmResourceShareShared);
            AccessRanges[AssignedCount].RangePassive = 0;
            AssignedCount++;
        }
        else if (Descriptor->Type == CmResourceTypePort)
        {
            INFO_(VIDEOPRT, "Port range starting at 0x%04x length %d\n",
                  Descriptor->u.Port.Start.u.LowPart, Descriptor->u.Port.Length);
            AccessRanges[AssignedCount].RangeStart = Descriptor->u.Port.Start;
            AccessRanges[AssignedCount].RangeLength = Descriptor->u.Port.Length;
            AccessRanges[AssignedCount].RangeInIoSpace = 1;
            AccessRanges[AssignedCount].RangeVisible = 0; /* FIXME: Just guessing */
            AccessRanges[AssignedCount].RangeShareable =
                (Descriptor->ShareDisposition == CmResourceShareShared);
            AccessRanges[AssignedCount].RangePassive = 0;
            if (Descriptor->Flags & CM_RESOURCE_PORT_10_BIT_DECODE)
                AccessRanges[AssignedCount].RangePassive |= VIDEO_RANGE_10_BIT_DECODE;
            if (Descriptor->Flags & CM_RESOURCE_PORT_PASSIVE_DECODE)
                AccessRanges[AssignedCount].RangePassive |= VIDEO_RANGE_PASSIVE_DECODE;
            AssignedCount++;
        }
        else if (Descriptor->Type == CmResourceTypeInterrupt)
        {
            DeviceExtension->InterruptLevel = Descriptor->u.Interrupt.Level;
            DeviceExtension->InterruptVector = Descriptor->u.Interrupt.Vector;
            if (Descriptor->ShareDisposition == CmResourceShareShared)
                DeviceExtension->InterruptShared = TRUE;
            else
                DeviceExtension->InterruptShared = FALSE;
        }
        // else if (Descriptor->Type == CmResourceTypeDma) // TODO!
        else
        {
            ASSERT(FALSE);
            return ERROR_INVALID_PARAMETER;
        }
    }
 
    return NO_ERROR;
}

Referenced by BochsFindAdapter(), and XboxVmpFindAdapter().

VideoPortGetBusData()

ULONG NTAPI VideoPortGetBusData	(	IN PVOID	HwDeviceExtension,
		IN BUS_DATA_TYPE	BusDataType,
		IN ULONG	SlotNumber,
		OUT PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 1380 of file resource.c.

{
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
 
   TRACE_(VIDEOPRT, "VideoPortGetBusData\n");
 
   DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
 
   if (BusDataType != Cmos)
   {
      /* Legacy vs. PnP behaviour */
      if (DeviceExtension->PhysicalDeviceObject != NULL)
         SlotNumber = DeviceExtension->SystemIoSlotNumber;
   }
 
   return HalGetBusDataByOffset(
      BusDataType,
      DeviceExtension->SystemIoBusNumber,
      SlotNumber,
      Buffer,
      Offset,
      Length);
}

VideoPortGetDeviceBase()

PVOID NTAPI VideoPortGetDeviceBase	(	IN PVOID	HwDeviceExtension,
		IN PHYSICAL_ADDRESS	IoAddress,
		IN ULONG	NumberOfUchars,
		IN UCHAR	InIoSpace
	)

Definition at line 537 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortGetDeviceBase\n");
   return IntVideoPortMapMemory(
      VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
      IoAddress,
      NumberOfUchars,
      InIoSpace,
      NULL,
      NULL);
}

Referenced by BochsFindAdapter(), InitializeModeTable(), and VgaFindAdapter().

VideoPortGetDeviceData()

VP_STATUS NTAPI VideoPortGetDeviceData	(	IN PVOID	HwDeviceExtension,
		IN VIDEO_DEVICE_DATA_TYPE	DeviceDataType,
		IN PMINIPORT_QUERY_DEVICE_ROUTINE	CallbackRoutine,
		IN PVOID	Context
	)

Definition at line 1213 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortGetDeviceData\n");
   UNIMPLEMENTED;
   return ERROR_INVALID_FUNCTION;
}

Referenced by VgaFindAdapter().

VideoPortLockBuffer()

PVOID NTAPI VideoPortLockBuffer	(	IN PVOID	HwDeviceExtension,
		IN PVOID	BaseAddress,
		IN ULONG	Length,
		IN VP_LOCK_OPERATION	Operation
	)

Definition at line 1284 of file resource.c.

{
    PMDL Mdl;
 
    Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, FALSE, NULL);
    if (!Mdl)
    {
        return NULL;
    }
    /* FIXME use seh */
    MmProbeAndLockPages(Mdl, KernelMode,Operation);
    return Mdl;
}

Referenced by VideoPortLockPages().

VideoPortLockPages()

BOOLEAN NTAPI VideoPortLockPages	(	IN PVOID	HwDeviceExtension,
		IN OUT PVIDEO_REQUEST_PACKET	pVrp,
		IN PEVENT	pUEvent,
		IN PEVENT	pDisplayEvent,
		IN DMA_FLAGS	DmaFlags
	)

Definition at line 1308 of file resource.c.

{
    PVOID Buffer;
 
    /* clear output buffer */
    pVrp->OutputBuffer = NULL;
 
    if (DmaFlags != VideoPortDmaInitOnly)
    {
        /* VideoPortKeepPagesLocked / VideoPortUnlockAfterDma is no-op */
        return FALSE;
    }
 
    /* lock the buffer */
    Buffer = VideoPortLockBuffer(HwDeviceExtension, pVrp->InputBuffer, pVrp->InputBufferLength, IoModifyAccess);
 
    if (Buffer)
    {
        /* store result buffer & length */
        pVrp->OutputBuffer = Buffer;
        pVrp->OutputBufferLength = pVrp->InputBufferLength;
 
        /* operation succeeded */
        return TRUE;
    }
 
    /* operation failed */
    return FALSE;
}

VideoPortMapBankedMemory()

VP_STATUS NTAPI VideoPortMapBankedMemory	(	IN PVOID	HwDeviceExtension,
		IN PHYSICAL_ADDRESS	PhysicalAddress,
		IN PULONG	Length,
		IN PULONG	InIoSpace,
		OUT PVOID *	VirtualAddress,
		IN ULONG	BankLength,
		IN UCHAR	ReadWriteBank,
		IN PBANKED_SECTION_ROUTINE	BankRoutine,
		IN PVOID	Context
	)

Definition at line 573 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortMapBankedMemory\n");
   UNIMPLEMENTED;
   return ERROR_INVALID_FUNCTION;
}

VideoPortMapMemory()

VP_STATUS NTAPI VideoPortMapMemory	(	IN PVOID	HwDeviceExtension,
		IN PHYSICAL_ADDRESS	PhysicalAddress,
		IN PULONG	Length,
		IN PULONG	InIoSpace,
		OUT PVOID *	VirtualAddress
	)

Definition at line 595 of file resource.c.

{
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
   NTSTATUS Status;
 
   TRACE_(VIDEOPRT, "VideoPortMapMemory\n");
   INFO_(VIDEOPRT, "- *VirtualAddress: 0x%x\n", *VirtualAddress);
 
   DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
   *VirtualAddress = IntVideoPortMapMemory(
      DeviceExtension,
      PhysicalAddress,
      *Length,
      *InIoSpace,
      (HANDLE)*VirtualAddress,
      &Status);
 
   return Status;
}

VideoPortReleaseBuffer()

VOID NTAPI VideoPortReleaseBuffer	(	IN PVOID	HwDeviceExtension,
		IN PVOID	Ptr
	)

Definition at line 1271 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortReleaseBuffer\n");
   ExFreePool(Ptr);
}

VideoPortSetBusData()

ULONG NTAPI VideoPortSetBusData	(	IN PVOID	HwDeviceExtension,
		IN BUS_DATA_TYPE	BusDataType,
		IN ULONG	SlotNumber,
		IN PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 1415 of file resource.c.

{
   PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
 
   TRACE_(VIDEOPRT, "VideoPortSetBusData\n");
 
   DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
 
   if (BusDataType != Cmos)
   {
      /* Legacy vs. PnP behaviour */
      if (DeviceExtension->PhysicalDeviceObject != NULL)
         SlotNumber = DeviceExtension->SystemIoSlotNumber;
   }
 
   return HalSetBusDataByOffset(
      BusDataType,
      DeviceExtension->SystemIoBusNumber,
      SlotNumber,
      Buffer,
      Offset,
      Length);
}

VideoPortSetTrappedEmulatorPorts()

VP_STATUS NTAPI VideoPortSetTrappedEmulatorPorts	(	IN PVOID	HwDeviceExtension,
		IN ULONG	NumAccessRanges,
		IN PVIDEO_ACCESS_RANGE	AccessRange
	)

Definition at line 1365 of file resource.c.

{
    UNIMPLEMENTED;
    /* Should store the ranges in the device extension for use by ntvdm. */
    return NO_ERROR;
}

VideoPortUnlockBuffer()

VOID NTAPI VideoPortUnlockBuffer	(	IN PVOID	HwDeviceExtension,
		IN PVOID	Mdl
	)

Definition at line 1349 of file resource.c.

{
    if (Mdl)
    {
        MmUnlockPages((PMDL)Mdl);
        IoFreeMdl(Mdl);
    }
}

VideoPortUnmapMemory()

VP_STATUS NTAPI VideoPortUnmapMemory	(	IN PVOID	HwDeviceExtension,
		IN PVOID	VirtualAddress,
		IN HANDLE	ProcessHandle
	)

Definition at line 625 of file resource.c.

{
   TRACE_(VIDEOPRT, "VideoPortFreeDeviceBase\n");
 
   IntVideoPortUnmapMemory(
      VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension),
      VirtualAddress);
 
   return NO_ERROR;
}

VideoPortVerifyAccessRanges()

VP_STATUS NTAPI VideoPortVerifyAccessRanges	(	_In_ PVOID	HwDeviceExtension,
		_In_opt_ ULONG	NumAccessRanges,
		_In_reads_opt_(NumAccessRanges) PVIDEO_ACCESS_RANGE	AccessRanges
	)

Claims or releases a range of hardware resources and checks for conflicts.

Parameters

[in]	HwDeviceExtension	The miniport device extension.
[in]	NumAccessRanges	The number of hardware resource ranges in the AccessRanges array. Specify zero to release the hardware resources held by the miniport.
[in]	AccessRanges	The array of hardware resource ranges to claim ownership. Specify NULL to release the hardware resources held by the miniport.

Returns

• NO_ERROR if the resources have been successfully claimed or released.
• ERROR_INVALID_PARAMETER if an error or a conflict occurred.
• ERROR_NOT_ENOUGH_MEMORY if there is not enough memory available.

Definition at line 976 of file resource.c.

{
    PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
    BOOLEAN ConflictDetected;
    ULONG ResourceListSize;
    PCM_RESOURCE_LIST ResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    ULONG i;
    NTSTATUS Status;
 
    TRACE_(VIDEOPRT, "VideoPortVerifyAccessRanges\n");
 
    /* Verify parameters */
    if (NumAccessRanges && !AccessRanges)
        return ERROR_INVALID_PARAMETER;
 
    DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
 
    if (NumAccessRanges == 0)
    {
        /* Release the resources and do nothing more for now... */
        IntVideoPortReleaseResources(DeviceExtension);
        /* If releasing VGA device resources, clear tracked ranges */
        if (DeviceExtension->IsVgaDriver)
        {
            KeWaitForMutexObject(&VgaSyncLock, Executive, KernelMode, FALSE, NULL);
            if (VgaRanges)
            {
                ExFreePoolWithTag(VgaRanges, TAG_VIDEO_PORT);
                VgaRanges = NULL;
            }
            NumOfVgaRanges = 0;
            VgaDeviceExtension = NULL;
            KeReleaseMutex(&VgaSyncLock, FALSE);
        }
        return NO_ERROR;
    }
 
    /*
     * For non-legacy PCI devices, validate that the relevant I/O or memory
     * decoding bits are enabled in the PCI command register before claiming
     */
    if (!DeviceExtension->IsLegacyDevice && DeviceExtension->AdapterInterfaceType == PCIBus)
    {
        USHORT PciCommand;
        ULONG BytesRead;
 
        BytesRead = HalGetBusDataByOffset(PCIConfiguration,
                                          DeviceExtension->SystemIoBusNumber,
                                          DeviceExtension->SystemIoSlotNumber,
                                          &PciCommand,
                                          FIELD_OFFSET(PCI_COMMON_CONFIG, Command),
                                          sizeof(PciCommand));
        if (BytesRead == sizeof(PciCommand))
        {
            for (i = 0; i < NumAccessRanges; i++)
            {
                if (AccessRanges[i].RangeInIoSpace)
                {
                    if ((PciCommand & PCI_ENABLE_IO_SPACE) == 0)
                    {
                        WARN_(VIDEOPRT, "PCI I/O space disabled; refusing access range claim\n");
                        return ERROR_INVALID_PARAMETER;
                    }
                }
                else
                {
                    if ((PciCommand & PCI_ENABLE_MEMORY_SPACE) == 0)
                    {
                        WARN_(VIDEOPRT, "PCI memory space disabled; refusing access range claim\n");
                        return ERROR_INVALID_PARAMETER;
                    }
                }
            }
        }
    }
 
    /* Determine which ranges need to be claimed (exclude PnP-assigned ones) */
    ULONG Needed = 0;
    for (i = 0; i < NumAccessRanges; ++i)
    {
        if (DeviceExtension->PhysicalDeviceObject && !DeviceExtension->IsLegacyDevice)
        {
            if (IntAccessRangeIsInAllocatedResources(DeviceExtension, &AccessRanges[i]))
                continue;
        }
        ++Needed;
    }
 
    if (Needed == 0)
    {
        /* Nothing to report/claim */
        return NO_ERROR;
    }
 
    /* Create the resource list for the non-PnP-assigned ranges */
    ResourceListSize = sizeof(CM_RESOURCE_LIST)
        + (Needed - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
    ResourceList = ExAllocatePoolWithTag(PagedPool, ResourceListSize, TAG_VIDEO_PORT);
    if (!ResourceList)
    {
        WARN_(VIDEOPRT, "ExAllocatePool() failed\n");
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    /* Fill resource list */
    ResourceList->Count = 1;
    ResourceList->List[0].InterfaceType = DeviceExtension->AdapterInterfaceType;
    ResourceList->List[0].BusNumber = DeviceExtension->SystemIoBusNumber;
    ResourceList->List[0].PartialResourceList.Version = 1;
    ResourceList->List[0].PartialResourceList.Revision = 1;
    ResourceList->List[0].PartialResourceList.Count = Needed;
 
    ULONG j = 0;
    for (i = 0; i < NumAccessRanges; ++i)
    {
        if (DeviceExtension->PhysicalDeviceObject && !DeviceExtension->IsLegacyDevice)
        {
            if (IntAccessRangeIsInAllocatedResources(DeviceExtension, &AccessRanges[i]))
                continue;
        }
 
        PartialDescriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[j++];
        if (AccessRanges[i].RangeInIoSpace)
        {
            PartialDescriptor->Type = CmResourceTypePort;
            PartialDescriptor->u.Port.Start = AccessRanges[i].RangeStart;
            PartialDescriptor->u.Port.Length = AccessRanges[i].RangeLength;
        }
        else
        {
            PartialDescriptor->Type = CmResourceTypeMemory;
            PartialDescriptor->u.Memory.Start = AccessRanges[i].RangeStart;
            PartialDescriptor->u.Memory.Length = AccessRanges[i].RangeLength;
        }
        PartialDescriptor->ShareDisposition = AccessRanges[i].RangeShareable ?
            CmResourceShareShared : CmResourceShareDeviceExclusive;
        PartialDescriptor->Flags = 0;
        if (AccessRanges[i].RangePassive & VIDEO_RANGE_PASSIVE_DECODE)
            PartialDescriptor->Flags |= CM_RESOURCE_PORT_PASSIVE_DECODE;
        if (AccessRanges[i].RangePassive & VIDEO_RANGE_10_BIT_DECODE)
            PartialDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
    }
 
    if (DeviceExtension->IsLegacyDevice || DeviceExtension->IsLegacyDetect || DeviceExtension->IsVgaDetect)
    {
        Status = IoReportResourceForDetection(
                    DeviceExtension->DriverObject,
                    NULL, 0, /* Driver List */
                    DeviceExtension->PhysicalDeviceObject,
                    ResourceList, ResourceListSize,
                    &ConflictDetected);
 
        /* IntIsVgaSaveDriver() will later ignore STATUS_CONFLICTING_ADDRESSES, but we still claim it */
        if (!NT_SUCCESS(Status) && DeviceExtension->IsVgaDriver)
        {
            NTSTATUS fbStatus;
            BOOLEAN fbConflict = FALSE;
            fbStatus = IoReportResourceUsage(&VideoClassName,
                                             DeviceExtension->DriverObject,
                                             NULL,
                                             0,
                                             DeviceExtension->PhysicalDeviceObject,
                                             ResourceList,
                                             ResourceListSize,
                                             FALSE,
                                             &fbConflict);
            INFO_(VIDEOPRT, "VGA detect->usage fallback: Status=0x%lx Conflict=%d fbStatus=0x%lx fbConflict=%d\n",
                  Status, ConflictDetected, fbStatus, fbConflict);
            Status = fbStatus;
            ConflictDetected = fbConflict;
        }
    }
    else
    {
        Status = IoReportResourceUsage(&VideoClassName,
                                       DeviceExtension->DriverObject,
                                       NULL,
                                       0,
                                       DeviceExtension->PhysicalDeviceObject,
                                       ResourceList,
                                       ResourceListSize,
                                       FALSE,
                                       &ConflictDetected);
    }
    ExFreePoolWithTag(ResourceList, TAG_VIDEO_PORT);
 
    /* If VgaSave driver is conflicting and we don't explicitly want
     * to use it, ignore the problem (because win32k will try to use
     * this driver only if all other ones are failing). */
    if ((Status == STATUS_CONFLICTING_ADDRESSES || ConflictDetected) &&
        DeviceExtension->IsVgaDriver && !VpBaseVideo)
    {
        return NO_ERROR;
    }
 
    if (!NT_SUCCESS(Status) || ConflictDetected)
        return ERROR_INVALID_PARAMETER;
    else
    {
        /* Track VGA access ranges on success for fallback handling */
        if (DeviceExtension->IsVgaDriver && AccessRanges != VgaRanges)
        {
            KeWaitForMutexObject(&VgaSyncLock, Executive, KernelMode, FALSE, NULL);
            if (VgaRanges)
            {
                ExFreePoolWithTag(VgaRanges, TAG_VIDEO_PORT);
                VgaRanges = NULL;
                NumOfVgaRanges = 0;
            }
            if (NumAccessRanges)
            {
                SIZE_T sz = NumAccessRanges * sizeof(VIDEO_ACCESS_RANGE);
                VgaRanges = ExAllocatePoolWithTag(PagedPool, sz, TAG_VIDEO_PORT);
                if (VgaRanges)
                {
                    RtlCopyMemory(VgaRanges, AccessRanges, sz);
                    NumOfVgaRanges = NumAccessRanges;
                    VgaDeviceExtension = DeviceExtension;
                }
            }
            KeReleaseMutex(&VgaSyncLock, FALSE);
        }
        /* Leave VGA detect phase after first successful claim */
        DeviceExtension->IsVgaDetect = FALSE;
        return NO_ERROR;
    }
}

Referenced by BochsFindAdapter(), IntVideoPortFindAdapter(), Pc98VidFindAdapter(), VgaAcquireResources(), and VGAFindAdapter().

Variable Documentation

VideoClassName

UNICODE_STRING VideoClassName = RTL_CONSTANT_STRING(L"VIDEO")

static

Definition at line 29 of file resource.c.

Referenced by IntVideoPortReleaseResources(), and VideoPortVerifyAccessRanges().

VpBaseVideo

BOOLEAN VpBaseVideo

extern

Definition at line 36 of file videoprt.c.

Referenced by IntLoadRegistryParameters(), and VideoPortVerifyAccessRanges().