-/* $Id$
- *
+/*
* PROJECT: ReactOS PCI bus driver
* FILE: pdo.c
* PURPOSE: Child device object dispatch routines
* 10-09-2001 CSH Created
*/
-#include <ddk/ntddk.h>
-
-#include "pcidef.h"
#include "pci.h"
#define NDEBUG
#include <debug.h>
-DEFINE_GUID(GUID_BUS_TYPE_PCI, 0xc8ebdfb0L, 0xb510, 0x11d0, 0x80, 0xe5, 0x00, 0xa0, 0xc9, 0x25, 0x42, 0xe3);
-
/*** PRIVATE *****************************************************************/
static NTSTATUS
switch (IrpSp->Parameters.QueryId.IdType) {
case BusQueryDeviceID:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->DeviceID,
- PagedPool);
+ &String);
DPRINT("DeviceID: %S\n", String.Buffer);
break;
case BusQueryHardwareIDs:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->HardwareIDs,
- PagedPool);
+ &String);
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
break;
case BusQueryCompatibleIDs:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->CompatibleIDs,
- PagedPool);
+ &String);
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
break;
case BusQueryInstanceID:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->InstanceID,
- PagedPool);
+ &String);
DPRINT("InstanceID: %S\n", String.Buffer);
{
BusInformation->BusTypeGuid = GUID_BUS_TYPE_PCI;
BusInformation->LegacyBusType = PCIBus;
- BusInformation->BusNumber = DeviceExtension->BusNumber;
+ BusInformation->BusNumber = DeviceExtension->PciDevice->BusNumber;
return STATUS_SUCCESS;
}
if (DeviceCapabilities->Version != 1)
return STATUS_UNSUCCESSFUL;
-
+
DeviceCapabilities->UniqueID = FALSE;
- DeviceCapabilities->Address = DeviceExtension->SlotNumber.u.AsULONG;
+ DeviceCapabilities->Address = DeviceExtension->PciDevice->SlotNumber.u.AsULONG;
DeviceCapabilities->UINumber = (ULONG)-1; /* FIXME */
return STATUS_SUCCESS;
/* Save original value */
Size= HalGetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&OrigValue,
Offset,
sizeof(ULONG));
/* Set magic value */
NewValue = (ULONG)-1;
Size= HalSetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&NewValue,
Offset,
sizeof(ULONG));
/* Get the range length */
Size= HalGetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&NewValue,
Offset,
sizeof(ULONG));
/* Restore original value */
Size= HalSetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&OrigValue,
Offset,
sizeof(ULONG));
/* Get PCI configuration space */
Size= HalGetBusData(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&PciConfig,
- sizeof(PCI_COMMON_CONFIG));
+ PCI_COMMON_HDR_LENGTH);
DPRINT("Size %lu\n", Size);
- if (Size < sizeof(PCI_COMMON_CONFIG))
+ if (Size < PCI_COMMON_HDR_LENGTH)
{
Irp->IoStatus.Information = 0;
return STATUS_UNSUCCESSFUL;
if (Length != 0)
ResCount += 2;
}
+ if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
+ ResCount++;
}
else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
{
+ /* FIXME: Count Cardbus bridge resources */
}
else
{
}
/* Calculate the resource list size */
- ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
- if (ResCount > 1)
- {
- ListSize += ((ResCount - 1) * sizeof(IO_RESOURCE_DESCRIPTOR));
- }
+ ListSize = FIELD_OFFSET(IO_RESOURCE_REQUIREMENTS_LIST, List->Descriptors)
+ + ResCount * sizeof(IO_RESOURCE_DESCRIPTOR);
DPRINT("ListSize %lu (0x%lx)\n", ListSize, ListSize);
return STATUS_INSUFFICIENT_RESOURCES;
}
+ RtlZeroMemory(ResourceList, ListSize);
ResourceList->ListSize = ListSize;
ResourceList->InterfaceType = PCIBus;
+ ResourceList->BusNumber = DeviceExtension->PciDevice->BusNumber;
+ ResourceList->SlotNumber = DeviceExtension->PciDevice->SlotNumber.u.AsULONG;
ResourceList->AlternativeLists = 1;
ResourceList->List[0].Version = 1;
ResourceList->List[0].Count = ResCount;
Descriptor = &ResourceList->List[0].Descriptors[0];
- if (PCI_CONFIGURATION_TYPE(&PciConfig) == 0)
+ if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
{
for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
{
if (Length == 0)
{
DPRINT("Unused address register\n");
- break;
+ continue;
}
/* Set preferred descriptor */
if (PciConfig.u.type0.InterruptPin != 0)
{
+ Descriptor->Option = 0; /* Required */
Descriptor->Type = CmResourceTypeInterrupt;
Descriptor->ShareDisposition = CmResourceShareShared;
Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
Descriptor->u.Interrupt.MaximumVector = 0xFF;
}
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 1)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
{
for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
{
if (Length == 0)
{
DPRINT("Unused address register\n");
- break;
+ continue;
}
/* Set preferred descriptor */
}
Descriptor++;
}
+ if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
+ {
+ Descriptor->Option = 0; /* Required */
+ Descriptor->Type = CmResourceTypeBusNumber;
+ Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+
+ Descriptor->u.BusNumber.MinBusNumber =
+ Descriptor->u.BusNumber.MaxBusNumber = DeviceExtension->PciDevice->PciConfig.u.type1.SecondaryBus;
+ Descriptor->u.BusNumber.Length = 1;
+ Descriptor->u.BusNumber.Reserved = 0;
+ }
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 2)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
{
/* FIXME: Add Cardbus bridge resources */
}
/* Get PCI configuration space */
Size= HalGetBusData(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
&PciConfig,
- sizeof(PCI_COMMON_CONFIG));
+ PCI_COMMON_HDR_LENGTH);
DPRINT("Size %lu\n", Size);
- if (Size < sizeof(PCI_COMMON_CONFIG))
+ if (Size < PCI_COMMON_HDR_LENGTH)
{
Irp->IoStatus.Information = 0;
return STATUS_UNSUCCESSFUL;
/* Count required resource descriptors */
ResCount = 0;
- if (PCI_CONFIGURATION_TYPE(&PciConfig) == 0)
+ if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
{
for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
{
(PciConfig.u.type0.InterruptLine != 0xFF))
ResCount++;
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 1)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
{
for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
{
if (Length != 0)
ResCount++;
}
+ if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
+ ResCount++;
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 2)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
{
-
+ /* FIXME: Count Cardbus bridge resources */
}
else
{
}
/* Calculate the resource list size */
- ListSize = sizeof(CM_RESOURCE_LIST);
- if (ResCount > 1)
- {
- ListSize += ((ResCount - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
- }
+ ListSize = FIELD_OFFSET(CM_RESOURCE_LIST, List->PartialResourceList.PartialDescriptors)
+ + ResCount * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
/* Allocate the resource list */
ResourceList = ExAllocatePool(PagedPool,
if (ResourceList == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
+ RtlZeroMemory(ResourceList, ListSize);
ResourceList->Count = 1;
- ResourceList->List[0].InterfaceType = PCIConfiguration;
- ResourceList->List[0].BusNumber = DeviceExtension->BusNumber;
+ ResourceList->List[0].InterfaceType = PCIBus;
+ ResourceList->List[0].BusNumber = DeviceExtension->PciDevice->BusNumber;
PartialList = &ResourceList->List[0].PartialResourceList;
- PartialList->Version = 0;
- PartialList->Revision = 0;
+ PartialList->Version = 1;
+ PartialList->Revision = 1;
PartialList->Count = ResCount;
Descriptor = &PartialList->PartialDescriptors[0];
- if (PCI_CONFIGURATION_TYPE(&PciConfig) == 0)
+ if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
{
for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
{
if (Length == 0)
{
DPRINT("Unused address register\n");
- break;
+ continue;
}
if (Flags & PCI_ADDRESS_IO_SPACE)
Descriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
}
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 1)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
{
for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
{
if (Length == 0)
{
DPRINT("Unused address register\n");
- break;
+ continue;
}
if (Flags & PCI_ADDRESS_IO_SPACE)
Descriptor++;
}
+ if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
+ {
+ Descriptor->Type = CmResourceTypeBusNumber;
+ Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+
+ Descriptor->u.BusNumber.Start = DeviceExtension->PciDevice->PciConfig.u.type1.SecondaryBus;
+ Descriptor->u.BusNumber.Length = 1;
+ Descriptor->u.BusNumber.Reserved = 0;
+ }
}
- else if (PCI_CONFIGURATION_TYPE(&PciConfig) == 2)
+ else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
{
- /* FIXME: Cardbus */
+ /* FIXME: Add Cardbus bridge resources */
}
Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
}
+static VOID NTAPI
+InterfaceReference(
+ IN PVOID Context)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+
+ DPRINT("InterfaceReference(%p)\n", Context);
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+ InterlockedIncrement(&DeviceExtension->References);
+}
+
+
+static VOID NTAPI
+InterfaceDereference(
+ IN PVOID Context)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+
+ DPRINT("InterfaceDereference(%p)\n", Context);
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+ InterlockedDecrement(&DeviceExtension->References);
+}
+
+
+static BOOLEAN NTAPI
+InterfaceBusTranslateBusAddress(
+ IN PVOID Context,
+ IN PHYSICAL_ADDRESS BusAddress,
+ IN ULONG Length,
+ IN OUT PULONG AddressSpace,
+ OUT PPHYSICAL_ADDRESS TranslatedAddress)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+
+ DPRINT("InterfaceBusTranslateBusAddress(%p %p 0x%lx %p %p)\n",
+ Context, BusAddress, Length, AddressSpace, TranslatedAddress);
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+
+ return HalTranslateBusAddress(
+ PCIBus, DeviceExtension->PciDevice->BusNumber,
+ BusAddress, AddressSpace, TranslatedAddress);
+}
+
+
+static PDMA_ADAPTER NTAPI
+InterfaceBusGetDmaAdapter(
+ IN PVOID Context,
+ IN PDEVICE_DESCRIPTION DeviceDescription,
+ OUT PULONG NumberOfMapRegisters)
+{
+ DPRINT("InterfaceBusGetDmaAdapter(%p %p %p)\n",
+ Context, DeviceDescription, NumberOfMapRegisters);
+ return (PDMA_ADAPTER)HalGetAdapter(DeviceDescription, NumberOfMapRegisters);
+}
+
+
+static ULONG NTAPI
+InterfaceBusSetBusData(
+ IN PVOID Context,
+ IN ULONG DataType,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+ ULONG Size;
+
+ DPRINT("InterfaceBusSetBusData(%p 0x%lx %p 0x%lx 0x%lx)\n",
+ Context, DataType, Buffer, Offset, Length);
+
+ if (DataType != PCI_WHICHSPACE_CONFIG)
+ {
+ DPRINT("Unknown DataType %lu\n", DataType);
+ return 0;
+ }
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+
+ /* Get PCI configuration space */
+ Size = HalSetBusDataByOffset(PCIConfiguration,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
+ Buffer,
+ Offset,
+ Length);
+ return Size;
+}
+
+
+static ULONG NTAPI
+InterfaceBusGetBusData(
+ IN PVOID Context,
+ IN ULONG DataType,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+ ULONG Size;
+
+ DPRINT("InterfaceBusGetBusData(%p 0x%lx %p 0x%lx 0x%lx) called\n",
+ Context, DataType, Buffer, Offset, Length);
+
+ if (DataType != PCI_WHICHSPACE_CONFIG)
+ {
+ DPRINT("Unknown DataType %lu\n", DataType);
+ return 0;
+ }
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+
+ /* Get PCI configuration space */
+ Size = HalGetBusDataByOffset(PCIConfiguration,
+ DeviceExtension->PciDevice->BusNumber,
+ DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
+ Buffer,
+ Offset,
+ Length);
+ return Size;
+}
+
+
+static BOOLEAN NTAPI
+InterfacePciDevicePresent(
+ IN USHORT VendorID,
+ IN USHORT DeviceID,
+ IN UCHAR RevisionID,
+ IN USHORT SubVendorID,
+ IN USHORT SubSystemID,
+ IN ULONG Flags)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PPCI_DEVICE PciDevice;
+ PLIST_ENTRY CurrentBus, CurrentEntry;
+ KIRQL OldIrql;
+ BOOLEAN Found = FALSE;
+
+ KeAcquireSpinLock(&DriverExtension->BusListLock, &OldIrql);
+ CurrentBus = DriverExtension->BusListHead.Flink;
+ while (!Found && CurrentBus != &DriverExtension->BusListHead)
+ {
+ FdoDeviceExtension = CONTAINING_RECORD(CurrentBus, FDO_DEVICE_EXTENSION, ListEntry);
+
+ KeAcquireSpinLockAtDpcLevel(&FdoDeviceExtension->DeviceListLock);
+ CurrentEntry = FdoDeviceExtension->DeviceListHead.Flink;
+ while (!Found && CurrentEntry != &FdoDeviceExtension->DeviceListHead)
+ {
+ PciDevice = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
+ if (PciDevice->PciConfig.VendorID == VendorID &&
+ PciDevice->PciConfig.DeviceID == DeviceID)
+ {
+ if (!(Flags & PCI_USE_SUBSYSTEM_IDS) || (
+ PciDevice->PciConfig.u.type0.SubVendorID == SubVendorID &&
+ PciDevice->PciConfig.u.type0.SubSystemID == SubSystemID))
+ {
+ if (!(Flags & PCI_USE_REVISION) ||
+ PciDevice->PciConfig.RevisionID == RevisionID)
+ {
+ DPRINT("Found the PCI device\n");
+ Found = TRUE;
+ }
+ }
+ }
+
+ CurrentEntry = CurrentEntry->Flink;
+ }
+
+ KeReleaseSpinLockFromDpcLevel(&FdoDeviceExtension->DeviceListLock);
+ CurrentBus = CurrentBus->Flink;
+ }
+ KeReleaseSpinLock(&DriverExtension->BusListLock, OldIrql);
+
+ return Found;
+}
+
+
+static BOOLEAN
+CheckPciDevice(
+ IN PPCI_COMMON_CONFIG PciConfig,
+ IN PPCI_DEVICE_PRESENCE_PARAMETERS Parameters)
+{
+ if ((Parameters->Flags & PCI_USE_VENDEV_IDS) && (
+ PciConfig->VendorID != Parameters->VendorID ||
+ PciConfig->DeviceID != Parameters->DeviceID))
+ {
+ return FALSE;
+ }
+ if ((Parameters->Flags & PCI_USE_CLASS_SUBCLASS) && (
+ PciConfig->BaseClass != Parameters->BaseClass ||
+ PciConfig->SubClass != Parameters->SubClass))
+ {
+ return FALSE;
+ }
+ if ((Parameters->Flags & PCI_USE_PROGIF) &&
+ PciConfig->ProgIf != Parameters->ProgIf)
+ {
+ return FALSE;
+ }
+ if ((Parameters->Flags & PCI_USE_SUBSYSTEM_IDS) && (
+ PciConfig->u.type0.SubVendorID != Parameters->SubVendorID ||
+ PciConfig->u.type0.SubSystemID != Parameters->SubSystemID))
+ {
+ return FALSE;
+ }
+ if ((Parameters->Flags & PCI_USE_REVISION) &&
+ PciConfig->RevisionID != Parameters->RevisionID)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+static BOOLEAN NTAPI
+InterfacePciDevicePresentEx(
+ IN PVOID Context,
+ IN PPCI_DEVICE_PRESENCE_PARAMETERS Parameters)
+{
+ PPDO_DEVICE_EXTENSION DeviceExtension;
+ PFDO_DEVICE_EXTENSION MyFdoDeviceExtension;
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PPCI_DEVICE PciDevice;
+ PLIST_ENTRY CurrentBus, CurrentEntry;
+ KIRQL OldIrql;
+ BOOLEAN Found = FALSE;
+
+ DPRINT("InterfacePciDevicePresentEx(%p %p) called\n",
+ Context, Parameters);
+
+ if (!Parameters || Parameters->Size != sizeof(PCI_DEVICE_PRESENCE_PARAMETERS))
+ return FALSE;
+
+ DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+ MyFdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceExtension->Fdo->DeviceExtension;
+
+ if (Parameters->Flags & PCI_USE_LOCAL_DEVICE)
+ {
+ return CheckPciDevice(&DeviceExtension->PciDevice->PciConfig, Parameters);
+ }
+
+ KeAcquireSpinLock(&DriverExtension->BusListLock, &OldIrql);
+ CurrentBus = DriverExtension->BusListHead.Flink;
+ while (!Found && CurrentBus != &DriverExtension->BusListHead)
+ {
+ FdoDeviceExtension = CONTAINING_RECORD(CurrentBus, FDO_DEVICE_EXTENSION, ListEntry);
+ if (!(Parameters->Flags & PCI_USE_LOCAL_BUS) || FdoDeviceExtension == MyFdoDeviceExtension)
+ {
+ KeAcquireSpinLockAtDpcLevel(&FdoDeviceExtension->DeviceListLock);
+ CurrentEntry = FdoDeviceExtension->DeviceListHead.Flink;
+ while (!Found && CurrentEntry != &FdoDeviceExtension->DeviceListHead)
+ {
+ PciDevice = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
+
+ if (CheckPciDevice(&PciDevice->PciConfig, Parameters))
+ {
+ DPRINT("Found the PCI device\n");
+ Found = TRUE;
+ }
+
+ CurrentEntry = CurrentEntry->Flink;
+ }
+
+ KeReleaseSpinLockFromDpcLevel(&FdoDeviceExtension->DeviceListLock);
+ }
+ CurrentBus = CurrentBus->Flink;
+ }
+ KeReleaseSpinLock(&DriverExtension->BusListLock, OldIrql);
+
+ return Found;
+}
+
+
+static NTSTATUS
+PdoQueryInterface(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ PIO_STACK_LOCATION IrpSp)
+{
+ NTSTATUS Status;
+
+ if (RtlCompareMemory(IrpSp->Parameters.QueryInterface.InterfaceType,
+ &GUID_BUS_INTERFACE_STANDARD, sizeof(GUID)) == sizeof(GUID))
+ {
+ /* BUS_INTERFACE_STANDARD */
+ if (IrpSp->Parameters.QueryInterface.Version < 1)
+ Status = STATUS_NOT_SUPPORTED;
+ else if (IrpSp->Parameters.QueryInterface.Size < sizeof(BUS_INTERFACE_STANDARD))
+ Status = STATUS_BUFFER_TOO_SMALL;
+ else
+ {
+ PBUS_INTERFACE_STANDARD BusInterface;
+ BusInterface = (PBUS_INTERFACE_STANDARD)IrpSp->Parameters.QueryInterface.Interface;
+ BusInterface->Size = sizeof(BUS_INTERFACE_STANDARD);
+ BusInterface->Version = 1;
+ BusInterface->TranslateBusAddress = InterfaceBusTranslateBusAddress;
+ BusInterface->GetDmaAdapter = InterfaceBusGetDmaAdapter;
+ BusInterface->SetBusData = InterfaceBusSetBusData;
+ BusInterface->GetBusData = InterfaceBusGetBusData;
+ Status = STATUS_SUCCESS;
+ }
+ }
+ else if (RtlCompareMemory(IrpSp->Parameters.QueryInterface.InterfaceType,
+ &GUID_PCI_DEVICE_PRESENT_INTERFACE, sizeof(GUID)) == sizeof(GUID))
+ {
+ /* PCI_DEVICE_PRESENT_INTERFACE */
+ if (IrpSp->Parameters.QueryInterface.Version < 1)
+ Status = STATUS_NOT_SUPPORTED;
+ else if (IrpSp->Parameters.QueryInterface.Size < sizeof(PCI_DEVICE_PRESENT_INTERFACE))
+ Status = STATUS_BUFFER_TOO_SMALL;
+ else
+ {
+ PPCI_DEVICE_PRESENT_INTERFACE PciDevicePresentInterface;
+ PciDevicePresentInterface = (PPCI_DEVICE_PRESENT_INTERFACE)IrpSp->Parameters.QueryInterface.Interface;
+ PciDevicePresentInterface->Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
+ PciDevicePresentInterface->Version = 1;
+ PciDevicePresentInterface->IsDevicePresent = InterfacePciDevicePresent;
+ PciDevicePresentInterface->IsDevicePresentEx = InterfacePciDevicePresentEx;
+ Status = STATUS_SUCCESS;
+ }
+ }
+ else
+ {
+ /* Not a supported interface */
+ return STATUS_NOT_SUPPORTED;
+ }
+
+ if (NT_SUCCESS(Status))
+ {
+ /* Add a reference for the returned interface */
+ PINTERFACE Interface;
+ Interface = (PINTERFACE)IrpSp->Parameters.QueryInterface.Interface;
+ Interface->Context = DeviceObject;
+ Interface->InterfaceReference = InterfaceReference;
+ Interface->InterfaceDereference = InterfaceDereference;
+ Interface->InterfaceReference(Interface->Context);
+ }
+
+ return Status;
+}
+
+
static NTSTATUS
PdoReadConfig(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
- PPDO_DEVICE_EXTENSION DeviceExtension;
ULONG Size;
- DPRINT1("PdoReadConfig() called\n");
-
- DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ DPRINT("PdoReadConfig() called\n");
-#if 0
- if (IrpSp->Parameters.ReadWriteConfig.WhichSpace != PCI_WHICHSPACE_CONFIG)
- return STATUS_NOT_SUPPORTED;
-#endif
+ Size = InterfaceBusGetBusData(
+ DeviceObject,
+ IrpSp->Parameters.ReadWriteConfig.WhichSpace,
+ IrpSp->Parameters.ReadWriteConfig.Buffer,
+ IrpSp->Parameters.ReadWriteConfig.Offset,
+ IrpSp->Parameters.ReadWriteConfig.Length);
- /* Get PCI configuration space */
- Size= HalGetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
- IrpSp->Parameters.ReadWriteConfig.Buffer,
- IrpSp->Parameters.ReadWriteConfig.Offset,
- IrpSp->Parameters.ReadWriteConfig.Length);
if (Size != IrpSp->Parameters.ReadWriteConfig.Length)
{
DPRINT1("Size %lu Length %lu\n", Size, IrpSp->Parameters.ReadWriteConfig.Length);
IN PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
- PPDO_DEVICE_EXTENSION DeviceExtension;
ULONG Size;
DPRINT1("PdoWriteConfig() called\n");
- DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
-
-#if 0
- if (IrpSp->Parameters.ReadWriteConfig.WhichSpace != PCI_WHICHSPACE_CONFIG)
- return STATUS_NOT_SUPPORTED;
-#endif
-
/* Get PCI configuration space */
- Size= HalSetBusDataByOffset(PCIConfiguration,
- DeviceExtension->BusNumber,
- DeviceExtension->SlotNumber.u.AsULONG,
- IrpSp->Parameters.ReadWriteConfig.Buffer,
- IrpSp->Parameters.ReadWriteConfig.Offset,
- IrpSp->Parameters.ReadWriteConfig.Length);
+ Size = InterfaceBusSetBusData(
+ DeviceObject,
+ IrpSp->Parameters.ReadWriteConfig.WhichSpace,
+ IrpSp->Parameters.ReadWriteConfig.Buffer,
+ IrpSp->Parameters.ReadWriteConfig.Offset,
+ IrpSp->Parameters.ReadWriteConfig.Length);
+
if (Size != IrpSp->Parameters.ReadWriteConfig.Length)
{
DPRINT1("Size %lu Length %lu\n", Size, IrpSp->Parameters.ReadWriteConfig.Length);
Status = STATUS_SUCCESS;
break;
+ case IRP_MN_QUERY_INTERFACE:
+ DPRINT("IRP_MN_QUERY_INTERFACE received\n");
+ Status = PdoQueryInterface(DeviceObject, Irp, IrpSp);
+ break;
+
case IRP_MN_READ_CONFIG:
- DPRINT1("IRP_MN_READ_CONFIG received\n");
+ DPRINT("IRP_MN_READ_CONFIG received\n");
Status = PdoReadConfig(DeviceObject, Irp, IrpSp);
break;
case IRP_MN_WRITE_CONFIG:
- DPRINT1("IRP_MN_WRITE_CONFIG received\n");
+ DPRINT("IRP_MN_WRITE_CONFIG received\n");
Status = PdoWriteConfig(DeviceObject, Irp, IrpSp);
break;
default:
- DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
+ DPRINT1("Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
break;
}
projects / reactos.git / blobdiff