pci.h File Reference

#include <ntifs.h>
#include <wdmguid.h>
#include <wchar.h>
#include <acpiioct.h>
#include <drivers/pci/pci.h>
#include <drivers/acpi/acpi.h>
#include <ndk/halfuncs.h>
#include <ndk/rtlfuncs.h>
#include <ndk/vffuncs.h>
#include <arbiter.h>
#include <cmreslist.h>

Include dependency graph for pci.h:

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

Go to the source code of this file.

Classes
struct	_PCI_HACK_ENTRY
struct	_PCI_POWER_STATE
struct	_PCI_LOCK
struct	_PCI_FDO_EXTENSION
struct	_PCI_FUNCTION_RESOURCES
union	_PCI_HEADER_TYPE_DEPENDENT
struct	_PCI_PDO_EXTENSION
struct	_PCI_MN_DISPATCH_TABLE
struct	_PCI_MJ_DISPATCH_TABLE
struct	_PCI_INTERFACE
struct	PCI_SECONDARY_EXTENSION
struct	PCI_ARBITER_INSTANCE
struct	_PCI_VERIFIER_DATA
struct	_PCI_ID_BUFFER
struct	_PCI_CONFIGURATOR
struct	_PCI_CONFIGURATOR_CONTEXT
struct	_PCI_IPI_CONTEXT
struct	_PCI_LEGACY_DEVICE

Macros
#define	PCI_POOL_TAG   'BicP'
#define	PCI_IS_ROOT_FDO(x)   ((x)->BusRootFdoExtension == x)
#define	ASSERT_FDO(x)   ASSERT((x)->ExtensionType == PciFdoExtensionType);
#define	ASSERT_PDO(x)   ASSERT((x)->ExtensionType == PciPdoExtensionType);
#define	PCI_HACK_ENTRY_SIZE   sizeof(L"VVVVdddd") - sizeof(UNICODE_NULL)
#define	PCI_HACK_ENTRY_REV_SIZE   sizeof(L"VVVVddddRR") - sizeof(UNICODE_NULL)
#define	PCI_HACK_ENTRY_SUBSYS_SIZE   sizeof(L"VVVVddddssssIIII") - sizeof(UNICODE_NULL)
#define	PCI_HACK_ENTRY_FULL_SIZE   sizeof(L"VVVVddddssssIIIIRR") - sizeof(UNICODE_NULL)
#define	PCI_HACK_HAS_REVISION_INFO   0x01
#define	PCI_HACK_HAS_SUBSYSTEM_INFO   0x02
#define	PCI_INTERFACE_PDO   0x01
#define	PCI_INTERFACE_FDO   0x02
#define	PCI_INTERFACE_ROOT   0x04
#define	PCI_SKIP_DEVICE_ENUMERATION   0x01
#define	PCI_SKIP_RESOURCE_ENUMERATION   0x02
#define	PCI_HACK_FIXUP_BEFORE_CONFIGURATION   0x00
#define	PCI_HACK_FIXUP_AFTER_CONFIGURATION   0x01
#define	PCI_HACK_FIXUP_BEFORE_UPDATE   0x03
#define	MAX_DEBUGGING_DEVICES_SUPPORTED   0x04
#define	PCI_VERIFIER_CODES   0x04
#define	MAX_ANSI_STRINGS   0x08

Typedefs
typedef enum _PCI_SIGNATURE	PCI_SIGNATURE
typedef enum _PCI_SIGNATURE *	PPCI_SIGNATURE
typedef enum _PCI_DEVICE_TYPES	PCI_DEVICE_TYPES
typedef enum _PCI_STATE	PCI_STATE
typedef enum _PCI_DISPATCH_STYLE	PCI_DISPATCH_STYLE
typedef struct _PCI_HACK_ENTRY	PCI_HACK_ENTRY
typedef struct _PCI_HACK_ENTRY *	PPCI_HACK_ENTRY
typedef struct _PCI_POWER_STATE	PCI_POWER_STATE
typedef struct _PCI_POWER_STATE *	PPCI_POWER_STATE
typedef struct _PCI_LOCK	PCI_LOCK
typedef struct _PCI_LOCK *	PPCI_LOCK
typedef struct _PCI_FDO_EXTENSION	PCI_FDO_EXTENSION
typedef struct _PCI_FDO_EXTENSION *	PPCI_FDO_EXTENSION
typedef struct _PCI_FUNCTION_RESOURCES	PCI_FUNCTION_RESOURCES
typedef struct _PCI_FUNCTION_RESOURCES *	PPCI_FUNCTION_RESOURCES
typedef union _PCI_HEADER_TYPE_DEPENDENT	PCI_HEADER_TYPE_DEPENDENT
typedef union _PCI_HEADER_TYPE_DEPENDENT *	PPCI_HEADER_TYPE_DEPENDENT
typedef struct _PCI_PDO_EXTENSION	PCI_PDO_EXTENSION
typedef struct _PCI_PDO_EXTENSION *	PPCI_PDO_EXTENSION
typedef NTSTATUS(NTAPI *	PCI_DISPATCH_FUNCTION) (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PVOID DeviceExtension)
typedef struct _PCI_MN_DISPATCH_TABLE	PCI_MN_DISPATCH_TABLE
typedef struct _PCI_MN_DISPATCH_TABLE *	PPCI_MN_DISPATCH_TABLE
typedef struct _PCI_MJ_DISPATCH_TABLE	PCI_MJ_DISPATCH_TABLE
typedef struct _PCI_MJ_DISPATCH_TABLE *	PPCI_MJ_DISPATCH_TABLE
typedef NTSTATUS(NTAPI *	PCI_INTERFACE_CONSTRUCTOR) (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
typedef NTSTATUS(NTAPI *	PCI_INTERFACE_INITIALIZER) (IN PVOID Instance)
typedef struct _PCI_INTERFACE	PCI_INTERFACE
typedef struct _PCI_INTERFACE *	PPCI_INTERFACE
typedef struct PCI_SECONDARY_EXTENSION	PCI_SECONDARY_EXTENSION
typedef struct PCI_SECONDARY_EXTENSION *	PPCI_SECONDARY_EXTENSION
typedef struct PCI_ARBITER_INSTANCE	PCI_ARBITER_INSTANCE
typedef struct PCI_ARBITER_INSTANCE *	PPCI_ARBITER_INSTANCE
typedef struct _PCI_VERIFIER_DATA	PCI_VERIFIER_DATA
typedef struct _PCI_VERIFIER_DATA *	PPCI_VERIFIER_DATA
typedef struct _PCI_ID_BUFFER	PCI_ID_BUFFER
typedef struct _PCI_ID_BUFFER *	PPCI_ID_BUFFER
typedef VOID(NTAPI *	PCI_CONFIGURATOR_INITIALIZE) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_RESTORE_CURRENT) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_SAVE_LIMITS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_SAVE_CURRENT_SETTINGS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_CHANGE_RESOURCE_SETTINGS) (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_GET_ADDITIONAL_RESOURCE_DESCRIPTORS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context, IN PPCI_COMMON_HEADER PciData, IN PIO_RESOURCE_DESCRIPTOR IoDescriptor)
typedef VOID(NTAPI *	PCI_CONFIGURATOR_RESET_DEVICE) (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
typedef struct _PCI_CONFIGURATOR	PCI_CONFIGURATOR
typedef struct _PCI_CONFIGURATOR *	PPCI_CONFIGURATOR
typedef struct _PCI_CONFIGURATOR_CONTEXT	PCI_CONFIGURATOR_CONTEXT
typedef struct _PCI_CONFIGURATOR_CONTEXT *	PPCI_CONFIGURATOR_CONTEXT
typedef VOID(NTAPI *	PCI_IPI_FUNCTION) (IN PVOID Reserved, IN PVOID Context)
typedef struct _PCI_IPI_CONTEXT	PCI_IPI_CONTEXT
typedef struct _PCI_IPI_CONTEXT *	PPCI_IPI_CONTEXT
typedef struct _PCI_LEGACY_DEVICE	PCI_LEGACY_DEVICE
typedef struct _PCI_LEGACY_DEVICE *	PPCI_LEGACY_DEVICE

Enumerations
enum	_PCI_SIGNATURE {   PciPdoExtensionType = 'icP0' , PciFdoExtensionType = 'icP1' , PciArb_Io = 'icP2' , PciArb_Memory = 'icP3' ,   PciArb_Interrupt = 'icP4' , PciArb_BusNumber = 'icP5' , PciTrans_Interrupt = 'icP6' , PciInterface_BusHandler = 'icP7' ,   PciInterface_IntRouteHandler = 'icP8' , PciInterface_PciCb = 'icP9' , PciInterface_LegacyDeviceDetection = 'icP:' , PciInterface_PmeHandler = 'icP;' ,   PciInterface_DevicePresent = 'icP<' , PciInterface_NativeIde = 'icP=' , PciInterface_AgpTarget = 'icP>' , PciInterface_Location = 'icP?' }
enum	_PCI_DEVICE_TYPES {   PciTypeInvalid , PciTypeHostBridge , PciTypePciBridge , PciTypeCardbusBridge ,   PciTypeDevice }
enum	_PCI_STATE {   PciNotStarted , PciStarted , PciDeleted , PciStopped ,   PciSurpriseRemoved , PciSynchronizedOperation , PciMaxObjectState }
enum	_PCI_DISPATCH_STYLE { IRP_COMPLETE , IRP_DOWNWARD , IRP_UPWARD , IRP_DISPATCH }

Functions
NTSTATUS NTAPI	PciDispatchIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	PciIrpNotSupported (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPassIrpFromFdoToPdo (IN PPCI_FDO_EXTENSION DeviceExtension, IN PIRP Irp)
NTSTATUS NTAPI	PciCallDownIrpStack (IN PPCI_FDO_EXTENSION DeviceExtension, IN PIRP Irp)
NTSTATUS NTAPI	PciIrpInvalidDeviceRequest (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoWaitWake (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoSetPowerState (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryPower (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciSetPowerManagedDevicePowerState (IN PPCI_PDO_EXTENSION DeviceExtension, IN DEVICE_POWER_STATE DeviceState, IN BOOLEAN IrpSet)
NTSTATUS NTAPI	PciAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS NTAPI	PciFdoIrpStartDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpCancelRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpCancelStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryDeviceRelations (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryInterface (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryCapabilities (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpDeviceUsageNotification (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpSurpriseRemoval (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciFdoIrpQueryLegacyBusInformation (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoCreate (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCI_SLOT_NUMBER Slot, OUT PDEVICE_OBJECT *PdoDeviceObject)
NTSTATUS NTAPI	PciPdoWaitWake (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoSetPowerState (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryPower (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpStartDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpCancelRemoveDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpCancelStopDevice (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryDeviceRelations (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryInterface (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryCapabilities (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryResources (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryResourceRequirements (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryDeviceText (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpReadConfig (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpWriteConfig (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryId (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryDeviceState (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryBusInformation (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpDeviceUsageNotification (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpSurpriseRemoval (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciPdoIrpQueryLegacyBusInformation (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_PDO_EXTENSION DeviceExtension)
VOID NTAPI	PciHookHal (VOID)
VOID NTAPI	PciVerifierInit (IN PDRIVER_OBJECT DriverObject)
PPCI_VERIFIER_DATA NTAPI	PciVerifierRetrieveFailureData (IN ULONG FailureCode)
BOOLEAN NTAPI	PciStringToUSHORT (IN PWCHAR String, OUT PUSHORT Value)
BOOLEAN NTAPI	PciIsDatacenter (VOID)
NTSTATUS NTAPI	PciBuildDefaultExclusionLists (VOID)
BOOLEAN NTAPI	PciUnicodeStringStrStr (IN PUNICODE_STRING InputString, IN PCUNICODE_STRING EqualString, IN BOOLEAN CaseInSensitive)
BOOLEAN NTAPI	PciOpenKey (IN PWCHAR KeyName, IN HANDLE RootKey, IN ACCESS_MASK DesiredAccess, OUT PHANDLE KeyHandle, OUT PNTSTATUS KeyStatus)
NTSTATUS NTAPI	PciGetRegistryValue (IN PWCHAR ValueName, IN PWCHAR KeyName, IN HANDLE RootHandle, IN ULONG Type, OUT PVOID *OutputBuffer, OUT PULONG OutputLength)
PPCI_FDO_EXTENSION NTAPI	PciFindParentPciFdoExtension (IN PDEVICE_OBJECT DeviceObject, IN PKEVENT Lock)
VOID NTAPI	PciInsertEntryAtTail (IN PSINGLE_LIST_ENTRY ListHead, IN PPCI_FDO_EXTENSION DeviceExtension, IN PKEVENT Lock)
NTSTATUS NTAPI	PciGetDeviceProperty (IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, OUT PVOID *OutputBuffer)
NTSTATUS NTAPI	PciSendIoctl (IN PDEVICE_OBJECT DeviceObject, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength)
VOID NTAPI	PcipLinkSecondaryExtension (IN PSINGLE_LIST_ENTRY List, IN PVOID Lock, IN PPCI_SECONDARY_EXTENSION SecondaryExtension, IN PCI_SIGNATURE ExtensionType, IN PVOID Destructor)
PPCI_SECONDARY_EXTENSION NTAPI	PciFindNextSecondaryExtension (IN PSINGLE_LIST_ENTRY ListHead, IN PCI_SIGNATURE ExtensionType)
ULONGLONG NTAPI	PciGetHackFlags (IN USHORT VendorId, IN USHORT DeviceId, IN USHORT SubVendorId, IN USHORT SubSystemId, IN UCHAR RevisionId)
PPCI_PDO_EXTENSION NTAPI	PciFindPdoByFunction (IN PPCI_FDO_EXTENSION DeviceExtension, IN ULONG FunctionNumber, IN PPCI_COMMON_HEADER PciData)
BOOLEAN NTAPI	PciIsCriticalDeviceClass (IN UCHAR BaseClass, IN UCHAR SubClass)
BOOLEAN NTAPI	PciIsDeviceOnDebugPath (IN PPCI_PDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciGetBiosConfig (IN PPCI_PDO_EXTENSION DeviceExtension, OUT PPCI_COMMON_HEADER PciData)
NTSTATUS NTAPI	PciSaveBiosConfig (IN PPCI_PDO_EXTENSION DeviceExtension, OUT PPCI_COMMON_HEADER PciData)
UCHAR NTAPI	PciReadDeviceCapability (IN PPCI_PDO_EXTENSION DeviceExtension, IN UCHAR Offset, IN ULONG CapabilityId, OUT PPCI_CAPABILITIES_HEADER Buffer, IN ULONG Length)
BOOLEAN NTAPI	PciCanDisableDecodes (IN PPCI_PDO_EXTENSION DeviceExtension, IN PPCI_COMMON_HEADER Config, IN ULONGLONG HackFlags, IN BOOLEAN ForPowerDown)
PCI_DEVICE_TYPES NTAPI	PciClassifyDeviceType (IN PPCI_PDO_EXTENSION PdoExtension)
ULONG_PTR NTAPI	PciExecuteCriticalSystemRoutine (IN ULONG_PTR IpiContext)
BOOLEAN NTAPI	PciCreateIoDescriptorFromBarLimit (PIO_RESOURCE_DESCRIPTOR ResourceDescriptor, IN PULONG BarArray, IN BOOLEAN Rom)
BOOLEAN NTAPI	PciIsSlotPresentInParentMethod (IN PPCI_PDO_EXTENSION PdoExtension, IN ULONG Method)
VOID NTAPI	PciDecodeEnable (IN PPCI_PDO_EXTENSION PdoExtension, IN BOOLEAN Enable, OUT PUSHORT Command)
NTSTATUS NTAPI	PciQueryBusInformation (IN PPCI_PDO_EXTENSION PdoExtension, OUT PPNP_BUS_INFORMATION *Buffer)
NTSTATUS NTAPI	PciQueryCapabilities (IN PPCI_PDO_EXTENSION PdoExtension, IN OUT PDEVICE_CAPABILITIES DeviceCapability)
NTSTATUS NTAPI	PciGetConfigHandlers (IN PPCI_FDO_EXTENSION FdoExtension)
VOID NTAPI	PciReadSlotConfig (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCI_SLOT_NUMBER Slot, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
VOID NTAPI	PciWriteDeviceConfig (IN PPCI_PDO_EXTENSION DeviceExtension, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
VOID NTAPI	PciReadDeviceConfig (IN PPCI_PDO_EXTENSION DeviceExtension, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
UCHAR NTAPI	PciGetAdjustedInterruptLine (IN PPCI_PDO_EXTENSION PdoExtension)
VOID NTAPI	PciInitializeState (IN PPCI_FDO_EXTENSION DeviceExtension)
NTSTATUS NTAPI	PciBeginStateTransition (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCI_STATE NewState)
NTSTATUS NTAPI	PciCancelStateTransition (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCI_STATE NewState)
VOID NTAPI	PciCommitStateTransition (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCI_STATE NewState)
NTSTATUS NTAPI	PciInitializeArbiters (IN PPCI_FDO_EXTENSION FdoExtension)
NTSTATUS NTAPI	PciInitializeArbiterRanges (IN PPCI_FDO_EXTENSION DeviceExtension, IN PCM_RESOURCE_LIST Resources)
BOOLEAN NTAPI	PciDebugIrpDispatchDisplay (IN PIO_STACK_LOCATION IoStackLocation, IN PPCI_FDO_EXTENSION DeviceExtension, IN USHORT MaxMinor)
VOID NTAPI	PciDebugDumpCommonConfig (IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	PciDebugDumpQueryCapabilities (IN PDEVICE_CAPABILITIES DeviceCaps)
VOID NTAPI	PciDebugPrintIoResReqList (IN PIO_RESOURCE_REQUIREMENTS_LIST Requirements)
VOID NTAPI	PciDebugPrintCmResList (IN PCM_RESOURCE_LIST ResourceList)
VOID NTAPI	PciDebugPrintPartialResource (IN PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResource)
NTSTATUS NTAPI	PciQueryInterface (IN PPCI_FDO_EXTENSION DeviceExtension, IN CONST GUID *InterfaceType, IN ULONG Size, IN ULONG Version, IN PVOID InterfaceData, IN PINTERFACE Interface, IN BOOLEAN LastChance)
NTSTATUS NTAPI	PciPmeInterfaceInitializer (IN PVOID Instance)
NTSTATUS NTAPI	routeintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	arbusno_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	agpintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	tranirq_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	busintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	armem_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	ario_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	locintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	pcicbintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	lddintrf_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	devpresent_Initializer (IN PVOID Instance)
NTSTATUS NTAPI	agpintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	arbusno_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	tranirq_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	armem_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	busintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	ario_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
VOID NTAPI	ario_ApplyBrokenVideoHack (IN PPCI_FDO_EXTENSION FdoExtension)
NTSTATUS NTAPI	pcicbintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	lddintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	locintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	PciPmeInterfaceConstructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	routeintrf_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	devpresent_Constructor (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)
NTSTATUS NTAPI	PciQueryDeviceRelations (IN PPCI_FDO_EXTENSION DeviceExtension, IN OUT PDEVICE_RELATIONS *pDeviceRelations)
NTSTATUS NTAPI	PciQueryResources (IN PPCI_PDO_EXTENSION PdoExtension, OUT PCM_RESOURCE_LIST *Buffer)
NTSTATUS NTAPI	PciQueryTargetDeviceRelations (IN PPCI_PDO_EXTENSION PdoExtension, IN OUT PDEVICE_RELATIONS *pDeviceRelations)
NTSTATUS NTAPI	PciQueryEjectionRelations (IN PPCI_PDO_EXTENSION PdoExtension, IN OUT PDEVICE_RELATIONS *pDeviceRelations)
NTSTATUS NTAPI	PciQueryRequirements (IN PPCI_PDO_EXTENSION PdoExtension, IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *RequirementsList)
BOOLEAN NTAPI	PciComputeNewCurrentSettings (IN PPCI_PDO_EXTENSION PdoExtension, IN PCM_RESOURCE_LIST ResourceList)
NTSTATUS NTAPI	PciSetResources (IN PPCI_PDO_EXTENSION PdoExtension, IN BOOLEAN DoReset, IN BOOLEAN SomethingSomethingDarkSide)
NTSTATUS NTAPI	PciBuildRequirementsList (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData, OUT PIO_RESOURCE_REQUIREMENTS_LIST *Buffer)
PWCHAR NTAPI	PciGetDeviceDescriptionMessage (IN UCHAR BaseClass, IN UCHAR SubClass)
NTSTATUS NTAPI	PciQueryDeviceText (IN PPCI_PDO_EXTENSION PdoExtension, IN DEVICE_TEXT_TYPE QueryType, IN ULONG Locale, OUT PWCHAR *Buffer)
NTSTATUS NTAPI	PciQueryId (IN PPCI_PDO_EXTENSION DeviceExtension, IN BUS_QUERY_ID_TYPE QueryType, OUT PWCHAR *Buffer)
VOID NTAPI	Cardbus_MassageHeaderForLimitsDetermination (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Cardbus_SaveCurrentSettings (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Cardbus_SaveLimits (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Cardbus_RestoreCurrent (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Cardbus_GetAdditionalResourceDescriptors (IN PPCI_CONFIGURATOR_CONTEXT Context, IN PPCI_COMMON_HEADER PciData, IN PIO_RESOURCE_DESCRIPTOR IoDescriptor)
VOID NTAPI	Cardbus_ResetDevice (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	Cardbus_ChangeResourceSettings (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	Device_MassageHeaderForLimitsDetermination (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Device_SaveCurrentSettings (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Device_SaveLimits (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Device_RestoreCurrent (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	Device_GetAdditionalResourceDescriptors (IN PPCI_CONFIGURATOR_CONTEXT Context, IN PPCI_COMMON_HEADER PciData, IN PIO_RESOURCE_DESCRIPTOR IoDescriptor)
VOID NTAPI	Device_ResetDevice (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	Device_ChangeResourceSettings (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	PPBridge_MassageHeaderForLimitsDetermination (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	PPBridge_SaveCurrentSettings (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	PPBridge_SaveLimits (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	PPBridge_RestoreCurrent (IN PPCI_CONFIGURATOR_CONTEXT Context)
VOID NTAPI	PPBridge_GetAdditionalResourceDescriptors (IN PPCI_CONFIGURATOR_CONTEXT Context, IN PPCI_COMMON_HEADER PciData, IN PIO_RESOURCE_DESCRIPTOR IoDescriptor)
VOID NTAPI	PPBridge_ResetDevice (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
VOID NTAPI	PPBridge_ChangeResourceSettings (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)
BOOLEAN NTAPI	PciAreBusNumbersConfigured (IN PPCI_PDO_EXTENSION PdoExtension)
NTSTATUS NTAPI	PciCacheLegacyDeviceRouting (IN PDEVICE_OBJECT DeviceObject, IN ULONG BusNumber, IN ULONG SlotNumber, IN UCHAR InterruptLine, IN UCHAR InterruptPin, IN UCHAR BaseClass, IN UCHAR SubClass, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PPCI_PDO_EXTENSION PdoExtension, OUT PDEVICE_OBJECT *pFoundDeviceObject)

Variables
DRIVER_DISPATCH	PciDispatchIrp
DRIVER_ADD_DEVICE	PciAddDevice
KIPI_BROADCAST_WORKER	PciExecuteCriticalSystemRoutine
SINGLE_LIST_ENTRY	PciFdoExtensionListHead
KEVENT	PciGlobalLock
PPCI_INTERFACE	PciInterfaces []
PCI_INTERFACE	ArbiterInterfaceBusNumber
PCI_INTERFACE	ArbiterInterfaceMemory
PCI_INTERFACE	ArbiterInterfaceIo
PCI_INTERFACE	BusHandlerInterface
PCI_INTERFACE	PciRoutingInterface
PCI_INTERFACE	PciCardbusPrivateInterface
PCI_INTERFACE	PciLegacyDeviceDetectionInterface
PCI_INTERFACE	PciPmeInterface
PCI_INTERFACE	PciDevicePresentInterface
PCI_INTERFACE	PciLocationInterface
PCI_INTERFACE	AgpTargetInterface
PCI_INTERFACE	TranslatorInterfaceInterrupt
PDRIVER_OBJECT	PciDriverObject
PWATCHDOG_TABLE	WdTable
PPCI_HACK_ENTRY	PciHackTable
BOOLEAN	PciAssignBusNumbers
BOOLEAN	PciEnableNativeModeATA
PPCI_IRQ_ROUTING_TABLE	PciIrqRoutingTable
BOOLEAN	PciRunningDatacenter
NTSYSAPI BOOLEAN	InitSafeBootMode

Macro Definition Documentation

ASSERT_FDO

#define ASSERT_FDO

(

x

)

ASSERT((x)->ExtensionType == PciFdoExtensionType);

Definition at line 37 of file pci.h.

ASSERT_PDO

#define ASSERT_PDO

(

x

)

ASSERT((x)->ExtensionType == PciPdoExtensionType);

Definition at line 38 of file pci.h.

MAX_ANSI_STRINGS

#define MAX_ANSI_STRINGS   0x08

Definition at line 87 of file pci.h.

MAX_DEBUGGING_DEVICES_SUPPORTED

#define MAX_DEBUGGING_DEVICES_SUPPORTED   0x04

Definition at line 77 of file pci.h.

PCI_HACK_ENTRY_FULL_SIZE

#define PCI_HACK_ENTRY_FULL_SIZE   sizeof(L"VVVVddddssssIIIIRR") - sizeof(UNICODE_NULL)

Definition at line 46 of file pci.h.

PCI_HACK_ENTRY_REV_SIZE

#define PCI_HACK_ENTRY_REV_SIZE   sizeof(L"VVVVddddRR") - sizeof(UNICODE_NULL)

Definition at line 44 of file pci.h.

PCI_HACK_ENTRY_SIZE

#define PCI_HACK_ENTRY_SIZE   sizeof(L"VVVVdddd") - sizeof(UNICODE_NULL)

Definition at line 43 of file pci.h.

PCI_HACK_ENTRY_SUBSYS_SIZE

#define PCI_HACK_ENTRY_SUBSYS_SIZE   sizeof(L"VVVVddddssssIIII") - sizeof(UNICODE_NULL)

Definition at line 45 of file pci.h.

PCI_HACK_FIXUP_AFTER_CONFIGURATION

#define PCI_HACK_FIXUP_AFTER_CONFIGURATION   0x01

Definition at line 71 of file pci.h.

PCI_HACK_FIXUP_BEFORE_CONFIGURATION

#define PCI_HACK_FIXUP_BEFORE_CONFIGURATION   0x00

Definition at line 70 of file pci.h.

PCI_HACK_FIXUP_BEFORE_UPDATE

#define PCI_HACK_FIXUP_BEFORE_UPDATE   0x03

Definition at line 72 of file pci.h.

PCI_HACK_HAS_REVISION_INFO

#define PCI_HACK_HAS_REVISION_INFO   0x01

Definition at line 51 of file pci.h.

PCI_HACK_HAS_SUBSYSTEM_INFO

#define PCI_HACK_HAS_SUBSYSTEM_INFO   0x02

Definition at line 52 of file pci.h.

PCI_INTERFACE_FDO

#define PCI_INTERFACE_FDO   0x02

Definition at line 58 of file pci.h.

PCI_INTERFACE_PDO

#define PCI_INTERFACE_PDO   0x01

Definition at line 57 of file pci.h.

PCI_INTERFACE_ROOT

#define PCI_INTERFACE_ROOT   0x04

Definition at line 59 of file pci.h.

PCI_IS_ROOT_FDO

#define PCI_IS_ROOT_FDO

(

x

)

((x)->BusRootFdoExtension == x)

Definition at line 32 of file pci.h.

PCI_POOL_TAG

#define PCI_POOL_TAG   'BicP'

Definition at line 27 of file pci.h.

PCI_SKIP_DEVICE_ENUMERATION

#define PCI_SKIP_DEVICE_ENUMERATION   0x01

Definition at line 64 of file pci.h.

PCI_SKIP_RESOURCE_ENUMERATION

#define PCI_SKIP_RESOURCE_ENUMERATION   0x02

Definition at line 65 of file pci.h.

PCI_VERIFIER_CODES

#define PCI_VERIFIER_CODES   0x04

Definition at line 82 of file pci.h.

Typedef Documentation

PCI_ARBITER_INSTANCE

typedef struct PCI_ARBITER_INSTANCE PCI_ARBITER_INSTANCE

PCI_CONFIGURATOR

typedef struct _PCI_CONFIGURATOR PCI_CONFIGURATOR

PCI_CONFIGURATOR_CHANGE_RESOURCE_SETTINGS

typedef VOID(NTAPI * PCI_CONFIGURATOR_CHANGE_RESOURCE_SETTINGS) (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)

Definition at line 455 of file pci.h.

PCI_CONFIGURATOR_CONTEXT

typedef struct _PCI_CONFIGURATOR_CONTEXT PCI_CONFIGURATOR_CONTEXT

PCI_CONFIGURATOR_GET_ADDITIONAL_RESOURCE_DESCRIPTORS

typedef VOID(NTAPI * PCI_CONFIGURATOR_GET_ADDITIONAL_RESOURCE_DESCRIPTORS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context, IN PPCI_COMMON_HEADER PciData, IN PIO_RESOURCE_DESCRIPTOR IoDescriptor)

Definition at line 460 of file pci.h.

PCI_CONFIGURATOR_INITIALIZE

typedef VOID(NTAPI * PCI_CONFIGURATOR_INITIALIZE) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)

Definition at line 439 of file pci.h.

PCI_CONFIGURATOR_RESET_DEVICE

typedef VOID(NTAPI * PCI_CONFIGURATOR_RESET_DEVICE) (IN PPCI_PDO_EXTENSION PdoExtension, IN PPCI_COMMON_HEADER PciData)

Definition at line 466 of file pci.h.

PCI_CONFIGURATOR_RESTORE_CURRENT

typedef VOID(NTAPI * PCI_CONFIGURATOR_RESTORE_CURRENT) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)

Definition at line 443 of file pci.h.

PCI_CONFIGURATOR_SAVE_CURRENT_SETTINGS

typedef VOID(NTAPI * PCI_CONFIGURATOR_SAVE_CURRENT_SETTINGS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)

Definition at line 451 of file pci.h.

PCI_CONFIGURATOR_SAVE_LIMITS

typedef VOID(NTAPI * PCI_CONFIGURATOR_SAVE_LIMITS) (IN struct _PCI_CONFIGURATOR_CONTEXT *Context)

Definition at line 447 of file pci.h.

PCI_DEVICE_TYPES

typedef enum _PCI_DEVICE_TYPES PCI_DEVICE_TYPES

PCI_DISPATCH_FUNCTION

typedef NTSTATUS(NTAPI * PCI_DISPATCH_FUNCTION) (IN PIRP Irp, IN PIO_STACK_LOCATION IoStackLocation, IN PVOID DeviceExtension)

Definition at line 325 of file pci.h.

PCI_DISPATCH_STYLE

typedef enum _PCI_DISPATCH_STYLE PCI_DISPATCH_STYLE

PCI_FDO_EXTENSION

typedef struct _PCI_FDO_EXTENSION PCI_FDO_EXTENSION

PCI_FUNCTION_RESOURCES

typedef struct _PCI_FUNCTION_RESOURCES PCI_FUNCTION_RESOURCES

PCI_HACK_ENTRY

typedef struct _PCI_HACK_ENTRY PCI_HACK_ENTRY

PCI_HEADER_TYPE_DEPENDENT

typedef union _PCI_HEADER_TYPE_DEPENDENT PCI_HEADER_TYPE_DEPENDENT

PCI_ID_BUFFER

typedef struct _PCI_ID_BUFFER PCI_ID_BUFFER

PCI_INTERFACE

typedef struct _PCI_INTERFACE PCI_INTERFACE

PCI_INTERFACE_CONSTRUCTOR

typedef NTSTATUS(NTAPI * PCI_INTERFACE_CONSTRUCTOR) (IN PVOID DeviceExtension, IN PVOID Instance, IN PVOID InterfaceData, IN USHORT Version, IN USHORT Size, IN PINTERFACE Interface)

Definition at line 359 of file pci.h.

PCI_INTERFACE_INITIALIZER

typedef NTSTATUS(NTAPI * PCI_INTERFACE_INITIALIZER) (IN PVOID Instance)

Definition at line 368 of file pci.h.

PCI_IPI_CONTEXT

typedef struct _PCI_IPI_CONTEXT PCI_IPI_CONTEXT

PCI_IPI_FUNCTION

typedef VOID(NTAPI * PCI_IPI_FUNCTION) (IN PVOID Reserved, IN PVOID Context)

Definition at line 502 of file pci.h.

PCI_LEGACY_DEVICE

typedef struct _PCI_LEGACY_DEVICE PCI_LEGACY_DEVICE

PCI_LOCK

typedef struct _PCI_LOCK PCI_LOCK

PCI_MJ_DISPATCH_TABLE

typedef struct _PCI_MJ_DISPATCH_TABLE PCI_MJ_DISPATCH_TABLE

PCI_MN_DISPATCH_TABLE

typedef struct _PCI_MN_DISPATCH_TABLE PCI_MN_DISPATCH_TABLE

PCI_PDO_EXTENSION

typedef struct _PCI_PDO_EXTENSION PCI_PDO_EXTENSION

PCI_POWER_STATE

typedef struct _PCI_POWER_STATE PCI_POWER_STATE

PCI_SECONDARY_EXTENSION

typedef struct PCI_SECONDARY_EXTENSION PCI_SECONDARY_EXTENSION

PCI_SIGNATURE

typedef enum _PCI_SIGNATURE PCI_SIGNATURE

PCI_STATE

typedef enum _PCI_STATE PCI_STATE

PCI_VERIFIER_DATA

typedef struct _PCI_VERIFIER_DATA PCI_VERIFIER_DATA

PPCI_ARBITER_INSTANCE

typedef struct PCI_ARBITER_INSTANCE * PPCI_ARBITER_INSTANCE

PPCI_CONFIGURATOR

typedef struct _PCI_CONFIGURATOR * PPCI_CONFIGURATOR

PPCI_CONFIGURATOR_CONTEXT

typedef struct _PCI_CONFIGURATOR_CONTEXT * PPCI_CONFIGURATOR_CONTEXT

PPCI_FDO_EXTENSION

typedef struct _PCI_FDO_EXTENSION * PPCI_FDO_EXTENSION

PPCI_FUNCTION_RESOURCES

typedef struct _PCI_FUNCTION_RESOURCES * PPCI_FUNCTION_RESOURCES

PPCI_HACK_ENTRY

typedef struct _PCI_HACK_ENTRY * PPCI_HACK_ENTRY

PPCI_HEADER_TYPE_DEPENDENT

typedef union _PCI_HEADER_TYPE_DEPENDENT * PPCI_HEADER_TYPE_DEPENDENT

PPCI_ID_BUFFER

typedef struct _PCI_ID_BUFFER * PPCI_ID_BUFFER

PPCI_INTERFACE

typedef struct _PCI_INTERFACE * PPCI_INTERFACE

PPCI_IPI_CONTEXT

typedef struct _PCI_IPI_CONTEXT * PPCI_IPI_CONTEXT

PPCI_LEGACY_DEVICE

typedef struct _PCI_LEGACY_DEVICE * PPCI_LEGACY_DEVICE

PPCI_LOCK

typedef struct _PCI_LOCK * PPCI_LOCK

PPCI_MJ_DISPATCH_TABLE

typedef struct _PCI_MJ_DISPATCH_TABLE * PPCI_MJ_DISPATCH_TABLE

PPCI_MN_DISPATCH_TABLE

typedef struct _PCI_MN_DISPATCH_TABLE * PPCI_MN_DISPATCH_TABLE

PPCI_PDO_EXTENSION

typedef struct _PCI_PDO_EXTENSION * PPCI_PDO_EXTENSION

PPCI_POWER_STATE

typedef struct _PCI_POWER_STATE * PPCI_POWER_STATE

PPCI_SECONDARY_EXTENSION

typedef struct PCI_SECONDARY_EXTENSION * PPCI_SECONDARY_EXTENSION

PPCI_SIGNATURE

typedef enum _PCI_SIGNATURE * PPCI_SIGNATURE

PPCI_VERIFIER_DATA

typedef struct _PCI_VERIFIER_DATA * PPCI_VERIFIER_DATA

Enumeration Type Documentation

_PCI_DEVICE_TYPES

enum _PCI_DEVICE_TYPES

Enumerator
PciTypeInvalid
PciTypeHostBridge
PciTypePciBridge
PciTypeCardbusBridge
PciTypeDevice

Definition at line 115 of file pci.h.

{
    PciTypeInvalid,
    PciTypeHostBridge,
    PciTypePciBridge,
    PciTypeCardbusBridge,
    PciTypeDevice
} PCI_DEVICE_TYPES;

_PCI_DISPATCH_STYLE

enum _PCI_DISPATCH_STYLE

Enumerator
IRP_COMPLETE
IRP_DOWNWARD
IRP_UPWARD
IRP_DISPATCH

Definition at line 141 of file pci.h.

{
    IRP_COMPLETE,
    IRP_DOWNWARD,
    IRP_UPWARD,
    IRP_DISPATCH,
} PCI_DISPATCH_STYLE;

_PCI_SIGNATURE

enum _PCI_SIGNATURE

Enumerator
PciPdoExtensionType
PciFdoExtensionType
PciArb_Io
PciArb_Memory
PciArb_Interrupt
PciArb_BusNumber
PciTrans_Interrupt
PciInterface_BusHandler
PciInterface_IntRouteHandler
PciInterface_PciCb
PciInterface_LegacyDeviceDetection
PciInterface_PmeHandler
PciInterface_DevicePresent
PciInterface_NativeIde
PciInterface_AgpTarget
PciInterface_Location

Definition at line 92 of file pci.h.

{
    PciPdoExtensionType = 'icP0',
    PciFdoExtensionType = 'icP1',
    PciArb_Io = 'icP2',
    PciArb_Memory = 'icP3',
    PciArb_Interrupt = 'icP4',
    PciArb_BusNumber = 'icP5',
    PciTrans_Interrupt = 'icP6',
    PciInterface_BusHandler = 'icP7',
    PciInterface_IntRouteHandler = 'icP8',
    PciInterface_PciCb = 'icP9',
    PciInterface_LegacyDeviceDetection = 'icP:',
    PciInterface_PmeHandler = 'icP;',
    PciInterface_DevicePresent = 'icP<',
    PciInterface_NativeIde = 'icP=',
    PciInterface_AgpTarget = 'icP>',
    PciInterface_Location  = 'icP?'
} PCI_SIGNATURE, *PPCI_SIGNATURE;

_PCI_STATE

enum _PCI_STATE

Enumerator
PciNotStarted
PciStarted
PciDeleted
PciStopped
PciSurpriseRemoved
PciSynchronizedOperation
PciMaxObjectState

Definition at line 127 of file pci.h.

{
    PciNotStarted,
    PciStarted,
    PciDeleted,
    PciStopped,
    PciSurpriseRemoved,
    PciSynchronizedOperation,
    PciMaxObjectState
} PCI_STATE;

Function Documentation

agpintrf_Constructor()

NTSTATUS NTAPI agpintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 47 of file agpintrf.c.

{
    PPCI_PDO_EXTENSION PdoExtension = (PPCI_PDO_EXTENSION)DeviceExtension;
 
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Only AGP bridges are supported (which are PCI-to-PCI Bridge Devices) */
    if ((PdoExtension->BaseClass != PCI_CLASS_BRIDGE_DEV) ||
        (PdoExtension->SubClass != PCI_SUBCLASS_BR_PCI_TO_PCI))
    {
        /* Fail any other PDO */
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

agpintrf_Initializer()

NTSTATUS NTAPI agpintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 37 of file agpintrf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI agpintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

arbusno_Constructor()

NTSTATUS NTAPI arbusno_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 73 of file ar_busno.c.

{
    PPCI_FDO_EXTENSION FdoExtension = (PPCI_FDO_EXTENSION)DeviceExtension;
    NTSTATUS Status;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(PciInterface);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Make sure it's the expected interface */
    if ((ULONG_PTR)InterfaceData != CmResourceTypeBusNumber)
    {
        /* Arbiter support must have been initialized first */
        if (FdoExtension->ArbitersInitialized)
        {
            /* Not yet implemented */
            UNIMPLEMENTED;
            while (TRUE);
        }
        else
        {
            /* No arbiters for this FDO */
            Status = STATUS_NOT_SUPPORTED;
        }
    }
    else
    {
        /* Not the right interface */
        Status = STATUS_INVALID_PARAMETER_5;
    }
 
    /* Return the status */
    return Status;
}

arbusno_Initializer()

NTSTATUS NTAPI arbusno_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file ar_busno.c.

{
    PPCI_ARBITER_INSTANCE Arbiter = Instance;
    PPCI_FDO_EXTENSION FdoExtension;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    RtlZeroMemory(&Arbiter->CommonInstance, sizeof(Arbiter->CommonInstance));
 
    FdoExtension = Arbiter->BusFdoExtension;
 
    /* Not yet implemented */
    UNIMPLEMENTED;
 
#if 0
    Arbiter->CommonInstance.UnpackRequirement = arbusno_UnpackRequirement;
    Arbiter->CommonInstance.PackResource = arbusno_PackResource;
    Arbiter->CommonInstance.UnpackResource = arbusno_UnpackResource;
    Arbiter->CommonInstance.ScoreRequirement = arbusno_ScoreRequirement;
#endif
 
    Status = ArbInitializeArbiterInstance(&Arbiter->CommonInstance,
                                          FdoExtension->FunctionalDeviceObject,
                                          CmResourceTypeBusNumber,
                                          Arbiter->InstanceName,
                                          L"Pci",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("arbusno_Initializer: init arbiter return %X", Status);
    }
 
    return Status;
}

ario_ApplyBrokenVideoHack()

VOID NTAPI ario_ApplyBrokenVideoHack

(

IN PPCI_FDO_EXTENSION

FdoExtension

)

Definition at line 104 of file ar_memio.c.

{
    PPCI_ARBITER_INSTANCE PciArbiter;
    //PARBITER_INSTANCE CommonInstance;
    //NTSTATUS Status;
 
    /* Only valid for root FDOs who are being applied the hack for the first time */
    ASSERT(!FdoExtension->BrokenVideoHackApplied);
    ASSERT(PCI_IS_ROOT_FDO(FdoExtension));
 
    /* Find the I/O arbiter */
    PciArbiter = (PVOID)PciFindNextSecondaryExtension(FdoExtension->
                                                      SecondaryExtension.Next,
                                                      PciArb_Io);
    ASSERT(PciArbiter);
#if 0 // when arb exist
    /* Get the Arb instance */
    CommonInstance = &PciArbiter->CommonInstance;
 
    /* Free the two lists, enabling full VGA access */
    ArbFreeOrderingList(&CommonInstance->OrderingList);
    ArbFreeOrderingList(&CommonInstance->ReservedList);
 
    /* Build the ordering for broken video PCI access */
    Status = ArbBuildAssignmentOrdering(CommonInstance,
                                        L"Pci",
                                        L"BrokenVideo",
                                        NULL);
    ASSERT(NT_SUCCESS(Status));
#else
    //Status = STATUS_SUCCESS;
    UNIMPLEMENTED;
    while (TRUE);
#endif
    /* Now the hack has been applied */
    FdoExtension->BrokenVideoHackApplied = TRUE;
}

Referenced by PciApplyHacks().

ario_Constructor()

NTSTATUS NTAPI ario_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 60 of file ar_memio.c.

{
    PPCI_FDO_EXTENSION FdoExtension = (PPCI_FDO_EXTENSION)DeviceExtension;
    NTSTATUS Status;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(PciInterface);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Make sure it's the expected interface */
    if ((ULONG_PTR)InterfaceData != CmResourceTypePort)
    {
        /* Arbiter support must have been initialized first */
        if (FdoExtension->ArbitersInitialized)
        {
            /* Not yet implemented */
            UNIMPLEMENTED;
            while (TRUE);
        }
        else
        {
            /* No arbiters for this FDO */
            Status = STATUS_NOT_SUPPORTED;
        }
    }
    else
    {
        /* Not the right interface */
        Status = STATUS_INVALID_PARAMETER_5;
    }
 
    /* Return the status */
    return Status;
}

ario_Initializer()

NTSTATUS NTAPI ario_Initializer

(

IN PVOID

Instance

)

Definition at line 48 of file ar_memio.c.

{
    UNREFERENCED_PARAMETER(Instance);
 
    /* Not yet implemented */
    UNIMPLEMENTED;
    //while (TRUE);
    return STATUS_SUCCESS;
}

armem_Constructor()

NTSTATUS NTAPI armem_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 156 of file ar_memio.c.

{
    PPCI_FDO_EXTENSION FdoExtension = (PPCI_FDO_EXTENSION)DeviceExtension;
    NTSTATUS Status;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(PciInterface);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Make sure it's the expected interface */
    if ((ULONG_PTR)InterfaceData != CmResourceTypeMemory)
    {
        /* Arbiter support must have been initialized first */
        if (FdoExtension->ArbitersInitialized)
        {
            /* Not yet implemented */
            UNIMPLEMENTED;
            while (TRUE);
        }
        else
        {
            /* No arbiters for this FDO */
            Status = STATUS_NOT_SUPPORTED;
        }
    }
    else
    {
        /* Not the right interface */
        Status = STATUS_INVALID_PARAMETER_5;
    }
 
    /* Return the status */
    return Status;
}

armem_Initializer()

NTSTATUS NTAPI armem_Initializer

(

IN PVOID

Instance

)

Definition at line 144 of file ar_memio.c.

{
    UNREFERENCED_PARAMETER(Instance);
 
    /* Not yet implemented */
    UNIMPLEMENTED;
    //while (TRUE);
    return STATUS_SUCCESS;
}

busintrf_Constructor()

NTSTATUS NTAPI busintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file busintrf.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

busintrf_Initializer()

NTSTATUS NTAPI busintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file busintrf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI busintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

Cardbus_ChangeResourceSettings()

VOID NTAPI Cardbus_ChangeResourceSettings	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 89 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_GetAdditionalResourceDescriptors()

VOID NTAPI Cardbus_GetAdditionalResourceDescriptors	(	IN PPCI_CONFIGURATOR_CONTEXT	Context,
		IN PPCI_COMMON_HEADER	PciData,
		IN PIO_RESOURCE_DESCRIPTOR	IoDescriptor
	)

Definition at line 67 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(PciData);
    UNREFERENCED_PARAMETER(IoDescriptor);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_MassageHeaderForLimitsDetermination()

VOID NTAPI Cardbus_MassageHeaderForLimitsDetermination

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 51 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_ResetDevice()

VOID NTAPI Cardbus_ResetDevice	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 79 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_RestoreCurrent()

VOID NTAPI Cardbus_RestoreCurrent

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 59 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_SaveCurrentSettings()

VOID NTAPI Cardbus_SaveCurrentSettings

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 35 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNIMPLEMENTED_DBGBREAK();
}

Cardbus_SaveLimits()

VOID NTAPI Cardbus_SaveLimits

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 43 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNIMPLEMENTED_DBGBREAK();
}

Device_ChangeResourceSettings()

VOID NTAPI Device_ChangeResourceSettings	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 283 of file device.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
}

Device_GetAdditionalResourceDescriptors()

VOID NTAPI Device_GetAdditionalResourceDescriptors	(	IN PPCI_CONFIGURATOR_CONTEXT	Context,
		IN PPCI_COMMON_HEADER	PciData,
		IN PIO_RESOURCE_DESCRIPTOR	IoDescriptor
	)

Definition at line 259 of file device.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(PciData);
    UNREFERENCED_PARAMETER(IoDescriptor);
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
}

Device_MassageHeaderForLimitsDetermination()

VOID NTAPI Device_MassageHeaderForLimitsDetermination

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 218 of file device.c.

{
    PPCI_COMMON_HEADER PciData;
    PPCI_PDO_EXTENSION PdoExtension;
    PULONG BarArray;
    ULONG i = 0;
 
    /* Get pointers from context data */
    PdoExtension = Context->PdoExtension;
    PciData = Context->PciData;
 
    /* Get the array of BARs */
    BarArray = PciData->u.type0.BaseAddresses;
 
    /* Check for IDE controllers that are not in native mode */
    if ((PdoExtension->BaseClass == PCI_CLASS_MASS_STORAGE_CTLR) &&
        (PdoExtension->SubClass == PCI_SUBCLASS_MSC_IDE_CTLR) &&
        (PdoExtension->ProgIf & 5) != 5)
    {
        /* These controllers only use legacy resources */
        i = 4;
    }
 
    /* Set all the bits on, which will allow us to recover the limit data */
    for (i = 0; i < PCI_TYPE0_ADDRESSES; i++) BarArray[i] = 0xFFFFFFFF;
 
    /* Do the same for the PCI ROM BAR */
    PciData->u.type0.ROMBaseAddress = PCI_ADDRESS_ROM_ADDRESS_MASK;
}

Device_ResetDevice()

VOID NTAPI Device_ResetDevice	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 272 of file device.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
}

Device_RestoreCurrent()

VOID NTAPI Device_RestoreCurrent

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 250 of file device.c.

{
    UNREFERENCED_PARAMETER(Context);
    /* Nothing to do for devices */
    return;
}

Device_SaveCurrentSettings()

VOID NTAPI Device_SaveCurrentSettings

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 20 of file device.c.

{
    PPCI_COMMON_HEADER PciData;
    PIO_RESOURCE_DESCRIPTOR IoDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor;
    PPCI_FUNCTION_RESOURCES Resources;
    PULONG BarArray;
    ULONG Bar, BarMask, i;
 
    /* Get variables from context */
    PciData = Context->Current;
    Resources = Context->PdoExtension->Resources;
 
    /* Loop all the PCI BARs */
    BarArray = PciData->u.type0.BaseAddresses;
    for (i = 0; i <= PCI_TYPE0_ADDRESSES; i++)
    {
        /* Get the resource descriptor and limit descriptor for this BAR */
        CmDescriptor = &Resources->Current[i];
        IoDescriptor = &Resources->Limit[i];
 
        /* Build the resource descriptor based on the limit descriptor */
        CmDescriptor->Type = IoDescriptor->Type;
        if (CmDescriptor->Type == CmResourceTypeNull) continue;
        CmDescriptor->Flags = IoDescriptor->Flags;
        CmDescriptor->ShareDisposition = IoDescriptor->ShareDisposition;
        CmDescriptor->u.Generic.Start.HighPart = 0;
        CmDescriptor->u.Generic.Length = IoDescriptor->u.Generic.Length;
 
        /* Check if we're handling PCI BARs, or the ROM BAR */
        if (i < PCI_TYPE0_ADDRESSES)
        {
            /* Read the actual BAR value */
            Bar = BarArray[i];
 
            /* Check if this is an I/O BAR */
            if (Bar & PCI_ADDRESS_IO_SPACE)
            {
                /* Use the right mask to get the I/O port base address */
                ASSERT(CmDescriptor->Type == CmResourceTypePort);
                BarMask = PCI_ADDRESS_IO_ADDRESS_MASK;
            }
            else
            {
                /* It's a RAM BAR, use the right mask to get the base address */
                ASSERT(CmDescriptor->Type == CmResourceTypeMemory);
                BarMask = PCI_ADDRESS_MEMORY_ADDRESS_MASK;
 
                /* Check if it's a 64-bit BAR */
                if ((Bar & PCI_ADDRESS_MEMORY_TYPE_MASK) == PCI_TYPE_64BIT)
                {
                    /* The next BAR value is actually the high 32-bits */
                    CmDescriptor->u.Memory.Start.HighPart = BarArray[i + 1];
                }
                else if ((Bar & PCI_ADDRESS_MEMORY_TYPE_MASK) == PCI_TYPE_20BIT)
                {
                    /* Legacy BAR, don't read more than 20 bits of the address */
                    BarMask = 0xFFFF0;
                }
            }
        }
        else
        {
            /* Actually a ROM BAR, so read the correct register */
            Bar = PciData->u.type0.ROMBaseAddress;
 
            /* Apply the correct mask for ROM BARs */
            BarMask = PCI_ADDRESS_ROM_ADDRESS_MASK;
 
            /* Make sure it's enabled */
            if (!(Bar & PCI_ROMADDRESS_ENABLED))
            {
                /* If it isn't, then a descriptor won't be built for it */
                CmDescriptor->Type = CmResourceTypeNull;
                continue;
            }
        }
 
        /* Now we have the right mask, read the actual address from the BAR */
        Bar &= BarMask;
        CmDescriptor->u.Memory.Start.LowPart = Bar;
 
        /* And check for invalid BAR addresses */
        if (!(CmDescriptor->u.Memory.Start.HighPart | Bar))
        {
            /* Skip these descriptors */
            CmDescriptor->Type = CmResourceTypeNull;
            DPRINT1("Invalid BAR\n");
        }
    }
 
    /* Also save the sub-IDs that came directly from the PCI header */
    Context->PdoExtension->SubsystemVendorId = PciData->u.type0.SubVendorID;
    Context->PdoExtension->SubsystemId = PciData->u.type0.SubSystemID;
}

Device_SaveLimits()

VOID NTAPI Device_SaveLimits

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 118 of file device.c.

{
    PPCI_COMMON_HEADER Current, PciData;
    PPCI_PDO_EXTENSION PdoExtension;
    PULONG BarArray;
    PIO_RESOURCE_DESCRIPTOR Limit;
    ULONG i;
 
    /* Get pointers from the context */
    PdoExtension = Context->PdoExtension;
    Current = Context->Current;
    PciData = Context->PciData;
 
    /* And get the array of bARs */
    BarArray = PciData->u.type0.BaseAddresses;
 
    /* First, check for IDE controllers that are not in native mode */
    if ((PdoExtension->BaseClass == PCI_CLASS_MASS_STORAGE_CTLR) &&
        (PdoExtension->SubClass == PCI_SUBCLASS_MSC_IDE_CTLR) &&
        (PdoExtension->ProgIf & 5) != 5)
    {
        /* They should not be using any non-legacy resources */
        BarArray[0] = 0;
        BarArray[1] = 0;
        BarArray[2] = 0;
        BarArray[3] = 0;
    }
    else if ((PdoExtension->VendorId == 0x5333) &&
             ((PdoExtension->DeviceId == 0x88F0) ||
              (PdoExtension->DeviceId == 0x8880)))
    {
        /*
         * The problem is caused by the S3 Vision 968/868 video controller which
         * is used on the Diamond Stealth 64 Video 3000 series, Number Nine 9FX
         * motion 771, and other popular video cards, all containing a memory bug.
         * The 968/868 claims to require 32 MB of memory, but it actually decodes
         * 64 MB of memory.
         */
        for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
        {
            /* Find its 32MB RAM BAR */
            if (BarArray[i] == 0xFE000000)
            {
                /* Increase it to 64MB to make sure nobody touches the buffer */
                BarArray[i] = 0xFC000000;
                DPRINT1("PCI - Adjusted broken S3 requirement from 32MB to 64MB\n");
            }
        }
    }
 
    /* Check for Cirrus Logic GD5430/5440 cards */
    if ((PdoExtension->VendorId == 0x1013) && (PdoExtension->DeviceId == 0xA0))
    {
        /* Check for the I/O port requirement */
        if (BarArray[1] == 0xFC01)
        {
            /* Check for completely bogus BAR */
            if (Current->u.type0.BaseAddresses[1] == 1)
            {
                /* Ignore it */
                BarArray[1] = 0;
                DPRINT1("PCI - Ignored Cirrus GD54xx broken IO requirement (400 ports)\n");
            }
            else
            {
                /* Otherwise, this BAR seems okay */
                DPRINT1("PCI - Cirrus GD54xx 400 port IO requirement has a valid setting (%08x)\n",
                        Current->u.type0.BaseAddresses[1]);
            }
        }
        else if (BarArray[1])
        {
            /* Strange, the I/O BAR was not found as expected (or at all) */
            DPRINT1("PCI - Warning Cirrus Adapter 101300a0 has unexpected resource requirement (%08x)\n",
                    BarArray[1]);
        }
    }
 
    /* Finally, process all the limit descriptors */
    Limit = PdoExtension->Resources->Limit;
    for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
    {
        /* And build them based on the BARs */
        if (PciCreateIoDescriptorFromBarLimit(&Limit[i], &BarArray[i], FALSE))
        {
            /* This function returns TRUE if the BAR was 64-bit, handle this */
            ASSERT((i + 1) < PCI_TYPE0_ADDRESSES);
            i++;
            Limit[i].Type = CmResourceTypeNull;
        }
    }
 
    /* Create the last descriptor based on the ROM address */
    PciCreateIoDescriptorFromBarLimit(&Limit[i],
                                      &PciData->u.type0.ROMBaseAddress,
                                      TRUE);
}

devpresent_Constructor()

NTSTATUS NTAPI devpresent_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file devhere.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

devpresent_Initializer()

NTSTATUS NTAPI devpresent_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file devhere.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI devpresent_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

lddintrf_Constructor()

NTSTATUS NTAPI lddintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file lddintrf.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

lddintrf_Initializer()

NTSTATUS NTAPI lddintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file lddintrf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI lddintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

locintrf_Constructor()

NTSTATUS NTAPI locintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file locintrf.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

locintrf_Initializer()

NTSTATUS NTAPI locintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file locintrf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI locintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

PciAddDevice()

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

Definition at line 458 of file fdo.c.

{
    PCM_RESOURCE_LIST Descriptor;
    PDEVICE_OBJECT AttachedTo;
    PPCI_FDO_EXTENSION FdoExtension;
    PPCI_FDO_EXTENSION ParentExtension;
    PPCI_PDO_EXTENSION PdoExtension;
    PDEVICE_OBJECT DeviceObject;
    UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
    PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)Buffer;
    NTSTATUS Status;
    HANDLE KeyHandle;
    UNICODE_STRING ValueName;
    ULONG ResultLength;
    PAGED_CODE();
    DPRINT1("PCI - AddDevice (a new bus). PDO: %p (Driver: %wZ)\n",
            PhysicalDeviceObject, &PhysicalDeviceObject->DriverObject->DriverName);
 
    /* Zero out variables so failure path knows what to do */
    AttachedTo = NULL;
    FdoExtension = NULL;
    PdoExtension = NULL;
    DeviceObject = NULL;
 
    do
    {
        /* Check if there's already a device extension for this bus */
        ParentExtension = PciFindParentPciFdoExtension(PhysicalDeviceObject,
                                                       &PciGlobalLock);
        if (ParentExtension)
        {
            /* Make sure we find a real PDO */
            PdoExtension = PhysicalDeviceObject->DeviceExtension;
            ASSERT_PDO(PdoExtension);
 
            /* Make sure it's a PCI-to-PCI bridge */
            if ((PdoExtension->BaseClass != PCI_CLASS_BRIDGE_DEV) ||
                (PdoExtension->SubClass != PCI_SUBCLASS_BR_PCI_TO_PCI))
            {
                /* This should never happen */
                DPRINT1("PCI - PciAddDevice for Non-Root/Non-PCI-PCI bridge,\n"
                        "      Class %02x, SubClass %02x, will not add.\n",
                        PdoExtension->BaseClass,
                        PdoExtension->SubClass);
                ASSERT((PdoExtension->BaseClass == PCI_CLASS_BRIDGE_DEV) &&
                       (PdoExtension->SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI));
 
                /* Enter the failure path */
                Status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
 
            /* Subordinate bus on the bridge */
            DPRINT1("PCI - AddDevice (new bus is child of bus 0x%x).\n",
                    ParentExtension->BaseBus);
 
            /* Make sure PCI bus numbers are configured */
            if (!PciAreBusNumbersConfigured(PdoExtension))
            {
                /* This is a critical failure */
                DPRINT1("PCI - Bus numbers not configured for bridge (0x%x.0x%x.0x%x)\n",
                        ParentExtension->BaseBus,
                        PdoExtension->Slot.u.bits.DeviceNumber,
                        PdoExtension->Slot.u.bits.FunctionNumber);
 
                /* Enter the failure path */
                Status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
        }
 
        /* Create the FDO for the bus */
        Status = IoCreateDevice(DriverObject,
                                sizeof(PCI_FDO_EXTENSION),
                                NULL,
                                FILE_DEVICE_BUS_EXTENDER,
                                0,
                                0,
                                &DeviceObject);
        if (!NT_SUCCESS(Status)) break;
 
        /* Initialize the extension for the FDO */
        FdoExtension = DeviceObject->DeviceExtension;
        PciInitializeFdoExtensionCommonFields(DeviceObject->DeviceExtension,
                                              DeviceObject,
                                              PhysicalDeviceObject);
 
        /* Attach to the root PDO */
        Status = STATUS_NO_SUCH_DEVICE;
        AttachedTo = IoAttachDeviceToDeviceStack(DeviceObject,
                                                 PhysicalDeviceObject);
        ASSERT(AttachedTo != NULL);
        if (!AttachedTo) break;
        FdoExtension->AttachedDeviceObject = AttachedTo;
 
        /* Check if this is a child bus, or the root */
        if (ParentExtension)
        {
            /* The child inherits root data */
            FdoExtension->BaseBus = PdoExtension->Dependent.type1.SecondaryBus;
            FdoExtension->BusRootFdoExtension = ParentExtension->BusRootFdoExtension;
            PdoExtension->BridgeFdoExtension = FdoExtension;
            FdoExtension->ParentFdoExtension = ParentExtension;
        }
        else
        {
            /* Query the boot configuration */
            Status = PciGetDeviceProperty(PhysicalDeviceObject,
                                          DevicePropertyBootConfiguration,
                                          (PVOID*)&Descriptor);
            if (!NT_SUCCESS(Status))
            {
                /* No configuration has been set */
                Descriptor = NULL;
            }
            else
            {
                /* Root PDO in ReactOS does not assign boot resources */
                UNIMPLEMENTED_DBGBREAK("Encountered during setup\n");
                Descriptor = NULL;
            }
 
            if (Descriptor)
            {
                /* Root PDO in ReactOS does not assign boot resources */
                UNIMPLEMENTED_DBGBREAK();
            }
            else
            {
                /* Default configuration isn't the normal path on Windows */
                if (PciBreakOnDefault)
                {
                    /* If a second bus is found and there's still no data, crash */
                    KeBugCheckEx(PCI_BUS_DRIVER_INTERNAL,
                                 0xDEAD0010u,
                                 (ULONG_PTR)DeviceObject,
                                 0,
                                 0);
                }
 
                /* Warn that a default configuration will be used, and set bus 0 */
                DPRINT1("PCI   Will use default configuration.\n");
                PciBreakOnDefault = TRUE;
                FdoExtension->BaseBus = 0;
            }
 
            /* This is the root bus */
            FdoExtension->BusRootFdoExtension = FdoExtension;
        }
 
        /* Get the HAL or ACPI Bus Handler Callbacks for Configuration Access */
        Status = PciGetConfigHandlers(FdoExtension);
        if (!NT_SUCCESS(Status)) break;
 
        /* Initialize all the supported PCI arbiters */
        Status = PciInitializeArbiters(FdoExtension);
        if (!NT_SUCCESS(Status)) break;
 
        /* This is a real FDO, insert it into the list */
        FdoExtension->Fake = FALSE;
        PciInsertEntryAtTail(&PciFdoExtensionListHead,
                             FdoExtension,
                             &PciGlobalLock);
 
        /* Open the device registry key so that we can query the errata flags */
        IoOpenDeviceRegistryKey(DeviceObject,
                                PLUGPLAY_REGKEY_DEVICE,
                                KEY_ALL_ACCESS,
                                &KeyHandle),
 
        /* Open the value that contains errata flags for this bus instance */
        RtlInitUnicodeString(&ValueName, L"HackFlags");
        Status = ZwQueryValueKey(KeyHandle,
                                 &ValueName,
                                 KeyValuePartialInformation,
                                 ValueInfo,
                                 sizeof(Buffer),
                                 &ResultLength);
        ZwClose(KeyHandle);
        if (NT_SUCCESS(Status))
        {
            /* Make sure the data is of expected type and size */
            if ((ValueInfo->Type == REG_DWORD) &&
                (ValueInfo->DataLength == sizeof(ULONG)))
            {
                /* Read the flags for this bus */
                FdoExtension->BusHackFlags = *(PULONG)&ValueInfo->Data;
            }
        }
 
        /* Query ACPI for PCI HotPlug Support */
        PciGetHotPlugParameters(FdoExtension);
 
        /* The Bus FDO is now initialized */
        DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
        return STATUS_SUCCESS;
    } while (FALSE);
 
    /* This is the failure path */
    ASSERT(!NT_SUCCESS(Status));
 
    /* Check if the FDO extension exists */
    if (FdoExtension) DPRINT1("Should destroy secondaries\n");
 
    /* Delete device objects */
    if (AttachedTo) IoDetachDevice(AttachedTo);
    if (DeviceObject) IoDeleteDevice(DeviceObject);
    return Status;
}

PciAreBusNumbersConfigured()

BOOLEAN NTAPI PciAreBusNumbersConfigured

(

IN PPCI_PDO_EXTENSION

PdoExtension

)

Definition at line 20 of file busno.c.

{
    UCHAR PrimaryBus, BaseBus, SecondaryBus, SubordinateBus;
 
    PAGED_CODE();
 
    /* Get all relevant bus number details */
    PrimaryBus = PdoExtension->Dependent.type1.PrimaryBus;
    BaseBus = PdoExtension->ParentFdoExtension->BaseBus;
    SecondaryBus = PdoExtension->Dependent.type1.SecondaryBus;
    SubordinateBus = PdoExtension->Dependent.type1.SubordinateBus;
 
    /* The primary bus should be the base bus of the parent */
    if ((PrimaryBus != BaseBus) || (SecondaryBus <= PrimaryBus)) return FALSE;
 
    /* The subordinate should be a higher bus number than the secondary */
    return SubordinateBus >= SecondaryBus;
}

Referenced by PciAddDevice().

PciBeginStateTransition()

NTSTATUS NTAPI PciBeginStateTransition	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCI_STATE	NewState
	)

Definition at line 97 of file state.c.

{
    PCI_STATE CurrentState;
    NTSTATUS Status;
    DPRINT1("PCI Request to begin transition of Extension %p to %s ->",
            DeviceExtension,
            PciTransitionText[NewState]);
 
    /* Assert the device isn't already in a pending transition */
    ASSERT(DeviceExtension->TentativeNextState == DeviceExtension->DeviceState);
 
    /* Assert this is a valid state */
    CurrentState = DeviceExtension->DeviceState;
    ASSERT(CurrentState < PciMaxObjectState);
    ASSERT(NewState < PciMaxObjectState);
 
    /* Lookup if this state transition is valid */
    Status = PnpStateTransitionArray[CurrentState + 6 * NewState];
    if (Status == STATUS_FAIL_CHECK)
    {
        /* Invalid transition (logical fault) */
        DPRINT1("ERROR\nPCI: Error trying to enter state \"%s\" "
                "from state \"%s\"\n",
                PciTransitionText[NewState],
                PciTransitionText[CurrentState]);
        DbgBreakPoint();
    }
    else if (Status == STATUS_INVALID_DEVICE_REQUEST)
    {
        /* Invalid transition (illegal request) */
        DPRINT1("ERROR\nPCI: Illegal request to try to enter state \"%s\" "
                "from state \"%s\", rejecting",
                PciTransitionText[NewState],
                PciTransitionText[CurrentState]);
    }
 
    /* New state must be different from current, unless request is at fault */
    ASSERT((NewState != DeviceExtension->DeviceState) || (!NT_SUCCESS(Status)));
 
    /* Enter the new state if successful, and return state status */
    if (NT_SUCCESS(Status)) DeviceExtension->TentativeNextState = NewState;
    DbgPrint("%x\n", Status);
    return Status;
}

Referenced by PciFdoIrpStartDevice(), PciPdoIrpStartDevice(), and PciQueryDeviceRelations().

PciBuildDefaultExclusionLists()

NTSTATUS NTAPI PciBuildDefaultExclusionLists

(

VOID

)

Definition at line 276 of file utils.c.

{
    ULONG Start;
    NTSTATUS Status;
    ASSERT(PciIsaBitExclusionList.Count == 0);
    ASSERT(PciVgaAndIsaBitExclusionList.Count == 0);
 
    /* Initialize the range lists */
    RtlInitializeRangeList(&PciIsaBitExclusionList);
    RtlInitializeRangeList(&PciVgaAndIsaBitExclusionList);
 
    /* Loop x86 I/O ranges */
    for (Start = 0x100; Start <= 0xFEFF; Start += 0x400)
    {
        /* Add the ISA I/O ranges */
        Status = RtlAddRange(&PciIsaBitExclusionList,
                             Start,
                             Start + 0x2FF,
                             0,
                             RTL_RANGE_LIST_ADD_IF_CONFLICT,
                             NULL,
                             NULL);
        if (!NT_SUCCESS(Status)) break;
 
        /* Add the ISA I/O ranges */
        Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
                             Start,
                             Start + 0x2AF,
                             0,
                             RTL_RANGE_LIST_ADD_IF_CONFLICT,
                             NULL,
                             NULL);
        if (!NT_SUCCESS(Status)) break;
 
        /* Add the VGA I/O range for Monochrome Video */
        Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
                             Start + 0x2BC,
                             Start + 0x2BF,
                             0,
                             RTL_RANGE_LIST_ADD_IF_CONFLICT,
                             NULL,
                             NULL);
        if (!NT_SUCCESS(Status)) break;
 
        /* Add the VGA I/O range for certain CGA adapters */
        Status = RtlAddRange(&PciVgaAndIsaBitExclusionList,
                             Start + 0x2E0,
                             Start + 0x2FF,
                             0,
                             RTL_RANGE_LIST_ADD_IF_CONFLICT,
                             NULL,
                             NULL);
        if (!NT_SUCCESS(Status)) break;
 
        /* Success, ranges added done */
    };
 
    RtlFreeRangeList(&PciIsaBitExclusionList);
    RtlFreeRangeList(&PciVgaAndIsaBitExclusionList);
    return Status;
}

Referenced by DriverEntry().

PciBuildRequirementsList()

NTSTATUS NTAPI PciBuildRequirementsList	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData,
		OUT PIO_RESOURCE_REQUIREMENTS_LIST *	Buffer
	)

Definition at line 551 of file enum.c.

{
    PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
 
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
 
    {
        /* There aren't, so use the zero descriptor */
        RequirementsList = PciZeroIoResourceRequirements;
 
        /* Does it actually exist yet? */
        if (!PciZeroIoResourceRequirements)
        {
            /* Allocate it, and use it for future use */
            RequirementsList = PciAllocateIoRequirementsList(0, 0, 0);
            PciZeroIoResourceRequirements = RequirementsList;
            if (!PciZeroIoResourceRequirements) return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Return the zero requirements list to the caller */
        *Buffer = RequirementsList;
        DPRINT1("PCI - build resource reqs - early out, 0 resources\n");
        return STATUS_SUCCESS;
    }
    return STATUS_SUCCESS;
}

Referenced by PciAssignSlotResources(), and PciQueryRequirements().

PciCacheLegacyDeviceRouting()

NTSTATUS NTAPI PciCacheLegacyDeviceRouting	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	BusNumber,
		IN ULONG	SlotNumber,
		IN UCHAR	InterruptLine,
		IN UCHAR	InterruptPin,
		IN UCHAR	BaseClass,
		IN UCHAR	SubClass,
		IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PPCI_PDO_EXTENSION	PdoExtension,
		OUT PDEVICE_OBJECT *	pFoundDeviceObject
	)

Definition at line 70 of file routintf.c.

{
    PPCI_LEGACY_DEVICE *Link;
    PPCI_LEGACY_DEVICE LegacyDevice;
    PDEVICE_OBJECT FoundDeviceObject;
    PAGED_CODE();
 
    /* Scan current registered devices */
    LegacyDevice = PciLegacyDeviceHead;
    Link = &PciLegacyDeviceHead;
    while (LegacyDevice)
    {
        /* Find a match */
        if ((BusNumber == LegacyDevice->BusNumber) &&
            (SlotNumber == LegacyDevice->SlotNumber))
        {
            /* We already know about this routing */
            break;
        }
 
        /* We know about device already, but for a different location */
        if (LegacyDevice->DeviceObject == DeviceObject)
        {
            /* Free the existing structure, move to the next one */
            *Link = LegacyDevice->Next;
            ExFreePoolWithTag(LegacyDevice, 0);
            LegacyDevice = *Link;
        }
        else
        {
            /* Keep going */
            Link = &LegacyDevice->Next;
            LegacyDevice = LegacyDevice->Next;
        }
    }
 
    /* Did we find a match? */
    if (!LegacyDevice)
    {
        /* Allocate a new cache structure */
        LegacyDevice = ExAllocatePoolWithTag(PagedPool,
                                             sizeof(PCI_LEGACY_DEVICE),
                                             'PciR');
        if (!LegacyDevice) return STATUS_INSUFFICIENT_RESOURCES;
 
        /* Save all the data in it */
        RtlZeroMemory(LegacyDevice, sizeof(PCI_LEGACY_DEVICE));
        LegacyDevice->BusNumber = BusNumber;
        LegacyDevice->SlotNumber = SlotNumber;
        LegacyDevice->InterruptLine = InterruptLine;
        LegacyDevice->InterruptPin = InterruptPin;
        LegacyDevice->BaseClass = BaseClass;
        LegacyDevice->SubClass = SubClass;
        LegacyDevice->PhysicalDeviceObject = PhysicalDeviceObject;
        LegacyDevice->DeviceObject = DeviceObject;
        LegacyDevice->PdoExtension = PdoExtension;
 
        /* Link it in the list */
        LegacyDevice->Next = PciLegacyDeviceHead;
        PciLegacyDeviceHead = LegacyDevice;
    }
 
    /* Check if we found, or created, a matching caching structure */
    FoundDeviceObject = LegacyDevice->DeviceObject;
    if (FoundDeviceObject == DeviceObject)
    {
        /* Return the device object and success */
        if (pFoundDeviceObject) *pFoundDeviceObject = DeviceObject;
        return STATUS_SUCCESS;
    }
 
    /* Otherwise, this is a new device object for this location */
    LegacyDevice->DeviceObject = DeviceObject;
    if (pFoundDeviceObject) *pFoundDeviceObject = FoundDeviceObject;
    return STATUS_SUCCESS;
}

Referenced by PciAssignSlotResources().

PciCallDownIrpStack()

NTSTATUS NTAPI PciCallDownIrpStack	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PIRP	Irp
	)

Definition at line 39 of file dispatch.c.

{
    NTSTATUS Status;
    KEVENT Event;
    PAGED_CODE();
    DPRINT1("PciCallDownIrpStack ...\n");
    ASSERT_FDO(DeviceExtension);
 
    /* Initialize the wait event */
    KeInitializeEvent(&Event, SynchronizationEvent, 0);
 
    /* Setup a completion routine */
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp, PciSetEventCompletion, &Event, TRUE, TRUE, TRUE);
 
    /* Call the attached device */
    Status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for it to complete the request, and get its status */
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = Irp->IoStatus.Status;
    }
 
    /* Return that status back to the caller */
    return Status;
}

Referenced by PciDispatchIrp(), and PciFdoIrpQueryInterface().

PciCancelStateTransition()

NTSTATUS NTAPI PciCancelStateTransition	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCI_STATE	NewState
	)

Definition at line 145 of file state.c.

{
    NTSTATUS Status;
    DPRINT1("PCI Request to cancel transition of Extension %p to %s ->",
            DeviceExtension,
            PciTransitionText[StateNotEntered]);
 
    /* The next state can't be the state the device is already in */
    if (DeviceExtension->TentativeNextState == DeviceExtension->DeviceState)
    {
        /* It's too late since the state was already committed */
        ASSERT(StateNotEntered < PciMaxObjectState);
        ASSERT(PnpStateCancelArray[StateNotEntered] != STATUS_FAIL_CHECK);
 
        /* Return failure */
        Status = STATUS_INVALID_DEVICE_STATE;
        DbgPrint("%x\n", Status);
    }
    else
    {
        /* The device hasn't yet entered the state, so it's still possible to cancel */
        ASSERT(DeviceExtension->TentativeNextState == StateNotEntered);
        DeviceExtension->TentativeNextState = DeviceExtension->DeviceState;
 
        /* Return success */
        Status = STATUS_SUCCESS;
        DbgPrint("%x\n", Status);
    }
 
    /* Return the cancel state */
    return Status;
}

Referenced by PciFdoIrpStartDevice(), PciPdoIrpStartDevice(), and PciQueryDeviceRelations().

PciCanDisableDecodes()

BOOLEAN NTAPI PciCanDisableDecodes	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN PPCI_COMMON_HEADER	Config,
		IN ULONGLONG	HackFlags,
		IN BOOLEAN	ForPowerDown
	)

Definition at line 955 of file utils.c.

{
    UCHAR BaseClass, SubClass;
    BOOLEAN IsVga;
 
    /* Is there a device extension or should the PCI header be used? */
    if (DeviceExtension)
    {
        /* Never disable decodes for a debug PCI Device */
        if (DeviceExtension->OnDebugPath) return FALSE;
 
        /* Hack flags will be obtained from the extension, not the caller */
        ASSERT(HackFlags == 0);
 
        /* Get hacks and classification from the device extension */
        HackFlags = DeviceExtension->HackFlags;
        SubClass = DeviceExtension->SubClass;
        BaseClass = DeviceExtension->BaseClass;
    }
    else
    {
        /* There must be a PCI header, go read the classification information */
        ASSERT(Config != NULL);
        BaseClass = Config->BaseClass;
        SubClass = Config->SubClass;
    }
 
    /* Check for hack flags that prevent disabling the decodes */
    if (HackFlags & (PCI_HACK_PRESERVE_COMMAND |
                     PCI_HACK_CB_SHARE_CMD_BITS |
                     PCI_HACK_DONT_DISABLE_DECODES))
    {
        /* Don't do it */
        return FALSE;
    }
 
    /* Is this a VGA adapter? */
    if ((BaseClass == PCI_CLASS_DISPLAY_CTLR) &&
        (SubClass == PCI_SUBCLASS_VID_VGA_CTLR))
    {
        /* Never disable decodes if this is for power down */
        return ForPowerDown;
    }
 
    /* Check for legacy devices */
    if (BaseClass == PCI_CLASS_PRE_20)
    {
        /* Never disable video adapter cards if this is for power down */
        if (SubClass == PCI_SUBCLASS_PRE_20_VGA) return ForPowerDown;
    }
    else if (BaseClass == PCI_CLASS_DISPLAY_CTLR)
    {
        /* Never disable VGA adapters if this is for power down */
        if (SubClass == PCI_SUBCLASS_VID_VGA_CTLR) return ForPowerDown;
    }
    else if (BaseClass == PCI_CLASS_BRIDGE_DEV)
    {
        /* Check for legacy bridges */
        if ((SubClass == PCI_SUBCLASS_BR_ISA) ||
            (SubClass == PCI_SUBCLASS_BR_EISA) ||
            (SubClass == PCI_SUBCLASS_BR_MCA) ||
            (SubClass == PCI_SUBCLASS_BR_HOST) ||
            (SubClass == PCI_SUBCLASS_BR_OTHER))
        {
            /* Never disable these */
            return FALSE;
        }
        else if ((SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI) ||
                 (SubClass == PCI_SUBCLASS_BR_CARDBUS))
        {
            /* This is a supported bridge, but does it have a VGA card? */
            if (!DeviceExtension)
            {
                /* Read the bridge control flag from the PCI header */
                IsVga = Config->u.type1.BridgeControl & PCI_ENABLE_BRIDGE_VGA;
            }
            else
            {
                /* Read the cached flag in the device extension */
                IsVga = DeviceExtension->Dependent.type1.VgaBitSet;
            }
 
            /* Never disable VGA adapters if this is for power down */
            if (IsVga) return ForPowerDown;
        }
    }
 
    /* Finally, never disable decodes if there's no power management */
    return !(HackFlags & PCI_HACK_NO_PM_CAPS);
}

Referenced by PciDecodeEnable(), and PciSetPowerManagedDevicePowerState().

pcicbintrf_Constructor()

NTSTATUS NTAPI pcicbintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 109 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

pcicbintrf_Initializer()

NTSTATUS NTAPI pcicbintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 99 of file cardbus.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI pcicbintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

PciClassifyDeviceType()

PCI_DEVICE_TYPES NTAPI PciClassifyDeviceType

(

IN PPCI_PDO_EXTENSION

PdoExtension

)

Definition at line 1051 of file utils.c.

{
    ASSERT(PdoExtension->ExtensionType == PciPdoExtensionType);
 
    /* Differentiate between devices and bridges */
    if (PdoExtension->BaseClass != PCI_CLASS_BRIDGE_DEV) return PciTypeDevice;
 
    /* The PCI Bus driver handles only CardBus and PCI bridges (plus host) */
    if (PdoExtension->SubClass == PCI_SUBCLASS_BR_HOST) return PciTypeHostBridge;
    if (PdoExtension->SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI) return PciTypePciBridge;
    if (PdoExtension->SubClass == PCI_SUBCLASS_BR_CARDBUS) return PciTypeCardbusBridge;
 
    /* Any other kind of bridge is treated like a device */
    return PciTypeDevice;
}

Referenced by PciProcessBus().

PciCommitStateTransition()

VOID NTAPI PciCommitStateTransition	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCI_STATE	NewState
	)

Definition at line 181 of file state.c.

{
    DPRINT1("PCI Commit transition of Extension %p to %s\n",
            DeviceExtension, PciTransitionText[NewState]);
 
    /* Make sure this is a valid commit */
    ASSERT(NewState != PciSynchronizedOperation);
    ASSERT(DeviceExtension->TentativeNextState == NewState);
 
    /* Enter the new state */
    DeviceExtension->DeviceState = NewState;
}

Referenced by PciFdoIrpStartDevice(), and PciPdoIrpStartDevice().

PciComputeNewCurrentSettings()

BOOLEAN NTAPI PciComputeNewCurrentSettings	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PCM_RESOURCE_LIST	ResourceList
	)

Definition at line 55 of file enum.c.

{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Partial, InterruptResource;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR BaseResource, CurrentDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PreviousDescriptor;
    CM_PARTIAL_RESOURCE_DESCRIPTOR ResourceArray[7];
    PCM_FULL_RESOURCE_DESCRIPTOR FullList;
    BOOLEAN DrainPartial, RangeChange;
    ULONG i, j;
    PPCI_FUNCTION_RESOURCES PciResources;
    PAGED_CODE();
 
    /* Make sure we have either no resources, or at least one */
    ASSERT((ResourceList == NULL) || (ResourceList->Count == 1));
 
    /* Initialize no partial, interrupt descriptor, or range change */
    Partial = NULL;
    InterruptResource = NULL;
    RangeChange = FALSE;
 
    /* Check if there's not actually any resources */
    if (!(ResourceList) || !(ResourceList->Count))
    {
        /* Then just return the hardware update state */
        return PdoExtension->UpdateHardware;
    }
 
    /* Print the new specified resource list */
    PciDebugPrintCmResList(ResourceList);
 
    /* Clear the temporary resource array */
    for (i = 0; i < 7; i++) ResourceArray[i].Type = CmResourceTypeNull;
 
    /* Loop the full resource descriptor */
    FullList = ResourceList->List;
    for (i = 0; i < ResourceList->Count; i++)
    {
        /* Initialize loop variables */
        DrainPartial = FALSE;
        BaseResource = NULL;
 
        /* Loop the partial descriptors */
        Partial = FullList->PartialResourceList.PartialDescriptors;
        for (j = 0; j < FullList->PartialResourceList.Count; j++)
        {
            /* Check if we were supposed to drain a partial due to device data */
            if (DrainPartial)
            {
                /* Draining complete, move on to the next descriptor then */
                DrainPartial--;
                continue;
            }
 
            /* Check what kind of descriptor this was */
            switch (Partial->Type)
            {
                /* Base BAR resources */
                case CmResourceTypePort:
                case CmResourceTypeMemory:
 
                    /* Set it as the base */
                    ASSERT(BaseResource == NULL);
                    BaseResource = Partial;
                    break;
 
                /* Interrupt resource */
                case CmResourceTypeInterrupt:
 
                    /* Make sure it's a compatible (and the only) PCI interrupt */
                    ASSERT(InterruptResource == NULL);
                    ASSERT(Partial->u.Interrupt.Level == Partial->u.Interrupt.Vector);
                    InterruptResource = Partial;
 
                    /* Only 255 interrupts on x86/x64 hardware */
                    if (Partial->u.Interrupt.Level < 256)
                    {
                        /* Use the passed interrupt line */
                        PdoExtension->AdjustedInterruptLine = Partial->u.Interrupt.Level;
                    }
                    else
                    {
                        /* Invalid vector, so ignore it */
                        PdoExtension->AdjustedInterruptLine = 0;
                    }
 
                    break;
 
                /* Check for specific device data */
                case CmResourceTypeDevicePrivate:
 
                    /* Check what kind of data this was */
                    switch (Partial->u.DevicePrivate.Data[0])
                    {
                        /* Not used in the driver yet */
                        case 1:
                            UNIMPLEMENTED_DBGBREAK();
                            break;
 
                        /* Not used in the driver yet */
                        case 2:
                            UNIMPLEMENTED_DBGBREAK();
                            break;
 
                        /* A drain request */
                        case 3:
                            /* Shouldn't be a base resource, this is a drain */
                            ASSERT(BaseResource == NULL);
                            DrainPartial = Partial->u.DevicePrivate.Data[1];
                            ASSERT(DrainPartial == TRUE);
                            break;
                    }
                    break;
            }
 
            /* Move to the next descriptor */
            Partial = CmiGetNextPartialDescriptor(Partial);
        }
 
        /* We should be starting a new list now */
        ASSERT(BaseResource == NULL);
        FullList = (PVOID)Partial;
    }
 
    /* Check the current assigned PCI resources */
    PciResources = PdoExtension->Resources;
    if (!PciResources) return FALSE;
 
    //if... // MISSING CODE
    UNIMPLEMENTED;
    DPRINT1("Missing sanity checking code!\n");
 
    /* Loop all the PCI function resources */
    for (i = 0; i < 7; i++)
    {
        /* Get the current function resource descriptor, and the new one */
        CurrentDescriptor = &PciResources->Current[i];
        Partial = &ResourceArray[i];
 
        /* Previous is current during the first loop iteration */
        PreviousDescriptor = &PciResources->Current[(i == 0) ? (0) : (i - 1)];
 
        /* Check if this new descriptor is different than the old one */
        if (((Partial->Type != CurrentDescriptor->Type) ||
             (Partial->Type != CmResourceTypeNull)) &&
            ((Partial->u.Generic.Start.QuadPart !=
              CurrentDescriptor->u.Generic.Start.QuadPart) ||
             (Partial->u.Generic.Length != CurrentDescriptor->u.Generic.Length)))
        {
            /* Record a change */
            RangeChange = TRUE;
 
            /* Was there a range before? */
            if (CurrentDescriptor->Type != CmResourceTypeNull)
            {
                /* Print it */
                DbgPrint("      Old range-\n");
                PciDebugPrintPartialResource(CurrentDescriptor);
            }
            else
            {
                /* There was no range */
                DbgPrint("      Previously unset range\n");
            }
 
            /* Print new one */
            DbgPrint("      changed to\n");
            PciDebugPrintPartialResource(Partial);
 
            /* Update to new range */
            CurrentDescriptor->Type = Partial->Type;
            PreviousDescriptor->u.Generic.Start = Partial->u.Generic.Start;
            PreviousDescriptor->u.Generic.Length = Partial->u.Generic.Length;
            CurrentDescriptor = PreviousDescriptor;
        }
    }
 
    /* Either the hardware was updated, or a resource range changed */
    return ((RangeChange) || (PdoExtension->UpdateHardware));
}

Referenced by PciAssignSlotResources(), and PciPdoIrpStartDevice().

PciCreateIoDescriptorFromBarLimit()

BOOLEAN NTAPI PciCreateIoDescriptorFromBarLimit	(	PIO_RESOURCE_DESCRIPTOR	ResourceDescriptor,
		IN PULONG	BarArray,
		IN BOOLEAN	Rom
	)

Definition at line 1175 of file utils.c.

{
    ULONG CurrentBar, BarLength, BarMask;
    BOOLEAN Is64BitBar = FALSE;
 
    /* Check if the BAR is nor I/O nor memory */
    CurrentBar = BarArray[0];
    if (!(CurrentBar & ~PCI_ADDRESS_IO_SPACE))
    {
        /* Fail this descriptor */
        ResourceDescriptor->Type = CmResourceTypeNull;
        return FALSE;
    }
 
    /* Set default flag and clear high words */
    ResourceDescriptor->Flags = 0;
    ResourceDescriptor->u.Generic.MaximumAddress.HighPart = 0;
    ResourceDescriptor->u.Generic.MinimumAddress.LowPart = 0;
    ResourceDescriptor->u.Generic.MinimumAddress.HighPart = 0;
 
    /* Check for ROM Address */
    if (Rom)
    {
        /* Clean up the BAR to get just the address */
        CurrentBar &= PCI_ADDRESS_ROM_ADDRESS_MASK;
        if (!CurrentBar)
        {
            /* Invalid ar, fail this descriptor */
            ResourceDescriptor->Type = CmResourceTypeNull;
            return FALSE;
        }
 
        /* ROM Addresses are always read only */
        ResourceDescriptor->Flags = CM_RESOURCE_MEMORY_READ_ONLY;
    }
 
    /* Compute the length, assume it's the alignment for now */
    BarLength = PciGetLengthFromBar(CurrentBar);
    ResourceDescriptor->u.Generic.Length = BarLength;
    ResourceDescriptor->u.Generic.Alignment = BarLength;
 
    /* Check what kind of BAR this is */
    if (CurrentBar & PCI_ADDRESS_IO_SPACE)
    {
        /* Use correct mask to decode the address */
        BarMask = PCI_ADDRESS_IO_ADDRESS_MASK;
 
        /* Set this as an I/O Port descriptor */
        ResourceDescriptor->Type = CmResourceTypePort;
        ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
    }
    else
    {
        /* Use correct mask to decode the address */
        BarMask = PCI_ADDRESS_MEMORY_ADDRESS_MASK;
 
        /* Set this as a memory descriptor */
        ResourceDescriptor->Type = CmResourceTypeMemory;
 
        /* Check if it's 64-bit or 20-bit decode */
        if ((CurrentBar & PCI_ADDRESS_MEMORY_TYPE_MASK) == PCI_TYPE_64BIT)
        {
            /* The next BAR has the high word, read it */
            ResourceDescriptor->u.Port.MaximumAddress.HighPart = BarArray[1];
            Is64BitBar = TRUE;
        }
        else if ((CurrentBar & PCI_ADDRESS_MEMORY_TYPE_MASK) == PCI_TYPE_20BIT)
        {
            /* Use the correct mask to decode the address */
            BarMask = ~0xFFF0000F;
        }
 
        /* Check if the BAR is listed as prefetchable memory */
        if (CurrentBar & PCI_ADDRESS_MEMORY_PREFETCHABLE)
        {
            /* Mark the descriptor in the same way */
            ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE;
        }
    }
 
    /* Now write down the maximum address based on the base + length */
    ResourceDescriptor->u.Port.MaximumAddress.QuadPart = (CurrentBar & BarMask) +
                                                         BarLength - 1;
 
    /* Return if this is a 64-bit BAR, so the loop code knows to skip the next one */
    return Is64BitBar;
}

Referenced by Device_SaveLimits(), and PPBridge_SaveLimits().

PciDebugDumpCommonConfig()

VOID NTAPI PciDebugDumpCommonConfig

(

IN PPCI_COMMON_HEADER

PciData

)

Definition at line 207 of file debug.c.

{
    USHORT i;
 
    /* Loop the PCI header */
    for (i = 0; i < PCI_COMMON_HDR_LENGTH; i += 4)
    {
        /* Dump each DWORD and its offset */
        DPRINT1("  %02x - %08x\n", i, *(PULONG)((ULONG_PTR)PciData + i));
    }
}

Referenced by PcipGetFunctionLimits(), and PciScanBus().

PciDebugDumpQueryCapabilities()

VOID NTAPI PciDebugDumpQueryCapabilities

(

IN PDEVICE_CAPABILITIES

DeviceCaps

)

Definition at line 221 of file debug.c.

{
    ULONG i;
 
    /* Dump the capabilities */
    DPRINT1("Capabilities\n  Lock:%u, Eject:%u, Remove:%u, Dock:%u, UniqueId:%u\n",
            DeviceCaps->LockSupported,
            DeviceCaps->EjectSupported,
            DeviceCaps->Removable,
            DeviceCaps->DockDevice,
            DeviceCaps->UniqueID);
    DbgPrint("  SilentInstall:%u, RawOk:%u, SurpriseOk:%u\n",
             DeviceCaps->SilentInstall,
             DeviceCaps->RawDeviceOK,
             DeviceCaps->SurpriseRemovalOK);
    DbgPrint("  Address %08x, UINumber %08x, Latencies D1 %u, D2 %u, D3 %u\n",
             DeviceCaps->Address,
             DeviceCaps->UINumber,
             DeviceCaps->D1Latency,
             DeviceCaps->D2Latency,
             DeviceCaps->D3Latency);
 
    /* Dump and convert the wake levels */
    DbgPrint("  System Wake: %s, Device Wake: %s\n  DeviceState[PowerState] [",
             SystemPowerStates[min(DeviceCaps->SystemWake, PowerSystemMaximum)],
             DevicePowerStates[min(DeviceCaps->DeviceWake, PowerDeviceMaximum)]);
 
    /* Dump and convert the power state mappings */
    for (i = PowerSystemWorking; i < PowerSystemMaximum; i++)
        DbgPrint(" %s", DevicePowerStates[DeviceCaps->DeviceState[i]]);
 
    /* Finish the dump */
    DbgPrint(" ]\n");
}

Referenced by PciFdoIrpQueryCapabilities(), and PciQueryCapabilities().

PciDebugIrpDispatchDisplay()

BOOLEAN NTAPI PciDebugIrpDispatchDisplay	(	IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN USHORT	MaxMinor
	)

Definition at line 124 of file debug.c.

{
    PPCI_PDO_EXTENSION PdoDeviceExtension;
    ULONG BreakMask;
    //ULONG DebugLevel = 0;
    PCHAR IrpString;
 
    /* Only two functions are recognized */
    switch (IoStackLocation->MajorFunction)
    {
        case IRP_MJ_POWER:
 
            /* Get the string and the correct break mask for the extension */
            BreakMask = (DeviceExtension->ExtensionType == PciPdoExtensionType) ?
                         PciBreakOnPdoPowerIrp : PciBreakOnFdoPowerIrp;
            IrpString = PciDebugPoIrpTypeToText(IoStackLocation->MinorFunction);
            break;
 
        case IRP_MJ_PNP:
 
            /* Get the string and the correct break mask for the extension */
            BreakMask = (DeviceExtension->ExtensionType == PciFdoExtensionType) ?
                         PciBreakOnPdoPnpIrp : PciBreakOnFdoPnpIrp;
            IrpString = PciDebugPnpIrpTypeToText(IoStackLocation->MinorFunction);
            break;
 
        default:
 
            /* Other functions are not decoded */
            BreakMask = FALSE;
            IrpString = "";
            break;
    }
 
    /* Check if this is a PDO */
    if (DeviceExtension->ExtensionType == PciPdoExtensionType)
    {
        /* Choose the correct debug level based on which function this is */
        if (IoStackLocation->MajorFunction == IRP_MJ_POWER)
        {
            //DebugLevel = 0x500;
        }
        else if (IoStackLocation->MajorFunction == IRP_MJ_PNP)
        {
            //DebugLevel = 0x200;
        }
 
        /* For a PDO, print out the bus, device, and function number */
        PdoDeviceExtension = (PVOID)DeviceExtension;
        DPRINT1("PDO(b=0x%x, d=0x%x, f=0x%x)<-%s\n",
                PdoDeviceExtension->ParentFdoExtension->BaseBus,
                PdoDeviceExtension->Slot.u.bits.DeviceNumber,
                PdoDeviceExtension->Slot.u.bits.FunctionNumber,
                IrpString);
    }
    else if (DeviceExtension->ExtensionType == PciFdoExtensionType)
    {
        /* Choose the correct debug level based on which function this is */
        if (IoStackLocation->MajorFunction == IRP_MJ_POWER)
        {
            //DebugLevel = 0x400;
        }
        else if (IoStackLocation->MajorFunction == IRP_MJ_PNP)
        {
            //DebugLevel = 0x100;
        }
 
        /* For an FDO, just dump the extension pointer and IRP string */
        DPRINT1("FDO(%p)<-%s\n", DeviceExtension, IrpString);
    }
 
    /* If the function is illegal for this extension, complain */
    if (IoStackLocation->MinorFunction > MaxMinor)
        DPRINT1("Unknown IRP, minor = 0x%x\n", IoStackLocation->MinorFunction);
 
    /* Return whether or not the debugger should be broken into for this IRP */
    return ((1 << IoStackLocation->MinorFunction) & BreakMask);
}

Referenced by PciDispatchIrp().

PciDebugPrintCmResList()

VOID NTAPI PciDebugPrintCmResList

(

IN PCM_RESOURCE_LIST

ResourceList

)

Definition at line 364 of file debug.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    ULONG Count, i, ListCount;
 
    /* Make sure there's something to dump */
    if (!PartialList) return;
 
    /* Get the full list count */
    ListCount = PartialList->Count;
    FullDescriptor = PartialList->List;
    DPRINT1("  CM_RESOURCE_LIST (PCI Bus Driver) (List Count = %u)\n", PartialList->Count);
 
    /* Loop full list */
    for (i = 0; i < ListCount; i++)
    {
        /* Loop full descriptor */
        DPRINT1("     InterfaceType        %d\n", FullDescriptor->InterfaceType);
        DPRINT1("     BusNumber            0x%x\n", FullDescriptor->BusNumber);
 
        /* Get partial count and loop partials */
        Count = FullDescriptor->PartialResourceList.Count;
        for (PartialDescriptor = FullDescriptor->PartialResourceList.PartialDescriptors;
             Count;
             PartialDescriptor = CmiGetNextPartialDescriptor(PartialDescriptor))
        {
            /* Print each partial */
            PciDebugPrintPartialResource(PartialDescriptor);
            Count--;
        }
 
        /* Go to the next full descriptor */
        FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)PartialDescriptor;
    }
 
    /* Done printing data */
    DPRINT1("\n");
}

Referenced by PciComputeNewCurrentSettings().

PciDebugPrintIoResReqList()

VOID NTAPI PciDebugPrintIoResReqList

(

IN PIO_RESOURCE_REQUIREMENTS_LIST

Requirements

)

Definition at line 302 of file debug.c.

{
    ULONG AlternativeLists;
    PIO_RESOURCE_LIST List;
    ULONG Count;
    PIO_RESOURCE_DESCRIPTOR Descriptor;
 
    /* Make sure there's a list */
    if (!Requirements) return;
 
    /* Grab the main list and the alternates as well */
    AlternativeLists = Requirements->AlternativeLists;
    List = Requirements->List;
 
    /* Print out the initial header*/
    DPRINT1("  IO_RESOURCE_REQUIREMENTS_LIST (PCI Bus Driver)\n");
    DPRINT1("     InterfaceType        %d\n", Requirements->InterfaceType);
    DPRINT1("     BusNumber            0x%x\n", Requirements->BusNumber);
    DPRINT1("     SlotNumber           %d (0x%x), (d/f = 0x%x/0x%x)\n",
            Requirements->SlotNumber,
            Requirements->SlotNumber,
            ((PCI_SLOT_NUMBER*)&Requirements->SlotNumber)->u.bits.DeviceNumber,
            ((PCI_SLOT_NUMBER*)&Requirements->SlotNumber)->u.bits.FunctionNumber);
    DPRINT1("     AlternativeLists     %u\n", AlternativeLists);
 
    /* Scan alternative lists */
    while (AlternativeLists--)
    {
        /* Get the descriptor array, and the count of descriptors */
        Descriptor = List->Descriptors;
        Count = List->Count;
 
        /* Print out each descriptor */
        DPRINT1("\n     List[%u].Count = %u\n", AlternativeLists, Count);
        while (Count--) PciDebugPrintIoResource(Descriptor++);
 
        /* Should've reached a new list now */
        List = (PIO_RESOURCE_LIST)Descriptor;
    }
 
    /* Terminate the dump */
    DPRINT1("\n");
}

Referenced by PciQueryRequirements().

PciDebugPrintPartialResource()

VOID NTAPI PciDebugPrintPartialResource

(

IN PCM_PARTIAL_RESOURCE_DESCRIPTOR

PartialResource

)

Definition at line 348 of file debug.c.

{
    /* Dump all the data in the partial */
    DPRINT1("     Partial Resource Descriptor @0x%p\n", PartialResource);
    DPRINT1("        Type             = %u (%s)\n", PartialResource->Type, PciDebugCmResourceTypeToText(PartialResource->Type));
    DPRINT1("        ShareDisposition = %u\n", PartialResource->ShareDisposition);
    DPRINT1("        Flags            = 0x%04X\n", PartialResource->Flags);
    DPRINT1("        Data[%d] = %08x  %08x  %08x\n",
            0,
            PartialResource->u.Generic.Start.LowPart,
            PartialResource->u.Generic.Start.HighPart,
            PartialResource->u.Generic.Length);
}

Referenced by PciComputeNewCurrentSettings(), and PciDebugPrintCmResList().

PciDecodeEnable()

VOID NTAPI PciDecodeEnable	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN BOOLEAN	Enable,
		OUT PUSHORT	Command
	)

Definition at line 1267 of file utils.c.

{
    USHORT CommandValue;
 
    /*
     * If decodes are being disabled, make sure it's allowed, and in both cases,
     * make sure that a hackflag isn't preventing touching the decodes at all.
     */
    if (((Enable) || (PciCanDisableDecodes(PdoExtension, 0, 0, 0))) &&
        !(PdoExtension->HackFlags & PCI_HACK_PRESERVE_COMMAND))
    {
        /* Did the caller already have a command word? */
        if (Command)
        {
            /* Use the caller's */
            CommandValue = *Command;
        }
        else
        {
            /* Otherwise, read the current command */
            PciReadDeviceConfig(PdoExtension,
                                &Command,
                                FIELD_OFFSET(PCI_COMMON_HEADER, Command),
                                sizeof(USHORT));
        }
 
        /* Turn off decodes by default */
        CommandValue &= ~(PCI_ENABLE_IO_SPACE |
                          PCI_ENABLE_MEMORY_SPACE |
                          PCI_ENABLE_BUS_MASTER);
 
        /* If requested, enable the decodes that were enabled at init time */
        if (Enable) CommandValue |= PdoExtension->CommandEnables &
                                    (PCI_ENABLE_IO_SPACE |
                                     PCI_ENABLE_MEMORY_SPACE |
                                     PCI_ENABLE_BUS_MASTER);
 
        /* Update the command word */
        PciWriteDeviceConfig(PdoExtension,
                             &CommandValue,
                             FIELD_OFFSET(PCI_COMMON_HEADER, Command),
                             sizeof(USHORT));
    }
}

Referenced by PciApplyHacks(), PciConfigureIdeController(), and PcipUpdateHardware().

PciDispatchIrp()

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

Definition at line 99 of file dispatch.c.

{
    PPCI_FDO_EXTENSION DeviceExtension;
    PIO_STACK_LOCATION IoStackLocation;
    PPCI_MJ_DISPATCH_TABLE IrpDispatchTable;
    BOOLEAN PassToPdo;
    NTSTATUS Status;
    PPCI_MN_DISPATCH_TABLE TableArray = NULL, Table;
    USHORT MaxMinor;
    PCI_DISPATCH_STYLE DispatchStyle = 0;
    PCI_DISPATCH_FUNCTION DispatchFunction = NULL;
    DPRINT1("PCI: Dispatch IRP\n");
 
    /* Get the extension and I/O stack location for this IRP */
    DeviceExtension = (PPCI_FDO_EXTENSION)DeviceObject->DeviceExtension;
    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
    ASSERT((DeviceExtension->ExtensionType == PciPdoExtensionType) ||
           (DeviceExtension->ExtensionType == PciFdoExtensionType));
 
    /* Deleted extensions don't respond to IRPs */
    if (DeviceExtension->DeviceState == PciDeleted)
    {
        /* Fail this IRP */
        Status = STATUS_NO_SUCH_DEVICE;
        PassToPdo = FALSE;
    }
    else
    {
        /* Otherwise, get the dispatch table for the extension */
        IrpDispatchTable = DeviceExtension->IrpDispatchTable;
 
        /* And choose which function table to use */
        switch (IoStackLocation->MajorFunction)
        {
            case IRP_MJ_POWER:
 
                /* Power Manager IRPs */
                TableArray = IrpDispatchTable->PowerIrpDispatchTable;
                MaxMinor = IrpDispatchTable->PowerIrpMaximumMinorFunction;
                break;
 
            case IRP_MJ_PNP:
 
                /* Plug-and-Play Manager IRPs */
                TableArray = IrpDispatchTable->PnpIrpDispatchTable;
                MaxMinor = IrpDispatchTable->PnpIrpMaximumMinorFunction;
                break;
 
            case IRP_MJ_SYSTEM_CONTROL:
 
                /* WMI IRPs */
                DispatchFunction = IrpDispatchTable->SystemControlIrpDispatchFunction;
                DispatchStyle = IrpDispatchTable->SystemControlIrpDispatchStyle;
                MaxMinor = 0xFFFF;
                break;
 
            default:
 
                /* Unrecognized IRPs */
                DispatchFunction = IrpDispatchTable->OtherIrpDispatchFunction;
                DispatchStyle = IrpDispatchTable->OtherIrpDispatchStyle;
                MaxMinor = 0xFFFF;
                break;
        }
 
        /* Only deal with recognized IRPs */
        if (MaxMinor != 0xFFFF)
        {
            /* Make sure the function is recognized */
            if (IoStackLocation->MinorFunction > MaxMinor)
            {
                /* Pick the terminator, which should return unrecognized */
                Table = &TableArray[MaxMinor + 1];
            }
            else
            {
                /* Pick the appropriate table for this function */
                Table = &TableArray[IoStackLocation->MinorFunction];
            }
 
            /* From that table, get the function code and dispatch style */
            DispatchStyle = Table->DispatchStyle;
            DispatchFunction = Table->DispatchFunction;
        }
 
        /* Print out debugging information, and see if we should break */
        if (PciDebugIrpDispatchDisplay(IoStackLocation,
                                       DeviceExtension,
                                       MaxMinor))
        {
            /* The developer/user wants us to break for this IRP, do it */
            DbgBreakPoint();
        }
 
        /* Check if this IRP should be sent up the stack first */
        if (DispatchStyle == IRP_UPWARD)
        {
            /* Do it now before handling it ourselves */
            PciCallDownIrpStack(DeviceExtension, Irp);
        }
 
        /* Call the our driver's handler for this IRP and deal with the IRP */
        Status = DispatchFunction(Irp, IoStackLocation, DeviceExtension);
        switch (DispatchStyle)
        {
            /* Complete IRPs are completely immediately by our driver */
            case IRP_COMPLETE:
                PassToPdo = FALSE;
                break;
 
            /* Downward IRPs are send to the attached FDO */
            case IRP_DOWNWARD:
                PassToPdo = TRUE;
                break;
 
            /* Upward IRPs are completed immediately by our driver */
            case IRP_UPWARD:
                PassToPdo = FALSE;
                break;
 
            /* Dispatch IRPs are immediately returned */
            case IRP_DISPATCH:
                return Status;
 
            /* There aren't any other dispatch styles! */
            default:
                ASSERT(FALSE);
                return Status;
        }
    }
 
    /* Pending IRPs are returned immediately */
    if (Status == STATUS_PENDING) return Status;
 
    /* Handled IRPs return their status in the status block */
    if (Status != STATUS_NOT_SUPPORTED) Irp->IoStatus.Status = Status;
 
    /* Successful, or unhandled IRPs that are "DOWNWARD" are sent to the PDO */
    if ((PassToPdo) && ((NT_SUCCESS(Status)) || (Status == STATUS_NOT_SUPPORTED)))
    {
        /* Let the PDO deal with it */
        Status = PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
    }
    else
    {
        /* Otherwise, the IRP is returned with its status */
        Status = Irp->IoStatus.Status;
 
        /* Power IRPs need to notify the Power Manager that the next IRP can go */
        if (IoStackLocation->MajorFunction == IRP_MJ_POWER) PoStartNextPowerIrp(Irp);
 
        /* And now this IRP can be completed */
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    /* And the status returned back to the caller */
    return Status;
}

PciExecuteCriticalSystemRoutine()

ULONG_PTR NTAPI PciExecuteCriticalSystemRoutine

(

IN ULONG_PTR

IpiContext

)

Definition at line 1069 of file utils.c.

{
    PPCI_IPI_CONTEXT Context = (PPCI_IPI_CONTEXT)IpiContext;
 
    /* Check if the IPI is already running */
    if (!InterlockedDecrement(&Context->RunCount))
    {
        /* Nope, this is the first instance, so execute the IPI function */
        Context->Function(Context->DeviceExtension, Context->Context);
 
        /* Notify anyone that was spinning that they can stop now */
        Context->Barrier = 0;
    }
    else
    {
        /* Spin until it has finished running */
        while (Context->Barrier);
    }
 
    /* Done */
    return 0;
}

PciFdoIrpCancelRemoveDevice()

NTSTATUS NTAPI PciFdoIrpCancelRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 152 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpCancelStopDevice()

NTSTATUS NTAPI PciFdoIrpCancelStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 194 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpDeviceUsageNotification()

NTSTATUS NTAPI PciFdoIrpDeviceUsageNotification	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 337 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpQueryCapabilities()

NTSTATUS NTAPI PciFdoIrpQueryCapabilities	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 310 of file fdo.c.

{
    PDEVICE_CAPABILITIES Capabilities;
    PAGED_CODE();
    ASSERT_FDO(DeviceExtension);
 
    UNREFERENCED_PARAMETER(Irp);
 
    /* Get the capabilities */
    Capabilities = IoStackLocation->Parameters.DeviceCapabilities.Capabilities;
 
    /* Inherit wake levels and power mappings from the higher-up capabilities */
    DeviceExtension->PowerState.SystemWakeLevel = Capabilities->SystemWake;
    DeviceExtension->PowerState.DeviceWakeLevel = Capabilities->DeviceWake;
    RtlCopyMemory(DeviceExtension->PowerState.SystemStateMapping,
                  Capabilities->DeviceState,
                  sizeof(DeviceExtension->PowerState.SystemStateMapping));
 
    /* Dump the capabilities and return success */
    PciDebugDumpQueryCapabilities(Capabilities);
    return STATUS_SUCCESS;
}

PciFdoIrpQueryDeviceRelations()

NTSTATUS NTAPI PciFdoIrpQueryDeviceRelations	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 208 of file fdo.c.

{
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Are bus relations being queried? */
    if (IoStackLocation->Parameters.QueryDeviceRelations.Type != BusRelations)
    {
        /* The FDO is a bus, so only bus relations can be obtained */
        Status = STATUS_NOT_SUPPORTED;
    }
    else
    {
        /* Scan the PCI bus and build the device relations for the caller */
        Status = PciQueryDeviceRelations(DeviceExtension,
                                         (PDEVICE_RELATIONS*)
                                         &Irp->IoStatus.Information);
    }
 
    /* Return the enumeration status back */
    return Status;
}

PciFdoIrpQueryInterface()

NTSTATUS NTAPI PciFdoIrpQueryInterface	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 235 of file fdo.c.

{
    NTSTATUS Status;
    PAGED_CODE();
    ASSERT(DeviceExtension->ExtensionType == PciFdoExtensionType);
 
    /* Deleted extensions don't respond to IRPs */
    if (DeviceExtension->DeviceState == PciDeleted)
    {
        /* Hand it back to try to deal with it */
        return PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
    }
 
    /* Query our driver for this interface */
    Status = PciQueryInterface(DeviceExtension,
                               IoStackLocation->Parameters.QueryInterface.
                               InterfaceType,
                               IoStackLocation->Parameters.QueryInterface.
                               Size,
                               IoStackLocation->Parameters.QueryInterface.
                               Version,
                               IoStackLocation->Parameters.QueryInterface.
                               InterfaceSpecificData,
                               IoStackLocation->Parameters.QueryInterface.
                               Interface,
                               FALSE);
    if (NT_SUCCESS(Status))
    {
        /* We found it, let the PDO handle it */
        Irp->IoStatus.Status = Status;
        return PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
    }
    else if (Status == STATUS_NOT_SUPPORTED)
    {
        /* Otherwise, we can't handle it, let someone else down the stack try */
        Status = PciCallDownIrpStack(DeviceExtension, Irp);
        if (Status == STATUS_NOT_SUPPORTED)
        {
            /* They can't either, try a last-resort interface lookup */
            Status = PciQueryInterface(DeviceExtension,
                                       IoStackLocation->Parameters.QueryInterface.
                                       InterfaceType,
                                       IoStackLocation->Parameters.QueryInterface.
                                       Size,
                                       IoStackLocation->Parameters.QueryInterface.
                                       Version,
                                       IoStackLocation->Parameters.QueryInterface.
                                       InterfaceSpecificData,
                                       IoStackLocation->Parameters.QueryInterface.
                                       Interface,
                                       TRUE);
        }
    }
 
    /* Has anyone claimed this interface yet? */
    if (Status == STATUS_NOT_SUPPORTED)
    {
        /* No, return the original IRP status */
        Status = Irp->IoStatus.Status;
    }
    else
    {
        /* Yes, set the new IRP status */
        Irp->IoStatus.Status = Status;
    }
 
    /* Complete this IRP */
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

PciFdoIrpQueryLegacyBusInformation()

NTSTATUS NTAPI PciFdoIrpQueryLegacyBusInformation	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 365 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpQueryPower()

NTSTATUS NTAPI PciFdoIrpQueryPower	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 236 of file power.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    while (TRUE);
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpQueryRemoveDevice()

NTSTATUS NTAPI PciFdoIrpQueryRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 124 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpQueryStopDevice()

NTSTATUS NTAPI PciFdoIrpQueryStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 180 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpRemoveDevice()

NTSTATUS NTAPI PciFdoIrpRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 138 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpStartDevice()

NTSTATUS NTAPI PciFdoIrpStartDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 76 of file fdo.c.

{
    NTSTATUS Status;
    PCM_RESOURCE_LIST Resources;
    PAGED_CODE();
 
    /* The device stack must be starting the FDO in a success path */
    if (!NT_SUCCESS(Irp->IoStatus.Status)) return STATUS_NOT_SUPPORTED;
 
    /* Attempt to switch the state machine to the started state */
    Status = PciBeginStateTransition(DeviceExtension, PciStarted);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check for any boot-provided resources */
    Resources = IoStackLocation->Parameters.StartDevice.AllocatedResources;
    if ((Resources) && !(PCI_IS_ROOT_FDO(DeviceExtension)))
    {
        /* These resources would only be for non-root FDOs, unhandled for now */
        ASSERT(Resources->Count == 1);
        UNIMPLEMENTED_DBGBREAK();
    }
 
    /* Initialize the arbiter for this FDO */
    Status = PciInitializeArbiterRanges(DeviceExtension, Resources);
    if (!NT_SUCCESS(Status))
    {
        /* Cancel the transition if this failed */
        PciCancelStateTransition(DeviceExtension, PciStarted);
        return Status;
    }
 
    /* Again, check for boot-provided resources for non-root FDO */
    if ((Resources) && !(PCI_IS_ROOT_FDO(DeviceExtension)))
    {
        /* Unhandled for now */
        ASSERT(Resources->Count == 1);
        UNIMPLEMENTED_DBGBREAK();
    }
 
    /* Commit the transition to the started state */
    PciCommitStateTransition(DeviceExtension, PciStarted);
    return STATUS_SUCCESS;
}

PciFdoIrpStopDevice()

NTSTATUS NTAPI PciFdoIrpStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 166 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoIrpSurpriseRemoval()

NTSTATUS NTAPI PciFdoIrpSurpriseRemoval	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 351 of file fdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciFdoSetPowerState()

NTSTATUS NTAPI PciFdoSetPowerState	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 221 of file power.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    while (TRUE);
    return STATUS_NOT_SUPPORTED;
}

PciFdoWaitWake()

NTSTATUS NTAPI PciFdoWaitWake	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 206 of file power.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    while (TRUE);
    return STATUS_NOT_SUPPORTED;
}

PciFindNextSecondaryExtension()

PPCI_SECONDARY_EXTENSION NTAPI PciFindNextSecondaryExtension	(	IN PSINGLE_LIST_ENTRY	ListHead,
		IN PCI_SIGNATURE	ExtensionType
	)

Definition at line 584 of file utils.c.

{
    PSINGLE_LIST_ENTRY NextEntry;
    PPCI_SECONDARY_EXTENSION Extension;
 
    /* Scan the list */
    for (NextEntry = ListHead; NextEntry; NextEntry = NextEntry->Next)
    {
        /* Grab each extension and check if it's the one requested */
        Extension = CONTAINING_RECORD(NextEntry, PCI_SECONDARY_EXTENSION, List);
        if (Extension->ExtensionType == ExtensionType) return Extension;
    }
 
    /* Nothing was found */
    return NULL;
}

Referenced by ario_ApplyBrokenVideoHack(), and PciInitializeArbiterRanges().

PciFindParentPciFdoExtension()

PPCI_FDO_EXTENSION NTAPI PciFindParentPciFdoExtension	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PKEVENT	Lock
	)

Definition at line 340 of file utils.c.

{
    PPCI_FDO_EXTENSION DeviceExtension;
    PPCI_PDO_EXTENSION SearchExtension, FoundExtension;
 
    /* Assume we'll find nothing */
    SearchExtension = DeviceObject->DeviceExtension;
    FoundExtension = NULL;
 
    /* Check if a lock was specified */
    if (Lock)
    {
        /* Wait for the lock to be released */
        KeEnterCriticalRegion();
        KeWaitForSingleObject(Lock, Executive, KernelMode, FALSE, NULL);
    }
 
    /* Now search for the extension */
    DeviceExtension = (PPCI_FDO_EXTENSION)PciFdoExtensionListHead.Next;
    while (DeviceExtension)
    {
        /* Acquire this device's lock */
        KeEnterCriticalRegion();
        KeWaitForSingleObject(&DeviceExtension->ChildListLock,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
 
        /* Scan all children PDO, stop when no more PDOs, or found it */
        for (FoundExtension = DeviceExtension->ChildPdoList;
             ((FoundExtension) && (FoundExtension != SearchExtension));
             FoundExtension = FoundExtension->Next);
 
        /* Release this device's lock */
        KeSetEvent(&DeviceExtension->ChildListLock, IO_NO_INCREMENT, FALSE);
        KeLeaveCriticalRegion();
 
        /* If we found it, break out */
        if (FoundExtension) break;
 
        /* Move to the next device */
        DeviceExtension = (PPCI_FDO_EXTENSION)DeviceExtension->List.Next;
    }
 
    /* Check if we had acquired a lock previously */
    if (Lock)
    {
        /* Release it */
        KeSetEvent(Lock, IO_NO_INCREMENT, FALSE);
        KeLeaveCriticalRegion();
    }
 
    /* Return which extension was found, if any */
    return DeviceExtension;
}

Referenced by PciAddDevice().

PciFindPdoByFunction()

PPCI_PDO_EXTENSION NTAPI PciFindPdoByFunction	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN ULONG	FunctionNumber,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 695 of file utils.c.

{
    KIRQL Irql;
    PPCI_PDO_EXTENSION PdoExtension;
 
    /* Get the current IRQL when this call was made */
    Irql = KeGetCurrentIrql();
 
    /* Is this a low-IRQL call? */
    if (Irql < DISPATCH_LEVEL)
    {
        /* Acquire this device's lock */
        KeEnterCriticalRegion();
        KeWaitForSingleObject(&DeviceExtension->ChildListLock,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
    }
 
    /* Loop every child PDO */
    for (PdoExtension = DeviceExtension->ChildPdoList;
         PdoExtension;
         PdoExtension = PdoExtension->Next)
    {
        /* Find only enumerated PDOs */
        if (!PdoExtension->ReportedMissing)
        {
            /* Check if the function number and header data matches */
            if ((FunctionNumber == PdoExtension->Slot.u.AsULONG) &&
                (PdoExtension->VendorId == PciData->VendorID) &&
                (PdoExtension->DeviceId == PciData->DeviceID) &&
                (PdoExtension->RevisionId == PciData->RevisionID))
            {
                /* This is considered to be the same PDO */
                break;
            }
        }
    }
 
    /* Was this a low-IRQL call? */
    if (Irql < DISPATCH_LEVEL)
    {
        /* Release this device's lock */
        KeSetEvent(&DeviceExtension->ChildListLock, IO_NO_INCREMENT, FALSE);
        KeLeaveCriticalRegion();
    }
 
    /* If the search found something, this is non-NULL, otherwise it's NULL */
    return PdoExtension;
}

Referenced by PciScanBus().

PciGetAdjustedInterruptLine()

UCHAR NTAPI PciGetAdjustedInterruptLine

(

IN PPCI_PDO_EXTENSION

PdoExtension

)

Definition at line 24 of file config.c.

{
    UCHAR InterruptLine = 0, PciInterruptLine;
    ULONG Length;
 
    /* Does the device have an interrupt pin? */
    if (PdoExtension->InterruptPin)
    {
        /* Find the associated line on the parent bus */
        Length = HalGetBusDataByOffset(PCIConfiguration,
                                       PdoExtension->ParentFdoExtension->BaseBus,
                                       PdoExtension->Slot.u.AsULONG,
                                       &PciInterruptLine,
                                       FIELD_OFFSET(PCI_COMMON_HEADER,
                                                    u.type0.InterruptLine),
                                       sizeof(UCHAR));
        if (Length) InterruptLine = PciInterruptLine;
    }
 
    /* Either keep the original interrupt line, or the one on the master bus */
    return InterruptLine ? PdoExtension->RawInterruptLine : InterruptLine;
}

Referenced by PciScanBus().

PciGetBiosConfig()

NTSTATUS NTAPI PciGetBiosConfig	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		OUT PPCI_COMMON_HEADER	PciData
	)

Definition at line 768 of file utils.c.

{
    HANDLE KeyHandle, SubKeyHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName, KeyValue;
    WCHAR Buffer[32];
    WCHAR DataBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + PCI_COMMON_HDR_LENGTH];
    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PVOID)DataBuffer;
    NTSTATUS Status;
    ULONG ResultLength;
    PAGED_CODE();
 
    /* Open the PCI key */
    Status = IoOpenDeviceRegistryKey(DeviceExtension->ParentFdoExtension->
                                     PhysicalDeviceObject,
                                     TRUE,
                                     KEY_ALL_ACCESS,
                                     &KeyHandle);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Create a volatile BIOS configuration key */
    RtlInitUnicodeString(&KeyName, L"BiosConfig");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_KERNEL_HANDLE,
                               KeyHandle,
                               NULL);
    Status = ZwCreateKey(&SubKeyHandle,
                         KEY_READ,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    ZwClose(KeyHandle);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Create the key value based on the device and function number */
    swprintf(Buffer,
             L"DEV_%02x&FUN_%02x",
             DeviceExtension->Slot.u.bits.DeviceNumber,
             DeviceExtension->Slot.u.bits.FunctionNumber);
    RtlInitUnicodeString(&KeyValue, Buffer);
 
    /* Query the value information (PCI BIOS configuration header) */
    Status = ZwQueryValueKey(SubKeyHandle,
                             &KeyValue,
                             KeyValuePartialInformation,
                             PartialInfo,
                             sizeof(DataBuffer),
                             &ResultLength);
    ZwClose(SubKeyHandle);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* If any information was returned, go ahead and copy its data */
    ASSERT(PartialInfo->DataLength == PCI_COMMON_HDR_LENGTH);
    RtlCopyMemory(PciData, PartialInfo->Data, PCI_COMMON_HDR_LENGTH);
    return Status;
}

Referenced by PciScanBus(), and PPBridge_SaveCurrentSettings().

PciGetConfigHandlers()

NTSTATUS NTAPI PciGetConfigHandlers

(

IN PPCI_FDO_EXTENSION

FdoExtension

)

Definition at line 224 of file config.c.

{
    PBUS_HANDLER BusHandler;
    NTSTATUS Status;
    ASSERT(FdoExtension->BusHandler == NULL);
 
    /* Check if this is the FDO for the root bus */
    if (PCI_IS_ROOT_FDO(FdoExtension))
    {
        /* Query the PCI Bus Interface that ACPI exposes */
        ASSERT(FdoExtension->PciBusInterface == NULL);
        Status = PciQueryForPciBusInterface(FdoExtension);
        if (!NT_SUCCESS(Status))
        {
            /* No ACPI, so Bus Numbers should be maintained by BIOS */
            ASSERT(!PciAssignBusNumbers);
        }
        else
        {
            /* ACPI detected, PCI Bus Driver will reconfigure bus numbers*/
            PciAssignBusNumbers = TRUE;
        }
    }
    else
    {
        /* Check if the root bus already has the interface set up */
        if (FdoExtension->BusRootFdoExtension->PciBusInterface)
        {
            /* Nothing for this FDO to do */
            return STATUS_SUCCESS;
        }
 
        /* Fail into case below so we can query the HAL interface */
        Status = STATUS_NOT_SUPPORTED;
    }
 
    /* If the ACPI PCI Bus Interface couldn't be obtained, try the HAL */
    if (!NT_SUCCESS(Status))
    {
        /* Bus number assignment should be static */
        ASSERT(Status == STATUS_NOT_SUPPORTED);
        ASSERT(!PciAssignBusNumbers);
 
        /* Call the HAL to obtain the bus handler for PCI */
        BusHandler = HalReferenceHandlerForBus(PCIBus, FdoExtension->BaseBus);
        FdoExtension->BusHandler = BusHandler;
 
        /* Fail if the HAL does not have a PCI Bus Handler for this bus */
        if (!BusHandler) return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* Appropriate interface was obtained */
    return STATUS_SUCCESS;
}

Referenced by PciAddDevice().

PciGetDeviceDescriptionMessage()

PWCHAR NTAPI PciGetDeviceDescriptionMessage	(	IN UCHAR	BaseClass,
		IN UCHAR	SubClass
	)

Definition at line 88 of file id.c.

{
    PWCHAR Message;
    ULONG Identifier;
 
    /* The message identifier in the table is encoded based on the PCI class */
    Identifier = (BaseClass << 8) | SubClass;
 
    /* Go grab the description message for this device */
    Message = PciGetDescriptionMessage(Identifier, NULL);
    if (!Message)
    {
        /* It wasn't found, allocate a buffer for a generic description */
        Message = ExAllocatePoolWithTag(PagedPool, sizeof(L"PCI Device"), 'bicP');
        if (Message) RtlCopyMemory(Message, L"PCI Device", sizeof(L"PCI Device"));
    }
 
    /* Return the description message */
    return Message;
}

Referenced by PciQueryDeviceText(), and PciScanBus().

PciGetDeviceProperty()

NTSTATUS NTAPI PciGetDeviceProperty	(	IN PDEVICE_OBJECT	DeviceObject,
		IN DEVICE_REGISTRY_PROPERTY	DeviceProperty,
		OUT PVOID *	OutputBuffer
	)

Definition at line 475 of file utils.c.

{
    NTSTATUS Status;
    ULONG BufferLength, ResultLength;
    PVOID Buffer;
    do
    {
        /* Query the requested property size */
        Status = IoGetDeviceProperty(DeviceObject,
                                     DeviceProperty,
                                     0,
                                     NULL,
                                     &BufferLength);
        if (Status != STATUS_BUFFER_TOO_SMALL)
        {
            /* Call should've failed with buffer too small! */
            DPRINT1("PCI - Unexpected status from GetDeviceProperty, saw %08X, expected %08X.\n",
                    Status,
                    STATUS_BUFFER_TOO_SMALL);
            *OutputBuffer = NULL;
            ASSERTMSG("PCI Successfully did the impossible!\n", FALSE);
            break;
        }
 
        /* Allocate the required buffer */
        Buffer = ExAllocatePoolWithTag(PagedPool, BufferLength, 'BicP');
        if (!Buffer)
        {
            /* No memory, fail the request */
            DPRINT1("PCI - Failed to allocate DeviceProperty buffer (%u bytes).\n", BufferLength);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Do the actual property query call */
        Status = IoGetDeviceProperty(DeviceObject,
                                     DeviceProperty,
                                     BufferLength,
                                     Buffer,
                                     &ResultLength);
        if (!NT_SUCCESS(Status)) break;
 
        /* Return the buffer to the caller */
        ASSERT(BufferLength == ResultLength);
        *OutputBuffer = Buffer;
        return STATUS_SUCCESS;
    } while (FALSE);
 
    /* Failure path */
    return STATUS_UNSUCCESSFUL;
}

Referenced by PciAddDevice().

PciGetHackFlags()

ULONGLONG NTAPI PciGetHackFlags	(	IN USHORT	VendorId,
		IN USHORT	DeviceId,
		IN USHORT	SubVendorId,
		IN USHORT	SubSystemId,
		IN UCHAR	RevisionId
	)

Definition at line 604 of file utils.c.

{
    PPCI_HACK_ENTRY HackEntry;
    ULONGLONG HackFlags;
    ULONG LastWeight, MatchWeight;
    ULONG EntryFlags;
 
    /* ReactOS SetupLDR Hack */
    if (!PciHackTable) return 0;
 
    /* Initialize the variables before looping */
    LastWeight = 0;
    HackFlags = 0;
    ASSERT(PciHackTable);
 
    /* Scan the hack table */
    for (HackEntry = PciHackTable;
         HackEntry->VendorID != PCI_INVALID_VENDORID;
         ++HackEntry)
    {
        /* Check if there's an entry for this device */
        if ((HackEntry->DeviceID == DeviceId) &&
            (HackEntry->VendorID == VendorId))
        {
            /* This is a basic match */
            EntryFlags = HackEntry->Flags;
            MatchWeight = 1;
 
            /* Does the entry have revision information? */
            if (EntryFlags & PCI_HACK_HAS_REVISION_INFO)
            {
                /* Check if the revision matches, if so, this is a better match */
                if (HackEntry->RevisionID != RevisionId) continue;
                MatchWeight = 3;
            }
 
            /* Does the netry have subsystem information? */
            if (EntryFlags & PCI_HACK_HAS_SUBSYSTEM_INFO)
            {
                /* Check if it matches, if so, this is the best possible match */
                if ((HackEntry->SubVendorID != SubVendorId) ||
                    (HackEntry->SubSystemID != SubSystemId))
                {
                    continue;
                }
                MatchWeight += 4;
            }
 
            /* Is this the best match yet? */
            if (MatchWeight > LastWeight)
            {
                /* This is the best match for now, use this as the hack flags */
                HackFlags = HackEntry->HackFlags;
                LastWeight = MatchWeight;
            }
        }
    }
 
    /* Return the best match */
    return HackFlags;
}

Referenced by PciScanBus().

PciGetRegistryValue()

NTSTATUS NTAPI PciGetRegistryValue	(	IN PWCHAR	ValueName,
		IN PWCHAR	KeyName,
		IN HANDLE	RootHandle,
		IN ULONG	Type,
		OUT PVOID *	OutputBuffer,
		OUT PULONG	OutputLength
	)

Definition at line 192 of file utils.c.

{
    NTSTATUS Status;
    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
    ULONG NeededLength, ActualLength;
    UNICODE_STRING ValueString;
    HANDLE KeyHandle;
    BOOLEAN Result;
 
    /* So we know what to free at the end of the body */
    PartialInfo = NULL;
    KeyHandle = NULL;
    do
    {
        /* Open the key by name, rooted off the handle passed */
        Result = PciOpenKey(KeyName,
                            RootHandle,
                            KEY_QUERY_VALUE,
                            &KeyHandle,
                            &Status);
        if (!Result) break;
 
        /* Query for the size that's needed for the value that was passed in */
        RtlInitUnicodeString(&ValueString, ValueName);
        Status = ZwQueryValueKey(KeyHandle,
                                 &ValueString,
                                 KeyValuePartialInformation,
                                 NULL,
                                 0,
                                 &NeededLength);
        ASSERT(!NT_SUCCESS(Status));
        if (Status != STATUS_BUFFER_TOO_SMALL) break;
 
        /* Allocate an appropriate buffer for the size that was returned */
        ASSERT(NeededLength != 0);
        Status = STATUS_INSUFFICIENT_RESOURCES;
        PartialInfo = ExAllocatePoolWithTag(PagedPool,
                                            NeededLength,
                                            PCI_POOL_TAG);
        if (!PartialInfo) break;
 
        /* Query the actual value information now that the size is known */
        Status = ZwQueryValueKey(KeyHandle,
                                 &ValueString,
                                 KeyValuePartialInformation,
                                 PartialInfo,
                                 NeededLength,
                                 &ActualLength);
        if (!NT_SUCCESS(Status)) break;
 
        /* Make sure it's of the type that the caller expects */
        Status = STATUS_INVALID_PARAMETER;
        if (PartialInfo->Type != Type) break;
 
        /* Subtract the registry-specific header, to get the data size */
        ASSERT(NeededLength == ActualLength);
        NeededLength -= sizeof(KEY_VALUE_PARTIAL_INFORMATION);
 
        /* Allocate a buffer to hold the data and return it to the caller */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        *OutputBuffer = ExAllocatePoolWithTag(PagedPool,
                                              NeededLength,
                                              PCI_POOL_TAG);
        if (!*OutputBuffer) break;
 
        /* Copy the data into the buffer and return its length to the caller */
        RtlCopyMemory(*OutputBuffer, PartialInfo->Data, NeededLength);
        if (OutputLength) *OutputLength = NeededLength;
        Status = STATUS_SUCCESS;
    } while (0);
 
    /* Close any opened keys and free temporary allocations */
    if (KeyHandle) ZwClose(KeyHandle);
    if (PartialInfo) ExFreePoolWithTag(PartialInfo, 0);
    return Status;
}

Referenced by DriverEntry(), PciAcpiFindRsdt(), PciGetIrqRoutingTableFromRegistry(), and PciIsDatacenter().

PciHookHal()

VOID NTAPI PciHookHal

(

VOID

)

Definition at line 248 of file hookhal.c.

{
    /* Save the old HAL routines */
    ASSERT(PcipSavedAssignSlotResources == NULL);
    ASSERT(PcipSavedTranslateBusAddress == NULL);
    PcipSavedAssignSlotResources = HalPciAssignSlotResources;
    PcipSavedTranslateBusAddress = HalPciTranslateBusAddress;
 
    /* Take over the HAL's Bus Handler functions */
//    HalPciAssignSlotResources = PciAssignSlotResources;
    HalPciTranslateBusAddress = PciTranslateBusAddress;
}

Referenced by DriverEntry().

PciInitializeArbiterRanges()

NTSTATUS NTAPI PciInitializeArbiterRanges	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCM_RESOURCE_LIST	Resources
	)

Definition at line 128 of file arb_comn.c.

{
    PPCI_PDO_EXTENSION PdoExtension;
    //CM_RESOURCE_TYPE DesiredType;
    PVOID Instance;
    PCI_SIGNATURE ArbiterType;
 
    UNREFERENCED_PARAMETER(Resources);
 
    /* Arbiters should not already be initialized */
    if (DeviceExtension->ArbitersInitialized)
    {
        /* Duplicated start request, fail initialization */
        DPRINT1("PCI Warning hot start FDOx %p, resource ranges not checked.\n", DeviceExtension);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* Check for non-root FDO */
    if (!PCI_IS_ROOT_FDO(DeviceExtension))
    {
        /* Grab the PDO */
        PdoExtension = (PPCI_PDO_EXTENSION)DeviceExtension->PhysicalDeviceObject->DeviceExtension;
        ASSERT_PDO(PdoExtension);
 
        /* Check if this is a subtractive bus */
        if (PdoExtension->Dependent.type1.SubtractiveDecode)
        {
            /* There is nothing to do regarding arbitration of resources */
            DPRINT1("PCI Skipping arbiter initialization for subtractive bridge FDOX %p\n", DeviceExtension);
            return STATUS_SUCCESS;
        }
    }
 
    /* Loop all arbiters */
    for (ArbiterType = PciArb_Io; ArbiterType <= PciArb_Memory; ArbiterType++)
    {
        /* Pick correct resource type for each arbiter */
        if (ArbiterType == PciArb_Io)
        {
            /* I/O Port */
            //DesiredType = CmResourceTypePort;
        }
        else if (ArbiterType == PciArb_Memory)
        {
            /* Device RAM */
            //DesiredType = CmResourceTypeMemory;
        }
        else
        {
            /* Ignore anything else */
            continue;
        }
 
        /* Find an arbiter of this type */
        Instance = PciFindNextSecondaryExtension(&DeviceExtension->SecondaryExtension,
                                                 ArbiterType);
        if (Instance)
        {
            /*
             * Now we should initialize it, not yet implemented because Arb
             * library isn't yet implemented, not even the headers.
             */
            UNIMPLEMENTED;
            //while (TRUE);
        }
        else
        {
            /* The arbiter was not found, this is an error! */
            DPRINT1("PCI - FDO ext 0x%p %s arbiter (REQUIRED) is missing.\n",
                    DeviceExtension,
                    PciArbiterNames[ArbiterType - PciArb_Io]);
        }
    }
 
    /* Arbiters are now initialized */
    DeviceExtension->ArbitersInitialized = TRUE;
    return STATUS_SUCCESS;
}

Referenced by PciFdoIrpStartDevice().

PciInitializeArbiters()

NTSTATUS NTAPI PciInitializeArbiters

(

IN PPCI_FDO_EXTENSION

FdoExtension

)

Definition at line 40 of file arb_comn.c.

{
    PPCI_INTERFACE CurrentInterface, *Interfaces;
    PPCI_PDO_EXTENSION PdoExtension;
    PPCI_ARBITER_INSTANCE ArbiterInterface;
    NTSTATUS Status;
    PCI_SIGNATURE ArbiterType;
    ASSERT_FDO(FdoExtension);
 
    /* Loop all the arbiters */
    for (ArbiterType = PciArb_Io; ArbiterType <= PciArb_BusNumber; ArbiterType++)
    {
        /* Check if this is the extension for the Root PCI Bus */
        if (!PCI_IS_ROOT_FDO(FdoExtension))
        {
            /* Get the PDO extension */
            PdoExtension = FdoExtension->PhysicalDeviceObject->DeviceExtension;
            ASSERT_PDO(PdoExtension);
 
            /* Skip this bus if it does subtractive decode */
            if (PdoExtension->Dependent.type1.SubtractiveDecode)
            {
                DPRINT1("PCI Not creating arbiters for subtractive bus %u\n",
                        PdoExtension->Dependent.type1.SubtractiveDecode);
                continue;
            }
        }
 
        /* Query all the registered arbiter interfaces */
        Interfaces = PciInterfaces;
        while (*Interfaces)
        {
            /* Find the one that matches the arbiter currently being setup */
            CurrentInterface = *Interfaces;
            if (CurrentInterface->Signature == ArbiterType) break;
            Interfaces++;
        }
 
        /* Check if the required arbiter was not found in the list */
        if (!*Interfaces)
        {
            /* Skip this arbiter and try the next one */
            DPRINT1("PCI - FDO ext 0x%p no %s arbiter.\n",
                    FdoExtension,
                    PciArbiterNames[ArbiterType - PciArb_Io]);
            continue;
        }
 
        /* An arbiter was found, allocate an instance for it */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        ArbiterInterface = ExAllocatePoolWithTag(PagedPool,
                                                 sizeof(PCI_ARBITER_INSTANCE),
                                                 PCI_POOL_TAG);
        if (!ArbiterInterface) break;
 
        /* Setup the instance */
        ArbiterInterface->BusFdoExtension = FdoExtension;
        ArbiterInterface->Interface = CurrentInterface;
        swprintf(ArbiterInterface->InstanceName,
                 L"PCI %S (b=%02x)",
                 PciArbiterNames[ArbiterType - PciArb_Io],
                 FdoExtension->BaseBus);
 
        /* Call the interface initializer for it */
        Status = CurrentInterface->Initializer(ArbiterInterface);
        if (!NT_SUCCESS(Status)) break;
 
        /* Link it with this FDO */
        PcipLinkSecondaryExtension(&FdoExtension->SecondaryExtension,
                                   &FdoExtension->SecondaryExtLock,
                                   &ArbiterInterface->Header,
                                   ArbiterType,
                                   PciArbiterDestructor);
 
        /* This arbiter is now initialized, move to the next one */
        DPRINT1("PCI - FDO ext 0x%p %S arbiter initialized (context 0x%p).\n",
                FdoExtension,
                L"ARBITER HEADER MISSING", //ArbiterInterface->CommonInstance.Name,
                ArbiterInterface);
        Status = STATUS_SUCCESS;
    }
 
    /* Return to caller */
    return Status;
}

Referenced by PciAddDevice().

PciInitializeState()

VOID NTAPI PciInitializeState

(

IN PPCI_FDO_EXTENSION

DeviceExtension

)

Definition at line 88 of file state.c.

{
    /* Set the initial state */
    DeviceExtension->DeviceState = PciNotStarted;
    DeviceExtension->TentativeNextState = PciNotStarted;
}

Referenced by PciInitializeFdoExtensionCommonFields(), and PciPdoCreate().

PciInsertEntryAtTail()

VOID NTAPI PciInsertEntryAtTail	(	IN PSINGLE_LIST_ENTRY	ListHead,
		IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PKEVENT	Lock
	)

Definition at line 400 of file utils.c.

{
    PSINGLE_LIST_ENTRY NextEntry;
    PAGED_CODE();
 
    /* Check if a lock was specified */
    if (Lock)
    {
        /* Wait for the lock to be released */
        KeEnterCriticalRegion();
        KeWaitForSingleObject(Lock, Executive, KernelMode, FALSE, NULL);
    }
 
    /* Loop the list until we get to the end, then insert this entry there */
    for (NextEntry = ListHead; NextEntry->Next; NextEntry = NextEntry->Next);
    NextEntry->Next = &DeviceExtension->List;
 
    /* Check if we had acquired a lock previously */
    if (Lock)
    {
        /* Release it */
        KeSetEvent(Lock, IO_NO_INCREMENT, FALSE);
        KeLeaveCriticalRegion();
    }
}

Referenced by PciAddDevice(), and PciPdoCreate().

PciIrpInvalidDeviceRequest()

NTSTATUS NTAPI PciIrpInvalidDeviceRequest	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 277 of file dispatch.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    /* Not supported */
    return STATUS_INVALID_DEVICE_REQUEST;
}

PciIrpNotSupported()

NTSTATUS NTAPI PciIrpNotSupported	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_FDO_EXTENSION	DeviceExtension
	)

Definition at line 261 of file dispatch.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    /* Not supported */
    DPRINT1("WARNING: PCI received unsupported IRP!\n");
    //DbgBreakPoint();
    return STATUS_NOT_SUPPORTED;
}

PciIsCriticalDeviceClass()

BOOLEAN NTAPI PciIsCriticalDeviceClass	(	IN UCHAR	BaseClass,
		IN UCHAR	SubClass
	)

Definition at line 672 of file utils.c.

{
    /* Check for system or bridge devices */
    if (BaseClass == PCI_CLASS_BASE_SYSTEM_DEV)
    {
        /* Interrupt controllers are critical */
        return SubClass == PCI_SUBCLASS_SYS_INTERRUPT_CTLR;
    }
    else if (BaseClass == PCI_CLASS_BRIDGE_DEV)
    {
        /* ISA Bridges are critical */
        return SubClass == PCI_SUBCLASS_BR_ISA;
    }
    else
    {
        /* All display controllers are critical */
        return BaseClass == PCI_CLASS_DISPLAY_CTLR;
    }
}

Referenced by PciScanBus().

PciIsDatacenter()

BOOLEAN NTAPI PciIsDatacenter

(

VOID

)

Definition at line 131 of file utils.c.

{
    BOOLEAN Result;
    PVOID Value;
    ULONG ResultLength;
    NTSTATUS Status;
 
    /* Assume this isn't Datacenter */
    Result = FALSE;
 
    /* First, try opening the setup key */
    Status = PciGetRegistryValue(L"",
                                 L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\setupdd",
                                 0,
                                 REG_BINARY,
                                 &Value,
                                 &ResultLength);
    if (!NT_SUCCESS(Status))
    {
        /* This is not an in-progress Setup boot, so query the suite version */
        Result = PciIsSuiteVersion(VER_SUITE_DATACENTER);
    }
    else
    {
        /* This scenario shouldn't happen yet, since SetupDD isn't used */
        UNIMPLEMENTED_FATAL("ReactOS doesn't use SetupDD for its installation program. Therefore this scenario must not happen!\n");
    }
 
    /* Return if this is Datacenter or not */
    return Result;
}

Referenced by DriverEntry().

PciIsDeviceOnDebugPath()

BOOLEAN NTAPI PciIsDeviceOnDebugPath

(

IN PPCI_PDO_EXTENSION

DeviceExtension

)

Definition at line 751 of file utils.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    /* Check for too many, or no, debug ports */
    ASSERT(PciDebugPortsCount <= MAX_DEBUGGING_DEVICES_SUPPORTED);
    if (!PciDebugPortsCount) return FALSE;
 
    /* eVb has not been able to test such devices yet */
    UNIMPLEMENTED_DBGBREAK();
    return FALSE;
}

Referenced by PciScanBus().

PciIsSlotPresentInParentMethod()

BOOLEAN NTAPI PciIsSlotPresentInParentMethod	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN ULONG	Method
	)

Definition at line 1094 of file utils.c.

{
    BOOLEAN FoundSlot;
    PACPI_METHOD_ARGUMENT Argument;
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
    PACPI_EVAL_OUTPUT_BUFFER OutputBuffer;
    ULONG i, Length;
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Assume slot is not part of the parent method */
    FoundSlot = FALSE;
 
    /* Allocate a 2KB buffer for the method return parameters */
    Length = sizeof(ACPI_EVAL_OUTPUT_BUFFER) + 2048;
    OutputBuffer = ExAllocatePoolWithTag(PagedPool, Length, 'BicP');
    if (OutputBuffer)
    {
        /* Clear out the output buffer */
        RtlZeroMemory(OutputBuffer, Length);
 
        /* Initialize the input buffer with the method requested */
        InputBuffer.Signature = 0;
        *(PULONG)InputBuffer.MethodName = Method;
        InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
        /* Send it to the ACPI driver */
        Status = PciSendIoctl(PdoExtension->ParentFdoExtension->PhysicalDeviceObject,
                              IOCTL_ACPI_EVAL_METHOD,
                              &InputBuffer,
                              sizeof(ACPI_EVAL_INPUT_BUFFER),
                              OutputBuffer,
                              Length);
        if (NT_SUCCESS(Status))
        {
            /* Scan all output arguments */
            for (i = 0; i < OutputBuffer->Count; i++)
            {
                /* Make sure it's an integer */
                Argument = &OutputBuffer->Argument[i];
                if (Argument->Type != ACPI_METHOD_ARGUMENT_INTEGER) continue;
 
                /* Check if the argument matches this PCI slot structure */
                if (Argument->Argument == ((PdoExtension->Slot.u.bits.DeviceNumber) |
                                           ((PdoExtension->Slot.u.bits.FunctionNumber) << 16)))
                {
                    /* This slot has been found, return it */
                    FoundSlot = TRUE;
                    break;
                }
            }
        }
 
        /* Finished with the buffer, free it */
        ExFreePoolWithTag(OutputBuffer, 0);
    }
 
    /* Return if the slot was found */
    return FoundSlot;
}

Referenced by PciApplyHacks(), and PciBridgeIsPositiveDecode().

PciOpenKey()

BOOLEAN NTAPI PciOpenKey	(	IN PWCHAR	KeyName,
		IN HANDLE	RootKey,
		IN ACCESS_MASK	DesiredAccess,
		OUT PHANDLE	KeyHandle,
		OUT PNTSTATUS	KeyStatus
	)

Definition at line 165 of file utils.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyString;
    PAGED_CODE();
 
    /* Initialize the object attributes */
    RtlInitUnicodeString(&KeyString, KeyName);
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyString,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               RootKey,
                               NULL);
 
    /* Open the key, returning a boolean, and the status, if requested */
    Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
    if (KeyStatus) *KeyStatus = Status;
    return NT_SUCCESS(Status);
}

Referenced by DriverEntry(), PciAcpiFindRsdt(), PciGetIrqRoutingTableFromRegistry(), and PciGetRegistryValue().

PciPassIrpFromFdoToPdo()

NTSTATUS NTAPI PciPassIrpFromFdoToPdo	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PIRP	Irp
	)

Definition at line 70 of file dispatch.c.

{
    PIO_STACK_LOCATION IoStackLocation;
    NTSTATUS Status;
    DPRINT1("Pci PassIrp ...\n");
 
    /* Get the stack location to check which function this is */
    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
    if (IoStackLocation->MajorFunction == IRP_MJ_POWER)
    {
        /* Power IRPs are special since we have to notify the Power Manager */
        IoCopyCurrentIrpStackLocationToNext(Irp);
        PoStartNextPowerIrp(Irp);
        Status = PoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
    }
    else
    {
        /* For a normal IRP, just call the next driver in the stack */
        IoSkipCurrentIrpStackLocation(Irp);
        Status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
    }
 
    /* Return the status back to the caller */
    return Status;
}

Referenced by PciDispatchIrp(), and PciFdoIrpQueryInterface().

PciPdoCreate()

NTSTATUS NTAPI PciPdoCreate	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCI_SLOT_NUMBER	Slot,
		OUT PDEVICE_OBJECT *	PdoDeviceObject
	)

Definition at line 530 of file pdo.c.

{
    WCHAR DeviceName[32];
    UNICODE_STRING DeviceString;
    NTSTATUS Status;
    PDEVICE_OBJECT DeviceObject;
    PPCI_PDO_EXTENSION PdoExtension;
    ULONG SequenceNumber;
    PAGED_CODE();
 
    /* Pick an atomically unique sequence number for this device */
    SequenceNumber = InterlockedIncrement(&PciPdoSequenceNumber);
 
    /* Create the standard PCI device name for a PDO */
    swprintf(DeviceName, L"\\Device\\NTPNP_PCI%04d", SequenceNumber);
    RtlInitUnicodeString(&DeviceString, DeviceName);
 
    /* Create the actual device now */
    Status = IoCreateDevice(DeviceExtension->FunctionalDeviceObject->DriverObject,
                            sizeof(PCI_PDO_EXTENSION),
                            &DeviceString,
                            FILE_DEVICE_BUS_EXTENDER,
                            0,
                            0,
                            &DeviceObject);
    ASSERT(NT_SUCCESS(Status));
 
    /* Get the extension for it */
    PdoExtension = (PPCI_PDO_EXTENSION)DeviceObject->DeviceExtension;
    DPRINT1("PCI: New PDO (b=0x%x, d=0x%x, f=0x%x) @ %p, ext @ %p\n",
            DeviceExtension->BaseBus,
            Slot.u.bits.DeviceNumber,
            Slot.u.bits.FunctionNumber,
            DeviceObject,
            DeviceObject->DeviceExtension);
 
    /* Configure the extension */
    PdoExtension->ExtensionType = PciPdoExtensionType;
    PdoExtension->IrpDispatchTable = &PciPdoDispatchTable;
    PdoExtension->PhysicalDeviceObject = DeviceObject;
    PdoExtension->Slot = Slot;
    PdoExtension->PowerState.CurrentSystemState = PowerSystemWorking;
    PdoExtension->PowerState.CurrentDeviceState = PowerDeviceD0;
    PdoExtension->ParentFdoExtension = DeviceExtension;
 
    /* Initialize the lock for arbiters and other interfaces */
    KeInitializeEvent(&PdoExtension->SecondaryExtLock, SynchronizationEvent, TRUE);
 
    /* Initialize the state machine */
    PciInitializeState((PPCI_FDO_EXTENSION)PdoExtension);
 
    /* Add the PDO to the parent's list */
    PdoExtension->Next = NULL;
    PciInsertEntryAtTail((PSINGLE_LIST_ENTRY)&DeviceExtension->ChildPdoList,
                         (PPCI_FDO_EXTENSION)PdoExtension,
                         &DeviceExtension->ChildListLock);
 
    /* And finally return it to the caller */
    *PdoDeviceObject = DeviceObject;
    return STATUS_SUCCESS;
}

Referenced by PciScanBus().

PciPdoIrpCancelRemoveDevice()

NTSTATUS NTAPI PciPdoIrpCancelRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 248 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpCancelStopDevice()

NTSTATUS NTAPI PciPdoIrpCancelStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 290 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpDeviceUsageNotification()

NTSTATUS NTAPI PciPdoIrpDeviceUsageNotification	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 488 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryBusInformation()

NTSTATUS NTAPI PciPdoIrpQueryBusInformation	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 430 of file pdo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(IoStackLocation);
 
    /* Call the worker function */
    return PciQueryBusInformation(DeviceExtension,
                                  (PPNP_BUS_INFORMATION*)&Irp->
                                  IoStatus.Information);
}

PciPdoIrpQueryCapabilities()

NTSTATUS NTAPI PciPdoIrpQueryCapabilities	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 352 of file pdo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(Irp);
 
    /* Call the worker function */
    return PciQueryCapabilities(DeviceExtension,
                                IoStackLocation->
                                Parameters.DeviceCapabilities.Capabilities);
}

PciPdoIrpQueryDeviceRelations()

NTSTATUS NTAPI PciPdoIrpQueryDeviceRelations	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 318 of file pdo.c.

{
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Are ejection relations being queried? */
    if (IoStackLocation->Parameters.QueryDeviceRelations.Type == EjectionRelations)
    {
        /* Call the worker function */
        Status = PciQueryEjectionRelations(DeviceExtension,
                                           (PDEVICE_RELATIONS*)&Irp->
                                           IoStatus.Information);
    }
    else if (IoStackLocation->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
    {
        /* The only other relation supported is the target device relation */
        Status = PciQueryTargetDeviceRelations(DeviceExtension,
                                               (PDEVICE_RELATIONS*)&Irp->
                                               IoStatus.Information);
    }
    else
    {
        /* All other relations are unsupported */
        Status = STATUS_NOT_SUPPORTED;
    }
 
    /* Return either the result of the worker function, or unsupported status */
    return Status;
}

PciPdoIrpQueryDeviceState()

NTSTATUS NTAPI PciPdoIrpQueryDeviceState	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 474 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryDeviceText()

NTSTATUS NTAPI PciPdoIrpQueryDeviceText	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 399 of file pdo.c.

{
    PAGED_CODE();
 
    /* Call the worker function */
    return PciQueryDeviceText(DeviceExtension,
                              IoStackLocation->
                              Parameters.QueryDeviceText.DeviceTextType,
                              IoStackLocation->
                              Parameters.QueryDeviceText.LocaleId,
                              (PWCHAR*)&Irp->IoStatus.Information);
}

PciPdoIrpQueryId()

NTSTATUS NTAPI PciPdoIrpQueryId	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 416 of file pdo.c.

{
    PAGED_CODE();
 
    /* Call the worker function */
    return PciQueryId(DeviceExtension,
                      IoStackLocation->Parameters.QueryId.IdType,
                      (PWCHAR*)&Irp->IoStatus.Information);
}

PciPdoIrpQueryInterface()

NTSTATUS NTAPI PciPdoIrpQueryInterface	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 304 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryLegacyBusInformation()

NTSTATUS NTAPI PciPdoIrpQueryLegacyBusInformation	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 516 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryPower()

NTSTATUS NTAPI PciPdoIrpQueryPower	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 107 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryRemoveDevice()

NTSTATUS NTAPI PciPdoIrpQueryRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 220 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpQueryResourceRequirements()

NTSTATUS NTAPI PciPdoIrpQueryResourceRequirements	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 383 of file pdo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(IoStackLocation);
 
    /* Call the worker function */
    return PciQueryRequirements(DeviceExtension,
                                (PIO_RESOURCE_REQUIREMENTS_LIST*)&Irp->
                                IoStatus.Information);
}

PciPdoIrpQueryResources()

NTSTATUS NTAPI PciPdoIrpQueryResources	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 368 of file pdo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(IoStackLocation);
 
    /* Call the worker function */
    return PciQueryResources(DeviceExtension,
                            (PCM_RESOURCE_LIST*)&Irp->IoStatus.Information);
}

PciPdoIrpQueryStopDevice()

NTSTATUS NTAPI PciPdoIrpQueryStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 276 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpReadConfig()

NTSTATUS NTAPI PciPdoIrpReadConfig	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 446 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpRemoveDevice()

NTSTATUS NTAPI PciPdoIrpRemoveDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 234 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpStartDevice()

NTSTATUS NTAPI PciPdoIrpStartDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 121 of file pdo.c.

{
    NTSTATUS Status;
    BOOLEAN Changed, DoReset;
    POWER_STATE PowerState;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(Irp);
 
    DoReset = FALSE;
 
    /* Begin entering the start phase */
    Status = PciBeginStateTransition((PVOID)DeviceExtension, PciStarted);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if this is a VGA device */
    if (((DeviceExtension->BaseClass == PCI_CLASS_PRE_20) &&
         (DeviceExtension->SubClass == PCI_SUBCLASS_PRE_20_VGA)) ||
        ((DeviceExtension->BaseClass == PCI_CLASS_DISPLAY_CTLR) &&
         (DeviceExtension->SubClass == PCI_SUBCLASS_VID_VGA_CTLR)))
    {
        /* Always force it on */
        DeviceExtension->CommandEnables |= (PCI_ENABLE_IO_SPACE |
                                            PCI_ENABLE_MEMORY_SPACE);
    }
 
    /* Check if native IDE is enabled and it owns the I/O ports */
    if (DeviceExtension->IoSpaceUnderNativeIdeControl)
    {
        /* Then don't allow I/O access */
        DeviceExtension->CommandEnables &= ~PCI_ENABLE_IO_SPACE;
    }
 
    /* Always enable bus mastering */
    DeviceExtension->CommandEnables |= PCI_ENABLE_BUS_MASTER;
 
    /* Check if the OS assigned resources differ from the PCI configuration */
    Changed = PciComputeNewCurrentSettings(DeviceExtension,
                                           IoStackLocation->Parameters.
                                           StartDevice.AllocatedResources);
    if (Changed)
    {
        /* Remember this for later */
        DeviceExtension->MovedDevice = TRUE;
    }
    else
    {
        /* All good */
        DPRINT1("PCI - START not changing resource settings.\n");
    }
 
    /* Check if the device was sleeping */
    if (DeviceExtension->PowerState.CurrentDeviceState != PowerDeviceD0)
    {
        /* Power it up */
        Status = PciSetPowerManagedDevicePowerState(DeviceExtension,
                                                    PowerDeviceD0,
                                                    FALSE);
        if (!NT_SUCCESS(Status))
        {
            /* Powerup fail, fail the request */
            PciCancelStateTransition((PVOID)DeviceExtension, PciStarted);
            return STATUS_DEVICE_POWER_FAILURE;
        }
 
        /* Tell the power manager that the device is powered up */
        PowerState.DeviceState = PowerDeviceD0;
        PoSetPowerState(DeviceExtension->PhysicalDeviceObject,
                        DevicePowerState,
                        PowerState);
 
        /* Update internal state */
        DeviceExtension->PowerState.CurrentDeviceState = PowerDeviceD0;
 
        /* This device's resources and decodes will need to be reset */
        DoReset = TRUE;
    }
 
    /* Update resource information now that the device is powered up and active */
    Status = PciSetResources(DeviceExtension, DoReset, TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* That failed, so cancel the transition */
        PciCancelStateTransition((PVOID)DeviceExtension, PciStarted);
    }
    else
    {
        /* Fully commit, as the device is now started up and ready to go */
        PciCommitStateTransition((PVOID)DeviceExtension, PciStarted);
    }
 
    /* Return the result of the start request */
    return Status;
}

PciPdoIrpStopDevice()

NTSTATUS NTAPI PciPdoIrpStopDevice	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 262 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpSurpriseRemoval()

NTSTATUS NTAPI PciPdoIrpSurpriseRemoval	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 502 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoIrpWriteConfig()

NTSTATUS NTAPI PciPdoIrpWriteConfig	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 460 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PciPdoSetPowerState()

NTSTATUS NTAPI PciPdoSetPowerState	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 93 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED;
    return STATUS_NOT_SUPPORTED;
}

PciPdoWaitWake()

NTSTATUS NTAPI PciPdoWaitWake	(	IN PIRP	Irp,
		IN PIO_STACK_LOCATION	IoStackLocation,
		IN PPCI_PDO_EXTENSION	DeviceExtension
	)

Definition at line 79 of file pdo.c.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(IoStackLocation);
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_SUPPORTED;
}

PcipLinkSecondaryExtension()

VOID NTAPI PcipLinkSecondaryExtension	(	IN PSINGLE_LIST_ENTRY	List,
		IN PVOID	Lock,
		IN PPCI_SECONDARY_EXTENSION	SecondaryExtension,
		IN PCI_SIGNATURE	ExtensionType,
		IN PVOID	Destructor
	)

Definition at line 459 of file utils.c.

{
    PAGED_CODE();
 
    /* Setup the extension data, and insert it into the primary's list */
    SecondaryExtension->ExtensionType = ExtensionType;
    SecondaryExtension->Destructor = Destructor;
    PciInsertEntryAtHead(List, &SecondaryExtension->List, Lock);
}

Referenced by PciInitializeArbiters().

PciPmeInterfaceConstructor()

NTSTATUS NTAPI PciPmeInterfaceConstructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file pmeintf.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Only version 1 is supported */
    if (Version != PCI_PME_INTRF_STANDARD_VER) return STATUS_NOINTERFACE;
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

PciPmeInterfaceInitializer()

NTSTATUS NTAPI PciPmeInterfaceInitializer

(

IN PVOID

Instance

)

Definition at line 35 of file pmeintf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI PciPmeInterfaceInitializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

PciQueryBusInformation()

NTSTATUS NTAPI PciQueryBusInformation	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		OUT PPNP_BUS_INFORMATION *	Buffer
	)

Definition at line 1316 of file utils.c.

{
    PPNP_BUS_INFORMATION BusInfo;
 
    /* Allocate a structure for the bus information */
    BusInfo = ExAllocatePoolWithTag(PagedPool,
                                    sizeof(PNP_BUS_INFORMATION),
                                    'BicP');
    if (!BusInfo) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Write the correct GUID and bus type identifier, and fill the bus number */
    BusInfo->BusTypeGuid = GUID_BUS_TYPE_PCI;
    BusInfo->LegacyBusType = PCIBus;
    BusInfo->BusNumber = PdoExtension->ParentFdoExtension->BaseBus;
 
    *Buffer = BusInfo;
 
    return STATUS_SUCCESS;
}

Referenced by PciPdoIrpQueryBusInformation().

PciQueryCapabilities()

NTSTATUS NTAPI PciQueryCapabilities	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN OUT PDEVICE_CAPABILITIES	DeviceCapability
	)

Definition at line 1728 of file utils.c.

{
    NTSTATUS Status;
 
    /* A PDO ID is never unique, and its address is its function and device */
    DeviceCapability->UniqueID = FALSE;
    DeviceCapability->Address = PdoExtension->Slot.u.bits.FunctionNumber |
                                (PdoExtension->Slot.u.bits.DeviceNumber << 16);
 
    /* Check for host bridges */
    if ((PdoExtension->BaseClass == PCI_CLASS_BRIDGE_DEV) &&
        (PdoExtension->SubClass == PCI_SUBCLASS_BR_HOST))
    {
        /* Raw device opens to a host bridge are acceptable */
        DeviceCapability->RawDeviceOK = TRUE;
    }
    else
    {
        /* Otherwise, other PDOs cannot be directly opened */
        DeviceCapability->RawDeviceOK = FALSE;
    }
 
    /* PCI PDOs are pretty fixed things */
    DeviceCapability->LockSupported = FALSE;
    DeviceCapability->EjectSupported = FALSE;
    DeviceCapability->Removable = FALSE;
    DeviceCapability->DockDevice = FALSE;
 
    /* The slot number is stored as a device property, go query it */
    PciDetermineSlotNumber(PdoExtension, &DeviceCapability->UINumber);
 
    /* Finally, query and power capabilities and convert them for PnP usage */
    Status = PciQueryPowerCapabilities(PdoExtension, DeviceCapability);
 
    /* Dump the capabilities if it all worked, and return the status */
    if (NT_SUCCESS(Status)) PciDebugDumpQueryCapabilities(DeviceCapability);
    return Status;
}

Referenced by PciPdoIrpQueryCapabilities().

PciQueryDeviceRelations()

NTSTATUS NTAPI PciQueryDeviceRelations	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN OUT PDEVICE_RELATIONS *	pDeviceRelations
	)

Definition at line 2034 of file enum.c.

{
    NTSTATUS Status;
    PPCI_PDO_EXTENSION PdoExtension;
    ULONG PdoCount = 0;
    PDEVICE_RELATIONS DeviceRelations, NewRelations;
    SIZE_T Size;
    PDEVICE_OBJECT DeviceObject, *ObjectArray;
    PAGED_CODE();
 
    /* Make sure the FDO is started */
    ASSERT(DeviceExtension->DeviceState == PciStarted);
 
    /* Synchronize while we enumerate the bus */
    Status = PciBeginStateTransition(DeviceExtension, PciSynchronizedOperation);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Scan all children PDO */
    for (PdoExtension = DeviceExtension->ChildPdoList;
         PdoExtension;
         PdoExtension = PdoExtension->Next)
    {
        /* Invalidate them */
        PdoExtension->NotPresent = TRUE;
    }
 
    /* Scan the PCI Bus */
    Status = PciScanBus(DeviceExtension);
    ASSERT(NT_SUCCESS(Status));
 
    /* Enumerate all children PDO again */
    for (PdoExtension = DeviceExtension->ChildPdoList;
         PdoExtension;
         PdoExtension = PdoExtension->Next)
    {
        /* Check for PDOs that are still invalidated */
        if (PdoExtension->NotPresent)
        {
            /* This means this PDO existed before, but not anymore */
            PdoExtension->ReportedMissing = TRUE;
            DPRINT1("PCI - Old device (pdox) %p not found on rescan.\n",
                    PdoExtension);
        }
        else
        {
            /* Increase count of detected PDOs */
            PdoCount++;
        }
    }
 
    /* Read the current relations and add the newly discovered relations */
    DeviceRelations = *pDeviceRelations;
    Size = FIELD_OFFSET(DEVICE_RELATIONS, Objects) +
           PdoCount * sizeof(PDEVICE_OBJECT);
    if (DeviceRelations) Size += sizeof(PDEVICE_OBJECT) * DeviceRelations->Count;
 
    /* Allocate the device relations */
    NewRelations = (PDEVICE_RELATIONS)ExAllocatePoolWithTag(0, Size, 'BicP');
    if (!NewRelations)
    {
        /* Out of space, cancel the operation */
        PciCancelStateTransition(DeviceExtension, PciSynchronizedOperation);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Check if there were any older relations */
    NewRelations->Count = 0;
    if (DeviceRelations)
    {
        /* Copy the old relations into the new buffer, then free the old one */
        RtlCopyMemory(NewRelations,
                      DeviceRelations,
                      FIELD_OFFSET(DEVICE_RELATIONS, Objects) +
                      DeviceRelations->Count * sizeof(PDEVICE_OBJECT));
        ExFreePoolWithTag(DeviceRelations, 0);
    }
 
    /* Print out that we're ready to dump relations */
    DPRINT1("PCI QueryDeviceRelations/BusRelations FDOx %p (bus 0x%02x)\n",
            DeviceExtension,
            DeviceExtension->BaseBus);
 
    /* Loop the current PDO children and the device relation object array */
    PdoExtension = DeviceExtension->ChildPdoList;
    ObjectArray = &NewRelations->Objects[NewRelations->Count];
    while (PdoExtension)
    {
        /* Dump this relation */
        DPRINT1("  QDR PDO %p (x %p)%s\n",
                PdoExtension->PhysicalDeviceObject,
                PdoExtension,
                PdoExtension->NotPresent ?
                "<Omitted, device flaged not present>" : "");
 
        /* Is this PDO present? */
        if (!PdoExtension->NotPresent)
        {
            /* Reference it and add it to the array */
            DeviceObject = PdoExtension->PhysicalDeviceObject;
            ObReferenceObject(DeviceObject);
            *ObjectArray++ = DeviceObject;
        }
 
        /* Go to the next PDO */
        PdoExtension = PdoExtension->Next;
    }
 
    /* Terminate dumping the relations */
    DPRINT1("  QDR Total PDO count = %u (%u already in list)\n",
            NewRelations->Count + PdoCount,
            NewRelations->Count);
 
    /* Return the final count and the new buffer */
    NewRelations->Count += PdoCount;
    *pDeviceRelations = NewRelations;
    return STATUS_SUCCESS;
}

Referenced by PciFdoIrpQueryDeviceRelations().

PciQueryDeviceText()

NTSTATUS NTAPI PciQueryDeviceText	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN DEVICE_TEXT_TYPE	QueryType,
		IN ULONG	Locale,
		OUT PWCHAR *	Buffer
	)

Definition at line 394 of file id.c.

{
    PWCHAR MessageBuffer, LocationBuffer;
    ULONG Length;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(Locale);
 
    /* Check what the caller is requesting */
    switch (QueryType)
    {
        case DeviceTextDescription:
 
            /* Get the message from the resource section */
            MessageBuffer = PciGetDeviceDescriptionMessage(PdoExtension->BaseClass,
                                                           PdoExtension->SubClass);
 
            /* Return it to the caller, and select proper status code */
            *Buffer = MessageBuffer;
            Status = MessageBuffer ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
            break;
 
        case DeviceTextLocationInformation:
 
            /* Get the message from the resource section */
            MessageBuffer = PciGetDescriptionMessage(0x10000, &Length);
            if (!MessageBuffer)
            {
                /* It should be there, but fail if it wasn't found for some reason */
                Status = STATUS_NOT_SUPPORTED;
                break;
            }
 
            /* Add space for a null-terminator, and allocate the buffer */
            Length += 2 * sizeof(UNICODE_NULL);
            LocationBuffer = ExAllocatePoolWithTag(PagedPool,
                                                   Length * sizeof(WCHAR),
                                                   'BicP');
            *Buffer = LocationBuffer;
 
            /* Check if the allocation succeeded */
            if (LocationBuffer)
            {
                /* Build the location string based on bus, function, and device */
                swprintf(LocationBuffer,
                         MessageBuffer,
                         PdoExtension->ParentFdoExtension->BaseBus,
                         PdoExtension->Slot.u.bits.FunctionNumber,
                         PdoExtension->Slot.u.bits.DeviceNumber);
            }
 
            /* Free the original string from the resource section */
            ExFreePoolWithTag(MessageBuffer, 0);
 
            /* Select the correct status */
            Status = LocationBuffer ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
            break;
 
        default:
 
            /* Anything else is unsupported */
            Status = STATUS_NOT_SUPPORTED;
            break;
    }
 
    /* Return whether or not a device text string was indeed found */
    return Status;
}

Referenced by PciPdoIrpQueryDeviceText().

PciQueryEjectionRelations()

NTSTATUS NTAPI PciQueryEjectionRelations	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN OUT PDEVICE_RELATIONS *	pDeviceRelations
	)

Definition at line 538 of file enum.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(pDeviceRelations);
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by PciPdoIrpQueryDeviceRelations().

PciQueryId()

NTSTATUS NTAPI PciQueryId	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN BUS_QUERY_ID_TYPE	QueryType,
		OUT PWCHAR *	Buffer
	)

Definition at line 200 of file id.c.

{
    ULONG SubsysId;
    CHAR VendorString[22];
    PPCI_PDO_EXTENSION PdoExtension;
    PPCI_FDO_EXTENSION ParentExtension;
    PWCHAR StringBuffer;
    ULONG i, Size;
    NTSTATUS Status;
    PANSI_STRING NextString;
    UNICODE_STRING DestinationString;
    PCI_ID_BUFFER IdBuffer;
    PAGED_CODE();
 
    /* Assume failure */
    Status = STATUS_SUCCESS;
    *Buffer = NULL;
 
    /* Start with the genric vendor string, which is the vendor ID + device ID */
    sprintf(VendorString,
            "PCI\\VEN_%04X&DEV_%04X",
            DeviceExtension->VendorId,
            DeviceExtension->DeviceId);
 
    /* Initialize the PCI ID Buffer */
    PciInitIdBuffer(&IdBuffer);
 
    /* Build the subsystem ID as shown in PCI ID Strings */
    SubsysId = DeviceExtension->SubsystemVendorId | (DeviceExtension->SubsystemId << 16);
 
    /* Check what the caller is requesting */
    switch (QueryType)
    {
        case BusQueryDeviceID:
 
            /* A single ID, the vendor string + the revision ID */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X&REV_%02X",
                        VendorString,
                        SubsysId,
                        DeviceExtension->RevisionId);
            break;
 
        case BusQueryHardwareIDs:
 
            /* First the vendor string + the subsystem ID + the revision ID */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X&REV_%02X",
                        VendorString,
                        SubsysId,
                        DeviceExtension->RevisionId);
 
            /* Next, without the revision */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X",
                        VendorString,
                        SubsysId);
 
            /* Next, the vendor string + the base class + sub class + progif */
            PciIdPrintf(&IdBuffer,
                        "%s&CC_%02X%02X%02X",
                        VendorString,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass,
                        DeviceExtension->ProgIf);
 
            /* Next, without the progif */
            PciIdPrintf(&IdBuffer,
                        "%s&CC_%02X%02X",
                        VendorString,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And finally, a terminator */
            PciIdPrintf(&IdBuffer, "\0");
            break;
 
        case BusQueryCompatibleIDs:
 
            /* First, the vendor + revision ID only */
            PciIdPrintf(&IdBuffer,
                        "%s&REV_%02X",
                        VendorString,
                        DeviceExtension->RevisionId);
 
            /* Next, the vendor string alone */
            PciIdPrintf(&IdBuffer, "%s", VendorString);
 
            /* Next, the vendor ID + the base class + the sub class + progif */
            PciIdPrintf(&IdBuffer,
                         "PCI\\VEN_%04X&CC_%02X%02X%02X",
                         DeviceExtension->VendorId,
                         DeviceExtension->BaseClass,
                         DeviceExtension->SubClass,
                         DeviceExtension->ProgIf);
 
            /* Now without the progif */
            PciIdPrintf(&IdBuffer,
                        "PCI\\VEN_%04X&CC_%02X%02X",
                        DeviceExtension->VendorId,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And then just the vendor ID itself */
            PciIdPrintf(&IdBuffer,
                        "PCI\\VEN_%04X",
                        DeviceExtension->VendorId);
 
            /* Then the base class + subclass + progif, without any vendor */
            PciIdPrintf(&IdBuffer,
                        "PCI\\CC_%02X%02X%02X",
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass,
                        DeviceExtension->ProgIf);
 
            /* Next, without the progif */
            PciIdPrintf(&IdBuffer,
                        "PCI\\CC_%02X%02X",
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And finally, a terminator */
            PciIdPrintf(&IdBuffer, "\0");
            break;
 
        case BusQueryInstanceID:
 
            /* Start with a terminator */
            PciIdPrintf(&IdBuffer, "\0");
 
            /* And then encode the device and function number */
            PciIdPrintfAppend(&IdBuffer,
                              "%02X",
                              (DeviceExtension->Slot.u.bits.DeviceNumber << 3) |
                              DeviceExtension->Slot.u.bits.FunctionNumber);
 
            /* Loop every parent until the root */
            ParentExtension = DeviceExtension->ParentFdoExtension;
            while (!PCI_IS_ROOT_FDO(ParentExtension))
            {
                /* And encode the parent's device and function number as well */
                PdoExtension = ParentExtension->PhysicalDeviceObject->DeviceExtension;
                PciIdPrintfAppend(&IdBuffer,
                                  "%02X",
                                  (PdoExtension->Slot.u.bits.DeviceNumber << 3) |
                                  PdoExtension->Slot.u.bits.FunctionNumber);
            }
            break;
 
        default:
 
            /* Unknown query type */
            DPRINT1("PciQueryId expected ID type = %d\n", QueryType);
            return STATUS_NOT_SUPPORTED;
    }
 
    /* Something should've been generated if this has been reached */
    ASSERT(IdBuffer.Count > 0);
 
    /* Allocate the final string buffer to hold the ID */
    StringBuffer = ExAllocatePoolWithTag(PagedPool, IdBuffer.TotalLength, 'BicP');
    if (!StringBuffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Build the UNICODE_STRING structure for it */
    DPRINT1("PciQueryId(%d)\n", QueryType);
    DestinationString.Buffer = StringBuffer;
    DestinationString.MaximumLength = IdBuffer.TotalLength;
 
    /* Loop every ID in the buffer */
    for (i = 0; i < IdBuffer.Count; i++)
    {
        /* Select the ANSI_STRING for the ID */
        NextString = &IdBuffer.Strings[i];
        DPRINT1("    <- \"%s\"\n", NextString->Buffer);
 
        /* Convert it to a UNICODE_STRING */
        Status = RtlAnsiStringToUnicodeString(&DestinationString, NextString, FALSE);
        ASSERT(NT_SUCCESS(Status));
 
        /* Add it into the final destination buffer */
        Size = IdBuffer.StringSize[i];
        DestinationString.MaximumLength -= Size;
        DestinationString.Buffer += (Size / sizeof(WCHAR));
    }
 
    /* Return the buffer to the caller and return status (should be success) */
    *Buffer = StringBuffer;
    return Status;
}

Referenced by PciPdoIrpQueryId().

PciQueryInterface()

NTSTATUS NTAPI PciQueryInterface	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN CONST GUID *	InterfaceType,
		IN ULONG	Size,
		IN ULONG	Version,
		IN PVOID	InterfaceData,
		IN PINTERFACE	Interface,
		IN BOOLEAN	LastChance
	)

Definition at line 45 of file intrface.c.

{
    UNICODE_STRING GuidString;
    NTSTATUS Status;
    PPCI_INTERFACE *InterfaceList;
    PPCI_INTERFACE PciInterface;
    RtlStringFromGUID(InterfaceType, &GuidString);
    DPRINT1("PCI - PciQueryInterface TYPE = %wZ\n", &GuidString);
    RtlFreeUnicodeString(&GuidString);
    DPRINT1("      Size = %u, Version = %u, InterfaceData = %p, LastChance = %s\n",
            Size,
            Version,
            InterfaceData,
            LastChance ? "TRUE" : "FALSE");
 
    /* Loop all the available interfaces */
    for (InterfaceList = LastChance ? PciInterfacesLastResort : PciInterfaces;
         *InterfaceList;
         InterfaceList++)
    {
        /* Get the current interface */
        PciInterface = *InterfaceList;
 
        /* For debugging, construct the GUID string */
        RtlStringFromGUID(PciInterface->InterfaceType, &GuidString);
 
        /* Check if this is an FDO or PDO */
        if (DeviceExtension->ExtensionType == PciFdoExtensionType)
        {
            /* Check if the interface is for FDOs */
            if (!(PciInterface->Flags & PCI_INTERFACE_FDO))
            {
                /* This interface is not for FDOs, skip it */
                DPRINT1("PCI - PciQueryInterface: guid = %wZ only for FDOs\n",
                        &GuidString);
                RtlFreeUnicodeString(&GuidString);
                continue;
            }
 
            /* Check if the interface is for root FDO only */
            if ((PciInterface->Flags & PCI_INTERFACE_ROOT) &&
                (!PCI_IS_ROOT_FDO(DeviceExtension)))
            {
                /* This FDO isn't the root, skip the interface */
                DPRINT1("PCI - PciQueryInterface: guid = %wZ only for ROOT\n",
                        &GuidString);
                RtlFreeUnicodeString(&GuidString);
                continue;
            }
        }
        else
        {
            /* This is a PDO, check if the interface is for PDOs too */
            if (!(PciInterface->Flags & PCI_INTERFACE_PDO))
            {
                /* It isn't, skip it */
                DPRINT1("PCI - PciQueryInterface: guid = %wZ only for PDOs\n",
                        &GuidString);
                RtlFreeUnicodeString(&GuidString);
                continue;
            }
        }
 
        /* Print the GUID for debugging, and then free the string */
        DPRINT1("PCI - PciQueryInterface looking at guid = %wZ\n", &GuidString);
        RtlFreeUnicodeString(&GuidString);
 
        /* Check if the GUID, version, and size all match */
        if ((IsEqualGUIDAligned(PciInterface->InterfaceType, InterfaceType)) &&
            (Version >= PciInterface->MinVersion) &&
            (Version <= PciInterface->MaxVersion) &&
            (Size >= PciInterface->MinSize))
        {
            /* Call the interface's constructor */
            Status = PciInterface->Constructor(DeviceExtension,
                                               PciInterface,
                                               InterfaceData,
                                               Version,
                                               Size,
                                               Interface);
            if (!NT_SUCCESS(Status))
            {
                /* This interface was not initialized correctly, skip it */
                DPRINT1("PCI - PciQueryInterface - Constructor %p = %08lx\n",
                        PciInterface->Constructor, Status);
                continue;
            }
 
            /* Reference the interface and return success, all is good */
            Interface->InterfaceReference(Interface->Context);
            DPRINT1("PCI - PciQueryInterface returning SUCCESS\n");
            return Status;
        }
    }
 
    /* An interface of this type, and for this device, could not be found */
    DPRINT1("PCI - PciQueryInterface FAILED TO FIND INTERFACE\n");
    return STATUS_NOT_SUPPORTED;
}

Referenced by PciFdoIrpQueryInterface().

PciQueryRequirements()

NTSTATUS NTAPI PciQueryRequirements	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *	RequirementsList
	)

Definition at line 583 of file enum.c.

{
    NTSTATUS Status;
    PCI_COMMON_HEADER PciHeader;
    PAGED_CODE();
 
    /* Check if the PDO has any resources, or at least an interrupt pin */
    if ((PdoExtension->Resources) || (PdoExtension->InterruptPin))
    {
        /* Read the current PCI header */
        PciReadDeviceConfig(PdoExtension, &PciHeader, 0, PCI_COMMON_HDR_LENGTH);
 
        /* Use it to build a list of requirements */
        Status = PciBuildRequirementsList(PdoExtension, &PciHeader, RequirementsList);
        if (!NT_SUCCESS(Status)) return Status;
 
        /* Is this a Compaq PCI Hotplug Controller (r17) on a PAE system ? */
        if ((PciHeader.VendorID == 0xE11) &&
            (PciHeader.DeviceID == 0xA0F7) &&
            (PciHeader.RevisionID == 17) &&
            (ExIsProcessorFeaturePresent(PF_PAE_ENABLED)))
        {
            /* Have not tested this on eVb's machine yet */
            UNIMPLEMENTED_DBGBREAK();
        }
 
        /* Check if the requirements are actually the zero list */
        if (*RequirementsList == PciZeroIoResourceRequirements)
        {
            /* A simple NULL will suffice for the PnP Manager */
            *RequirementsList = NULL;
            DPRINT1("Returning NULL requirements list\n");
        }
        else
        {
            /* Otherwise, print out the requirements list */
            PciDebugPrintIoResReqList(*RequirementsList);
        }
    }
    else
    {
        /* There aren't any resources, so simply return NULL */
        DPRINT1("PciQueryRequirements returning NULL requirements list\n");
        *RequirementsList = NULL;
    }
 
    /* This call always succeeds (but maybe with no requirements) */
    return STATUS_SUCCESS;
}

Referenced by PciPdoIrpQueryResourceRequirements().

PciQueryResources()

NTSTATUS NTAPI PciQueryResources	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		OUT PCM_RESOURCE_LIST *	Buffer
	)

Definition at line 354 of file enum.c.

{
    PPCI_FUNCTION_RESOURCES PciResources;
    BOOLEAN HaveVga, HaveMemSpace, HaveIoSpace;
    USHORT BridgeControl, PciCommand;
    ULONG Count, i;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Partial, Resource, LastResource;
    PCM_RESOURCE_LIST ResourceList;
    UCHAR InterruptLine;
    PAGED_CODE();
 
    /* Assume failure */
    Count = 0;
    HaveVga = FALSE;
    *Buffer = NULL;
 
    /* Make sure there's some resources to query */
    PciResources = PdoExtension->Resources;
    if (!PciResources) return STATUS_SUCCESS;
 
    /* Read the decodes */
    PciReadDeviceConfig(PdoExtension,
                        &PciCommand,
                        FIELD_OFFSET(PCI_COMMON_HEADER, Command),
                        sizeof(USHORT));
 
    /* Check which ones are turned on */
    HaveIoSpace = PciCommand & PCI_ENABLE_IO_SPACE;
    HaveMemSpace = PciCommand & PCI_ENABLE_MEMORY_SPACE;
 
    /* Loop maximum possible descriptors */
    for (i = 0; i < 7; i++)
    {
        /* Check if the decode for this descriptor is actually turned on */
        Partial = &PciResources->Current[i];
        if (((HaveMemSpace) && (Partial->Type == CmResourceTypeMemory)) ||
            ((HaveIoSpace) && (Partial->Type == CmResourceTypePort)))
        {
            /* One more fully active descriptor */
            Count++;
        }
    }
 
    /* If there's an interrupt pin associated, check at least one decode is on */
    if ((PdoExtension->InterruptPin) && ((HaveMemSpace) || (HaveIoSpace)))
    {
        /* Read the interrupt line for the pin, add a descriptor if it's valid */
        InterruptLine = PdoExtension->AdjustedInterruptLine;
        if ((InterruptLine) && (InterruptLine != -1)) Count++;
    }
 
    /* Check for PCI bridge */
    if (PdoExtension->HeaderType == PCI_BRIDGE_TYPE)
    {
        /* Read bridge settings, check if VGA is present */
        PciReadDeviceConfig(PdoExtension,
                            &BridgeControl,
                            FIELD_OFFSET(PCI_COMMON_HEADER, u.type1.BridgeControl),
                            sizeof(USHORT));
        if (BridgeControl & PCI_ENABLE_BRIDGE_VGA)
        {
            /* Remember for later */
            HaveVga = TRUE;
 
            /* One memory descriptor for 0xA0000, plus the two I/O port ranges */
            if (HaveMemSpace) Count++;
            if (HaveIoSpace) Count += 2;
        }
    }
 
    /* If there's no descriptors in use, there's no resources, so return */
    if (!Count) return STATUS_SUCCESS;
 
    /* Allocate a resource list to hold the resources */
    ResourceList = PciAllocateCmResourceList(Count,
                                             PdoExtension->ParentFdoExtension->BaseBus);
    if (!ResourceList) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* This is where the descriptors will be copied into */
    Resource = ResourceList->List[0].PartialResourceList.PartialDescriptors;
    LastResource = Resource + Count + 1;
 
    /* Loop maximum possible descriptors */
    for (i = 0; i < 7; i++)
    {
        /* Check if the decode for this descriptor is actually turned on */
        Partial = &PciResources->Current[i];
        if (((HaveMemSpace) && (Partial->Type == CmResourceTypeMemory)) ||
            ((HaveIoSpace) && (Partial->Type == CmResourceTypePort)))
        {
            /* Copy the descriptor into the resource list */
            *Resource++ = *Partial;
        }
    }
 
    /* Check if earlier the code detected this was a PCI bridge with VGA on it */
    if (HaveVga)
    {
        /* Are the memory decodes enabled? */
        if (HaveMemSpace)
        {
            /* Build a memory descriptor for a 128KB framebuffer at 0xA0000 */
            Resource->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
            Resource->u.Generic.Start.HighPart = 0;
            Resource->Type = CmResourceTypeMemory;
            Resource->u.Generic.Start.LowPart = 0xA0000;
            Resource->u.Generic.Length = 0x20000;
            Resource++;
        }
 
        /* Are the I/O decodes enabled? */
        if (HaveIoSpace)
        {
            /* Build an I/O descriptor for the graphic ports at 0x3B0 */
            Resource->Type = CmResourceTypePort;
            Resource->Flags = CM_RESOURCE_PORT_POSITIVE_DECODE | CM_RESOURCE_PORT_10_BIT_DECODE;
            Resource->u.Port.Start.QuadPart = 0x3B0u;
            Resource->u.Port.Length = 0xC;
            Resource++;
 
            /* Build an I/O descriptor for the graphic ports at 0x3C0 */
            Resource->Type = CmResourceTypePort;
            Resource->Flags = CM_RESOURCE_PORT_POSITIVE_DECODE | CM_RESOURCE_PORT_10_BIT_DECODE;
            Resource->u.Port.Start.QuadPart = 0x3C0u;
            Resource->u.Port.Length = 0x20;
            Resource++;
        }
    }
 
    /* If there's an interrupt pin associated, check at least one decode is on */
    if ((PdoExtension->InterruptPin) && ((HaveMemSpace) || (HaveIoSpace)))
    {
         /* Read the interrupt line for the pin, check if it's valid */
         InterruptLine = PdoExtension->AdjustedInterruptLine;
         if ((InterruptLine) && (InterruptLine != -1))
         {
             /* Make sure there's still space */
             ASSERT(Resource < LastResource);
 
             /* Add the interrupt descriptor */
             Resource->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
             Resource->Type = CmResourceTypeInterrupt;
             Resource->ShareDisposition = CmResourceShareShared;
             Resource->u.Interrupt.Affinity = -1;
             Resource->u.Interrupt.Level = InterruptLine;
             Resource->u.Interrupt.Vector = InterruptLine;
        }
    }
 
    /* Return the resource list */
    *Buffer = ResourceList;
    return STATUS_SUCCESS;
}

Referenced by PciPdoIrpQueryResources().

PciQueryTargetDeviceRelations()

NTSTATUS NTAPI PciQueryTargetDeviceRelations	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN OUT PDEVICE_RELATIONS *	pDeviceRelations
	)

Definition at line 511 of file enum.c.

{
    PDEVICE_RELATIONS DeviceRelations;
    PAGED_CODE();
 
    /* If there were existing relations, free them */
    if (*pDeviceRelations) ExFreePoolWithTag(*pDeviceRelations, 0);
 
    /* Allocate a new structure for the relations */
    DeviceRelations = ExAllocatePoolWithTag(NonPagedPool,
                                            sizeof(DEVICE_RELATIONS),
                                            'BicP');
    if (!DeviceRelations) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Only one relation: the PDO */
    DeviceRelations->Count = 1;
    DeviceRelations->Objects[0] = PdoExtension->PhysicalDeviceObject;
    ObReferenceObject(DeviceRelations->Objects[0]);
 
    /* Return the new relations */
    *pDeviceRelations = DeviceRelations;
    return STATUS_SUCCESS;
}

Referenced by PciPdoIrpQueryDeviceRelations().

PciReadDeviceCapability()

UCHAR NTAPI PciReadDeviceCapability	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN UCHAR	Offset,
		IN ULONG	CapabilityId,
		OUT PPCI_CAPABILITIES_HEADER	Buffer,
		IN ULONG	Length
	)

Definition at line 886 of file utils.c.

{
    ULONG CapabilityCount = 0;
 
    /* If the device has no capabilility list, fail */
    if (!Offset) return 0;
 
    /* Validate a PDO with capabilities, a valid buffer, and a valid length */
    ASSERT(DeviceExtension->ExtensionType == PciPdoExtensionType);
    ASSERT(DeviceExtension->CapabilitiesPtr != 0);
    ASSERT(Buffer);
    ASSERT(Length >= sizeof(PCI_CAPABILITIES_HEADER));
 
    /* Loop all capabilities */
    while (Offset)
    {
        /* Make sure the pointer is spec-aligned and spec-sized */
        ASSERT((Offset >= PCI_COMMON_HDR_LENGTH) && ((Offset & 0x3) == 0));
 
        /* Read the capability header */
        PciReadDeviceConfig(DeviceExtension,
                            Buffer,
                            Offset,
                            sizeof(PCI_CAPABILITIES_HEADER));
 
        /* Check if this is the capability being looked up */
        if ((Buffer->CapabilityID == CapabilityId) || !(CapabilityId))
        {
            /* Check if was at a valid offset and length */
            if ((Offset) && (Length > sizeof(PCI_CAPABILITIES_HEADER)))
            {
                /* Sanity check */
                ASSERT(Length <= (sizeof(PCI_COMMON_CONFIG) - Offset));
 
                /* Now read the whole capability data into the buffer */
                PciReadDeviceConfig(DeviceExtension,
                                    (PVOID)((ULONG_PTR)Buffer +
                                    sizeof(PCI_CAPABILITIES_HEADER)),
                                    Offset + sizeof(PCI_CAPABILITIES_HEADER),
                                    Length - sizeof(PCI_CAPABILITIES_HEADER));
            }
 
            /* Return the offset where the capability was found */
            return Offset;
        }
 
        /* Try the next capability instead */
        CapabilityCount++;
        Offset = Buffer->Next;
 
        /* There can't be more than 48 capabilities (256 bytes max) */
        if (CapabilityCount > 48)
        {
            /* Fail, since this is basically a broken PCI device */
            DPRINT1("PCI device %p capabilities list is broken.\n", DeviceExtension);
            return 0;
        }
    }
 
    /* Capability wasn't found, fail */
    return 0;
}

Referenced by PciGetEnhancedCapabilities(), PciScanBus(), and PciSetPowerManagedDevicePowerState().

PciReadDeviceConfig()

VOID NTAPI PciReadDeviceConfig	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 107 of file config.c.

{
    /* Call the generic worker function */
    PciReadWriteConfigSpace(DeviceExtension->ParentFdoExtension,
                            DeviceExtension->Slot,
                            Buffer,
                            Offset,
                            Length,
                            TRUE);
}

Referenced by PciApplyHacks(), PciAssignSlotResources(), PciConfigureIdeController(), PciDecodeEnable(), PcipGetFunctionLimits(), PciQueryRequirements(), PciQueryResources(), PciReadDeviceCapability(), PciScanBus(), PciSetResources(), PciStallForPowerChange(), and PciWriteLimitsAndRestoreCurrent().

PciReadSlotConfig()

VOID NTAPI PciReadSlotConfig	(	IN PPCI_FDO_EXTENSION	DeviceExtension,
		IN PCI_SLOT_NUMBER	Slot,
		IN PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 123 of file config.c.

{
    /* Call the generic worker function */
    PciReadWriteConfigSpace(DeviceExtension, Slot, Buffer, Offset, Length, TRUE);
}

Referenced by PciScanBus().

PciSaveBiosConfig()

NTSTATUS NTAPI PciSaveBiosConfig	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		OUT PPCI_COMMON_HEADER	PciData
	)

Referenced by PciScanBus().

PciSendIoctl()

NTSTATUS NTAPI PciSendIoctl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	IoControlCode,
		IN PVOID	InputBuffer,
		IN ULONG	InputBufferLength,
		IN PVOID	OutputBuffer,
		IN ULONG	OutputBufferLength
	)

Definition at line 531 of file utils.c.

{
    PIRP Irp;
    NTSTATUS Status;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PDEVICE_OBJECT AttachedDevice;
    PAGED_CODE();
 
    /* Initialize the pending IRP event */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
    /* Get a reference to the root PDO (ACPI) */
    AttachedDevice = IoGetAttachedDeviceReference(DeviceObject);
    if (!AttachedDevice) return STATUS_INVALID_PARAMETER;
 
    /* Build the requested IOCTL IRP */
    Irp = IoBuildDeviceIoControlRequest(IoControlCode,
                                        AttachedDevice,
                                        InputBuffer,
                                        InputBufferLength,
                                        OutputBuffer,
                                        OutputBufferLength,
                                        0,
                                        &Event,
                                        &IoStatusBlock);
    if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Send the IOCTL to the driver */
    Status = IoCallDriver(AttachedDevice, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for a response */
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = Irp->IoStatus.Status;
    }
 
    /* Take away the reference we took and return the result to the caller */
    ObDereferenceObject(AttachedDevice);
    return Status;
}

Referenced by PciGetHotPlugParameters(), and PciIsSlotPresentInParentMethod().

PciSetPowerManagedDevicePowerState()

NTSTATUS NTAPI PciSetPowerManagedDevicePowerState	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN DEVICE_POWER_STATE	DeviceState,
		IN BOOLEAN	IrpSet
	)

Definition at line 121 of file power.c.

{
    NTSTATUS Status;
    PCI_PM_CAPABILITY PmCaps;
    ULONG CapsOffset;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Check if this device can support low power states */
    if (!(PciCanDisableDecodes(DeviceExtension, NULL, 0, TRUE)) &&
         (DeviceState != PowerDeviceD0))
    {
        /* Simply return success, ignoring this request */
        DPRINT1("Cannot disable decodes on this device, ignoring PM request...\n");
        return Status;
    }
 
    /* Does the device support power management at all? */
    if (!(DeviceExtension->HackFlags & PCI_HACK_NO_PM_CAPS))
    {
        /* Get the PM capabilities register */
        CapsOffset = PciReadDeviceCapability(DeviceExtension,
                                             DeviceExtension->CapabilitiesPtr,
                                             PCI_CAPABILITY_ID_POWER_MANAGEMENT,
                                             &PmCaps.Header,
                                             sizeof(PCI_PM_CAPABILITY));
        ASSERT(CapsOffset);
        ASSERT(DeviceState != PowerDeviceUnspecified);
 
        /* Check if the device is being powered up */
        if (DeviceState == PowerDeviceD0)
        {
            /* Set full power state */
            PmCaps.PMCSR.ControlStatus.PowerState = 0;
 
            /* Check if the device supports Cold-D3 poweroff */
            if (PmCaps.PMC.Capabilities.Support.PMED3Cold)
            {
                /* If there was a pending PME, clear it */
                PmCaps.PMCSR.ControlStatus.PMEStatus = 1;
            }
        }
        else
        {
            /* Otherwise, just set the new power state, converting from NT */
            PmCaps.PMCSR.ControlStatus.PowerState = DeviceState - 1;
        }
 
        /* Write the new power state in the PMCSR */
        PciWriteDeviceConfig(DeviceExtension,
                             &PmCaps.PMCSR,
                             CapsOffset + FIELD_OFFSET(PCI_PM_CAPABILITY, PMCSR),
                             sizeof(PCI_PMCSR));
 
        /* Now wait for the change to "stick" based on the spec-mandated time */
        Status = PciStallForPowerChange(DeviceExtension, DeviceState, CapsOffset);
        if (!NT_SUCCESS(Status)) return Status;
    }
    else
    {
        /* Nothing to do! */
        DPRINT1("No PM on this device, ignoring request\n");
    }
 
    /* Check if new resources have to be assigned */
    if (IrpSet)
    {
        /* Check if the new device state is lower (higher power) than now */
        if (DeviceState < DeviceExtension->PowerState.CurrentDeviceState)
        {
            /* We would normally re-assign resources after powerup */
            UNIMPLEMENTED_DBGBREAK();
            Status = STATUS_NOT_IMPLEMENTED;
        }
    }
 
    /* Return the power state change status */
    return Status;
}

Referenced by PciPdoIrpStartDevice(), and PciScanBus().

PciSetResources()

NTSTATUS NTAPI PciSetResources	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN BOOLEAN	DoReset,
		IN BOOLEAN	SomethingSomethingDarkSide
	)

Definition at line 2155 of file enum.c.

{
    PPCI_FDO_EXTENSION FdoExtension;
    UCHAR NewCacheLineSize, NewLatencyTimer;
    PCI_COMMON_HEADER PciData;
    BOOLEAN Native;
    PPCI_CONFIGURATOR Configurator;
 
    UNREFERENCED_PARAMETER(SomethingSomethingDarkSide);
 
    /* Get the FDO and read the configuration data */
    FdoExtension = PdoExtension->ParentFdoExtension;
    PciReadDeviceConfig(PdoExtension, &PciData, 0, PCI_COMMON_HDR_LENGTH);
 
    /* Make sure this is still the same device */
    if (!PcipIsSameDevice(PdoExtension, &PciData))
    {
        /* Fail */
        ASSERTMSG("PCI Set resources - not same device.\n", FALSE);
        return STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    /* Nothing to set for a host bridge */
    if ((PdoExtension->BaseClass == PCI_CLASS_BRIDGE_DEV) &&
        (PdoExtension->SubClass == PCI_SUBCLASS_BR_HOST))
    {
        /* Fake success */
        return STATUS_SUCCESS;
    }
 
    /* Check if an IDE controller is being reset */
    if ((DoReset) &&
        (PdoExtension->BaseClass == PCI_CLASS_MASS_STORAGE_CTLR) &&
        (PdoExtension->SubClass == PCI_SUBCLASS_MSC_IDE_CTLR))
    {
        /* Turn off native mode */
        Native = PciConfigureIdeController(PdoExtension, &PciData, FALSE);
        ASSERT(Native == PdoExtension->IDEInNativeMode);
    }
 
    /* Check for update of a hotplug device, or first configuration of one */
    if ((PdoExtension->NeedsHotPlugConfiguration) &&
        (FdoExtension->HotPlugParameters.Acquired))
    {
        /* Don't have hotplug devices to test with yet, QEMU 0.14 should */
        UNIMPLEMENTED_DBGBREAK();
    }
 
    /* Locate the correct resource configurator for this type of device */
    Configurator = &PciConfigurators[PdoExtension->HeaderType];
 
    /* Apply the settings change */
    Configurator->ChangeResourceSettings(PdoExtension, &PciData);
 
    /* Assume no update needed */
    PdoExtension->UpdateHardware = FALSE;
 
    /* Check if a reset is needed */
    if (DoReset)
    {
        /* Reset resources */
        Configurator->ResetDevice(PdoExtension, &PciData);
        PciData.u.type0.InterruptLine = PdoExtension->RawInterruptLine;
    }
 
    /* Check if the latency timer changed */
    NewLatencyTimer = PdoExtension->SavedLatencyTimer;
    if (PciData.LatencyTimer != NewLatencyTimer)
    {
        /* Debug notification */
        DPRINT1("PCI (pdox %p) changing latency from %02x to %02x.\n",
                PdoExtension,
                PciData.LatencyTimer,
                NewLatencyTimer);
    }
 
    /* Check if the cache line changed */
    NewCacheLineSize = PdoExtension->SavedCacheLineSize;
    if (PciData.CacheLineSize != NewCacheLineSize)
    {
        /* Debug notification */
        DPRINT1("PCI (pdox %p) changing cache line size from %02x to %02x.\n",
                PdoExtension,
                PciData.CacheLineSize,
                NewCacheLineSize);
    }
 
    /* Inherit data from PDO extension */
    PciData.LatencyTimer = PdoExtension->SavedLatencyTimer;
    PciData.CacheLineSize = PdoExtension->SavedCacheLineSize;
    PciData.u.type0.InterruptLine = PdoExtension->RawInterruptLine;
 
    /* Apply any resource hacks required */
    PciApplyHacks(FdoExtension,
                  &PciData,
                  PdoExtension->Slot,
                  PCI_HACK_FIXUP_BEFORE_UPDATE,
                  PdoExtension);
 
    /* Check if I/O space was disabled by administrator or driver */
    if (PdoExtension->IoSpaceNotRequired)
    {
        /* Don't turn on the decode */
        PdoExtension->CommandEnables &= ~PCI_ENABLE_IO_SPACE;
    }
 
    /* Update the device with the new settings */
    PciUpdateHardware(PdoExtension, &PciData);
 
    /* Update complete */
    PdoExtension->RawInterruptLine = PciData.u.type0.InterruptLine;
    PdoExtension->NeedsHotPlugConfiguration = FALSE;
    return STATUS_SUCCESS;
}

Referenced by PciAssignSlotResources(), and PciPdoIrpStartDevice().

PciStringToUSHORT()

BOOLEAN NTAPI PciStringToUSHORT	(	IN PWCHAR	String,
		OUT PUSHORT	Value
	)

Definition at line 61 of file utils.c.

{
    USHORT Short;
    ULONG Low, High, Length;
    WCHAR Char;
 
    /* Initialize everything to zero */
    Short = 0;
    Length = 0;
    while (TRUE)
    {
        /* Get the character and set the high byte based on the previous one */
        Char = *String++;
        High = 16 * Short;
 
        /* Check for numbers */
        if ( Char >= '0' && Char <= '9' )
        {
            /* Convert them to a byte */
            Low = Char - '0';
        }
        else if ( Char >= 'A' && Char <= 'F' )
        {
            /* Convert upper-case hex letters into a byte */
            Low = Char - '7';
        }
        else if ( Char >= 'a' && Char <= 'f' )
        {
            /* Convert lower-case hex letters into a byte */
            Low = Char - 'W';
        }
        else
        {
            /* Invalid string, fail the conversion */
            return FALSE;
        }
 
        /* Combine the high and low byte */
        Short = High | Low;
 
        /* If 4 letters have been reached, the 16-bit integer should exist */
        if (++Length >= 4)
        {
            /* Return it to the caller */
            *Value = Short;
            return TRUE;
        }
    }
}

Referenced by PciBuildHackTable().

PciUnicodeStringStrStr()

BOOLEAN NTAPI PciUnicodeStringStrStr	(	IN PUNICODE_STRING	InputString,
		IN PCUNICODE_STRING	EqualString,
		IN BOOLEAN	CaseInSensitive
	)

Definition at line 27 of file utils.c.

{
    UNICODE_STRING PartialString;
    LONG EqualChars, TotalChars;
 
    /* Build a partial string with the smaller substring */
    PartialString.Length = EqualString->Length;
    PartialString.MaximumLength = InputString->MaximumLength;
    PartialString.Buffer = InputString->Buffer;
 
    /* Check how many characters that need comparing */
    EqualChars = 0;
    TotalChars = (InputString->Length - EqualString->Length) / sizeof(WCHAR);
 
    /* If the substring is bigger, just fail immediately */
    if (TotalChars < 0) return FALSE;
 
    /* Keep checking each character */
    while (!RtlEqualUnicodeString(EqualString, &PartialString, CaseInSensitive))
    {
        /* Continue checking until all the required characters are equal */
        PartialString.Buffer++;
        PartialString.MaximumLength -= sizeof(WCHAR);
        if (++EqualChars > TotalChars) return FALSE;
    }
 
    /* The string is equal */
    return TRUE;
}

Referenced by DriverEntry().

PciVerifierInit()

VOID NTAPI PciVerifierInit

(

IN PDRIVER_OBJECT

DriverObject

)

Definition at line 94 of file pcivrify.c.

{
    NTSTATUS Status;
 
    /* Check if the kernel driver verifier is enabled */
    if (VfIsVerificationEnabled(VFOBJTYPE_SYSTEM_BIOS, NULL))
    {
        /* Register a notification for changes, to keep track of the PCI tree */
        Status = IoRegisterPlugPlayNotification(EventCategoryHardwareProfileChange,
                                                0,
                                                NULL,
                                                DriverObject,
                                                PciVerifierProfileChangeCallback,
                                                NULL,
                                                &PciVerifierNotificationHandle);
        if (NT_SUCCESS(Status)) PciVerifierRegistered = TRUE;
    }
}

Referenced by DriverEntry().

PciVerifierRetrieveFailureData()

PPCI_VERIFIER_DATA NTAPI PciVerifierRetrieveFailureData

(

IN ULONG

FailureCode

)

Definition at line 60 of file pcivrify.c.

{
    PPCI_VERIFIER_DATA VerifierData;
 
    /* Scan the verifier failure table for this code */
    VerifierData = PciVerifierFailureTable;
    while (VerifierData->FailureCode != FailureCode)
    {
        /* Keep searching */
        ++VerifierData;
        ASSERT(VerifierData < &PciVerifierFailureTable[PCI_VERIFIER_CODES]);
    }
 
    /* Return the entry for this code */
    return VerifierData;
}

Referenced by PciStallForPowerChange().

PciWriteDeviceConfig()

VOID NTAPI PciWriteDeviceConfig	(	IN PPCI_PDO_EXTENSION	DeviceExtension,
		IN PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 91 of file config.c.

{
    /* Call the generic worker function */
    PciReadWriteConfigSpace(DeviceExtension->ParentFdoExtension,
                            DeviceExtension->Slot,
                            Buffer,
                            Offset,
                            Length,
                            FALSE);
}

Referenced by PciApplyHacks(), PciConfigureIdeController(), PciDecodeEnable(), PcipUpdateHardware(), PciScanBus(), PciSetPowerManagedDevicePowerState(), and PciWriteLimitsAndRestoreCurrent().

PPBridge_ChangeResourceSettings()

VOID NTAPI PPBridge_ChangeResourceSettings	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 683 of file ppbridge.c.

{
    //BOOLEAN IoActive;
    PPCI_FDO_EXTENSION FdoExtension;
    PPCI_FUNCTION_RESOURCES PciResources;
    ULONG i;
 
    /* Check if I/O Decodes are enabled */
    //IoActive = (PciData->u.type1.IOBase & 0xF) == 1;
 
    /*
     * Check for Intel ICH PCI-to-PCI (i82801) bridges (used on the i810,
     * i820, i840, i845 Chipsets) that don't have subtractive decode broken.
     * If they do have broken subtractive support, or if they are not ICH bridges,
     * then check if the bridge supports subtractive decode at all.
     */
    if ((((PdoExtension->VendorId == 0x8086) &&
         ((PdoExtension->DeviceId == 0x2418) ||
          (PdoExtension->DeviceId == 0x2428) ||
          (PdoExtension->DeviceId == 0x244E) ||
          (PdoExtension->DeviceId == 0x2448))) &&
         (!(PdoExtension->HackFlags & PCI_HACK_BROKEN_SUBTRACTIVE_DECODE) ||
         (PdoExtension->Dependent.type1.SubtractiveDecode == FALSE))) ||
        (PdoExtension->Dependent.type1.SubtractiveDecode == FALSE))
    {
        /* No resources are needed on a subtractive decode bridge */
        PciData->u.type1.MemoryBase = 0xFFFF;
        PciData->u.type1.PrefetchBase = 0xFFFF;
        PciData->u.type1.IOBase = 0xFF;
        PciData->u.type1.IOLimit = 0;
        PciData->u.type1.MemoryLimit = 0;
        PciData->u.type1.PrefetchLimit = 0;
        PciData->u.type1.PrefetchBaseUpper32 = 0;
        PciData->u.type1.PrefetchLimitUpper32 = 0;
        PciData->u.type1.IOBaseUpper16 = 0;
        PciData->u.type1.IOLimitUpper16 = 0;
    }
    else
    {
        /*
         * Otherwise, get the FDO to read the old PCI configuration header that
         * had been saved by the hack in PPBridge_SaveCurrentSettings.
         */
        FdoExtension = PdoExtension->ParentFdoExtension;
        ASSERT(PdoExtension->Resources == NULL);
 
        /* Read the PCI header data and use that here */
        PciData->u.type1.IOBase = FdoExtension->PreservedConfig->u.type1.IOBase;
        PciData->u.type1.IOLimit = FdoExtension->PreservedConfig->u.type1.IOLimit;
        PciData->u.type1.MemoryBase = FdoExtension->PreservedConfig->u.type1.MemoryBase;
        PciData->u.type1.MemoryLimit = FdoExtension->PreservedConfig->u.type1.MemoryLimit;
        PciData->u.type1.PrefetchBase = FdoExtension->PreservedConfig->u.type1.PrefetchBase;
        PciData->u.type1.PrefetchLimit = FdoExtension->PreservedConfig->u.type1.PrefetchLimit;
        PciData->u.type1.PrefetchBaseUpper32 = FdoExtension->PreservedConfig->u.type1.PrefetchBaseUpper32;
        PciData->u.type1.PrefetchLimitUpper32 = FdoExtension->PreservedConfig->u.type1.PrefetchLimitUpper32;
        PciData->u.type1.IOBaseUpper16 = FdoExtension->PreservedConfig->u.type1.IOBaseUpper16;
        PciData->u.type1.IOLimitUpper16 = FdoExtension->PreservedConfig->u.type1.IOLimitUpper16;
    }
 
    /* Loop bus resources */
    PciResources = PdoExtension->Resources;
    if (PciResources)
    {
        /* Loop each resource type (the BARs, ROM BAR and Prefetch) */
        for (i = 0; i < 6; i++)
        {
            UNIMPLEMENTED;
        }
    }
 
    /* Copy the bus number data */
    PciData->u.type1.PrimaryBus = PdoExtension->Dependent.type1.PrimaryBus;
    PciData->u.type1.SecondaryBus = PdoExtension->Dependent.type1.SecondaryBus;
    PciData->u.type1.SubordinateBus = PdoExtension->Dependent.type1.SubordinateBus;
 
    /* Copy the decode flags */
    if (PdoExtension->Dependent.type1.IsaBitSet)
    {
        PciData->u.type1.BridgeControl |= PCI_ENABLE_BRIDGE_ISA;
    }
 
    if (PdoExtension->Dependent.type1.VgaBitSet)
    {
        PciData->u.type1.BridgeControl |= PCI_ENABLE_BRIDGE_VGA;
    }
}

PPBridge_GetAdditionalResourceDescriptors()

VOID NTAPI PPBridge_GetAdditionalResourceDescriptors	(	IN PPCI_CONFIGURATOR_CONTEXT	Context,
		IN PPCI_COMMON_HEADER	PciData,
		IN PIO_RESOURCE_DESCRIPTOR	IoDescriptor
	)

Definition at line 628 of file ppbridge.c.

{
 
    UNREFERENCED_PARAMETER(Context);
 
    /* Does this bridge have VGA decodes on it? */
    if (PciData->u.type1.BridgeControl & PCI_ENABLE_BRIDGE_VGA)
    {
        /* Build a private descriptor with 3 entries */
        IoDescriptor->Type = CmResourceTypeDevicePrivate;
        IoDescriptor->u.DevicePrivate.Data[0] = 3;
        IoDescriptor->u.DevicePrivate.Data[1] = 3;
 
        /* First, the VGA range at 0xA0000 */
        IoDescriptor[1].Type = CmResourceTypeMemory;
        IoDescriptor[1].Flags = CM_RESOURCE_MEMORY_READ_WRITE;
        IoDescriptor[1].u.Port.Length = 0x20000;
        IoDescriptor[1].u.Port.Alignment = 1;
        IoDescriptor[1].u.Port.MinimumAddress.QuadPart = 0xA0000;
        IoDescriptor[1].u.Port.MaximumAddress.QuadPart = 0xBFFFF;
 
        /* Then, the VGA registers at 0x3B0 */
        IoDescriptor[2].Type = CmResourceTypePort;
        IoDescriptor[2].Flags = CM_RESOURCE_PORT_POSITIVE_DECODE |
                                CM_RESOURCE_PORT_10_BIT_DECODE;
        IoDescriptor[2].u.Port.Length = 12;
        IoDescriptor[2].u.Port.Alignment = 1;
        IoDescriptor[2].u.Port.MinimumAddress.QuadPart = 0x3B0;
        IoDescriptor[2].u.Port.MaximumAddress.QuadPart = 0x3BB;
 
        /* And finally the VGA registers at 0x3C0 */
        IoDescriptor[3].Type = CmResourceTypePort;
        IoDescriptor[3].Flags = CM_RESOURCE_PORT_POSITIVE_DECODE |
                                CM_RESOURCE_PORT_10_BIT_DECODE;
        IoDescriptor[3].u.Port.Length = 32;
        IoDescriptor[3].u.Port.Alignment = 1;
        IoDescriptor[3].u.Port.MinimumAddress.QuadPart = 0x3C0;
        IoDescriptor[3].u.Port.MaximumAddress.QuadPart = 0x3DF;
    }
}

PPBridge_MassageHeaderForLimitsDetermination()

VOID NTAPI PPBridge_MassageHeaderForLimitsDetermination

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 582 of file ppbridge.c.

{
    PPCI_COMMON_HEADER PciData, Current;
 
    /* Get pointers from context */
    PciData = Context->PciData;
    Current = Context->Current;
 
    /*
     * Write FFh everywhere so that the PCI bridge ignores what it can't handle.
     * Based on the bits that were ignored (still 0), this is how we can tell
     * what the limit is.
     */
    RtlFillMemory(PciData->u.type1.BaseAddresses,
                  FIELD_OFFSET(PCI_COMMON_HEADER, u.type1.CapabilitiesPtr) -
                  FIELD_OFFSET(PCI_COMMON_HEADER, u.type1.BaseAddresses),
                  0xFF);
 
    /* Copy the saved settings from the current context into the PCI header */
    PciData->u.type1.PrimaryBus = Current->u.type1.PrimaryBus;
    PciData->u.type1.SecondaryBus = Current->u.type1.SecondaryBus;
    PciData->u.type1.SubordinateBus = Current->u.type1.SubordinateBus;
    PciData->u.type1.SecondaryLatency = Current->u.type1.SecondaryLatency;
 
    /* No I/O limit or base. The bottom base bit specifies that FIXME */
    PciData->u.type1.IOBaseUpper16 = 0xFFFE;
    PciData->u.type1.IOLimitUpper16 = 0xFFFF;
 
    /* Save secondary status before it gets cleared */
    Context->SecondaryStatus = Current->u.type1.SecondaryStatus;
 
    /* Clear secondary status */
    Current->u.type1.SecondaryStatus = 0;
    PciData->u.type1.SecondaryStatus = 0;
}

PPBridge_ResetDevice()

VOID NTAPI PPBridge_ResetDevice	(	IN PPCI_PDO_EXTENSION	PdoExtension,
		IN PPCI_COMMON_HEADER	PciData
	)

Definition at line 673 of file ppbridge.c.

{
    UNREFERENCED_PARAMETER(PdoExtension);
    UNREFERENCED_PARAMETER(PciData);
    UNIMPLEMENTED_DBGBREAK();
}

PPBridge_RestoreCurrent()

VOID NTAPI PPBridge_RestoreCurrent

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 620 of file ppbridge.c.

{
    /* Copy back the secondary status register */
    Context->Current->u.type1.SecondaryStatus = Context->SecondaryStatus;
}

PPBridge_SaveCurrentSettings()

VOID NTAPI PPBridge_SaveCurrentSettings

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 225 of file ppbridge.c.

{
    NTSTATUS Status;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor;
    PIO_RESOURCE_DESCRIPTOR IoDescriptor;
    PPCI_FUNCTION_RESOURCES Resources;
    PCI_COMMON_HEADER BiosData;
    PPCI_COMMON_HEADER Current;
    PPCI_COMMON_CONFIG SavedConfig;
    ULONG i, Bar, BarMask;
    PULONG BarArray;
    PHYSICAL_ADDRESS Limit, Base, Length;
    BOOLEAN HaveIoLimit, CheckAlignment;
    PPCI_PDO_EXTENSION PdoExtension;
 
    /* Get the pointers from the extension */
    PdoExtension = Context->PdoExtension;
    Resources = PdoExtension->Resources;
    Current = Context->Current;
 
    /* Check if decodes are disabled */
    if (!(Context->Command & (PCI_ENABLE_IO_SPACE | PCI_ENABLE_MEMORY_SPACE)))
    {
        /* Well, we're going to need them from somewhere, use the registry data */
        Status = PciGetBiosConfig(PdoExtension, &BiosData);
        if (NT_SUCCESS(Status)) Current = &BiosData;
    }
 
    /* Scan all current and limit descriptors for each BAR needed */
    BarArray = Current->u.type1.BaseAddresses;
    for (i = 0; i < 6; i++)
    {
        /* Get the current resource descriptor, and the limit requirement */
        CmDescriptor = &Resources->Current[i];
        IoDescriptor = &Resources->Limit[i];
 
        /* Copy descriptor data, skipping null descriptors */
        CmDescriptor->Type = IoDescriptor->Type;
        if (CmDescriptor->Type == CmResourceTypeNull) continue;
        CmDescriptor->Flags = IoDescriptor->Flags;
        CmDescriptor->ShareDisposition = IoDescriptor->ShareDisposition;
 
        /* Initialize the high-parts to zero, since most stuff is 32-bit only */
        Base.QuadPart = Limit.QuadPart = Length.QuadPart = 0;
 
        /* Check if we're handling PCI BARs, or the ROM BAR */
        if ((i < PCI_TYPE1_ADDRESSES) || (i == 5))
        {
            /* Is this the ROM BAR? */
            if (i == 5)
            {
                /* Read the correct bar, with the appropriate mask */
                Bar = Current->u.type1.ROMBaseAddress;
                BarMask = PCI_ADDRESS_ROM_ADDRESS_MASK;
 
                /* Decode the base address, and write down the length */
                Base.LowPart = Bar & BarMask;
                DPRINT1("ROM BAR Base: %lx\n", Base.LowPart);
                CmDescriptor->u.Memory.Length = IoDescriptor->u.Memory.Length;
            }
            else
            {
                /* Otherwise, get the BAR from the array */
                Bar = BarArray[i];
 
                /* Is this an I/O BAR? */
                if (Bar & PCI_ADDRESS_IO_SPACE)
                {
                    /* Set the correct mask */
                    ASSERT(CmDescriptor->Type == CmResourceTypePort);
                    BarMask = PCI_ADDRESS_IO_ADDRESS_MASK;
                }
                else
                {
                    /* This is a memory BAR, set the correct base */
                    ASSERT(CmDescriptor->Type == CmResourceTypeMemory);
                    BarMask = PCI_ADDRESS_MEMORY_ADDRESS_MASK;
 
                    /* IS this a 64-bit BAR? */
                    if ((Bar & PCI_ADDRESS_MEMORY_TYPE_MASK) == PCI_TYPE_64BIT)
                    {
                        /* Read the next 32-bits as well, ie, the next BAR */
                        Base.HighPart = BarArray[i + 1];
                    }
                }
 
                /* Decode the base address, and write down the length */
                Base.LowPart = Bar & BarMask;
                DPRINT1("BAR Base: %lx\n", Base.LowPart);
                CmDescriptor->u.Generic.Length = IoDescriptor->u.Generic.Length;
            }
        }
        else
        {
            /* Reset loop conditions */
            HaveIoLimit = FALSE;
            CheckAlignment = FALSE;
 
            /* Check which descriptor is being parsed */
            if (i == 2)
            {
                /* I/O Port Requirements */
                Base.LowPart = PciBridgeIoBase(Current);
                Limit.LowPart = PciBridgeIoLimit(Current);
                DPRINT1("Bridge I/O Base and Limit: %lx %lx\n",
                         Base.LowPart, Limit.LowPart);
 
                /* Do we have any I/O Port data? */
                if (!(Base.LowPart) && (Current->u.type1.IOLimit))
                {
                    /* There's a limit */
                    HaveIoLimit = TRUE;
                }
            }
            else if (i == 3)
            {
                /* Memory requirements */
                Base.LowPart = PciBridgeMemoryBase(Current);
                Limit.LowPart = PciBridgeMemoryLimit(Current);
 
                /* These should always be there, so check their alignment */
                DPRINT1("Bridge MEM Base and Limit: %lx %lx\n",
                         Base.LowPart, Limit.LowPart);
                CheckAlignment = TRUE;
            }
            else if (i == 4)
            {
                /* This should only be present for prefetch memory */
                ASSERT(CmDescriptor->Flags & CM_RESOURCE_MEMORY_PREFETCHABLE);
                Base = PciBridgePrefetchMemoryBase(Current);
                Limit = PciBridgePrefetchMemoryLimit(Current);
 
                /* If it's there, check the alignment */
                DPRINT1("Bridge Prefetch MEM Base and Limit: %I64x %I64x\n", Base, Limit);
                CheckAlignment = TRUE;
            }
 
            /* Check for invalid base address */
            if (Base.QuadPart >= Limit.QuadPart)
            {
                /* Assume the descriptor is bogus */
                CmDescriptor->Type = CmResourceTypeNull;
                IoDescriptor->Type = CmResourceTypeNull;
                continue;
            }
 
            /* Check if there's no memory, and no I/O port either */
            if (!(Base.LowPart) && !(HaveIoLimit))
            {
                /* This seems like a bogus requirement, ignore it */
                CmDescriptor->Type = CmResourceTypeNull;
                continue;
            }
 
            /* Set the length to be the limit - the base; should always be 32-bit */
            Length.QuadPart = Limit.LowPart - Base.LowPart + 1;
            ASSERT(Length.HighPart == 0);
            CmDescriptor->u.Generic.Length = Length.LowPart;
 
            /* Check if alignment should be set */
            if (CheckAlignment)
            {
                /* Compute the required alignment for this length */
                ASSERT(CmDescriptor->u.Memory.Length > 0);
                IoDescriptor->u.Memory.Alignment =
                    PciBridgeMemoryWorstCaseAlignment(CmDescriptor->u.Memory.Length);
            }
        }
 
        /* Now set the base address */
        CmDescriptor->u.Generic.Start.LowPart = Base.LowPart;
    }
 
    /* Save PCI settings into the PDO extension for easy access later */
    PdoExtension->Dependent.type1.PrimaryBus = Current->u.type1.PrimaryBus;
    PdoExtension->Dependent.type1.SecondaryBus = Current->u.type1.SecondaryBus;
    PdoExtension->Dependent.type1.SubordinateBus = Current->u.type1.SubordinateBus;
 
    /* Check for subtractive decode bridges */
    if (PdoExtension->Dependent.type1.SubtractiveDecode)
    {
        /* Check if legacy VGA decodes are enabled */
        DPRINT1("Subtractive decode bridge\n");
        if (Current->u.type1.BridgeControl & PCI_ENABLE_BRIDGE_VGA)
        {
            /* Save this setting for later */
            DPRINT1("VGA Bridge\n");
            PdoExtension->Dependent.type1.VgaBitSet = TRUE;
        }
 
        /* Legacy ISA decoding is not compatible with subtractive decode */
        ASSERT(PdoExtension->Dependent.type1.IsaBitSet == FALSE);
    }
    else
    {
        /* Check if legacy VGA decodes are enabled */
        if (Current->u.type1.BridgeControl & PCI_ENABLE_BRIDGE_VGA)
        {
            /* Save this setting for later */
            DPRINT1("VGA Bridge\n");
            PdoExtension->Dependent.type1.VgaBitSet = TRUE;
 
            /* And on positive decode, we'll also need extra resources locked */
            PdoExtension->AdditionalResourceCount = 4;
        }
 
        /* Check if legacy ISA decoding is enabled */
        if (Current->u.type1.BridgeControl & PCI_ENABLE_BRIDGE_ISA)
        {
            /* Save this setting for later */
            DPRINT1("ISA Bridge\n");
            PdoExtension->Dependent.type1.IsaBitSet = TRUE;
        }
    }
 
    /*
     * Check for Intel ICH PCI-to-PCI (i82801) bridges (used on the i810,
     * i820, i840, i845 Chipsets) that have subtractive decode broken.
     */
    if (((PdoExtension->VendorId == 0x8086) &&
         ((PdoExtension->DeviceId == 0x2418) ||
          (PdoExtension->DeviceId == 0x2428) ||
          (PdoExtension->DeviceId == 0x244E) ||
          (PdoExtension->DeviceId == 0x2448))) ||
        (PdoExtension->HackFlags & PCI_HACK_BROKEN_SUBTRACTIVE_DECODE))
    {
        /* Check if subtractive decode is actually enabled */
        if (PdoExtension->Dependent.type1.SubtractiveDecode)
        {
            /* We're going to need a copy of the configuration for later use */
            DPRINT1("apply config save hack to ICH subtractive decode\n");
            SavedConfig = ExAllocatePoolWithTag(0, PCI_COMMON_HDR_LENGTH, 'PciP');
            PdoExtension->ParentFdoExtension->PreservedConfig = SavedConfig;
            if (SavedConfig) RtlCopyMemory(SavedConfig, Current, PCI_COMMON_HDR_LENGTH);
        }
    }
}

PPBridge_SaveLimits()

VOID NTAPI PPBridge_SaveLimits

(

IN PPCI_CONFIGURATOR_CONTEXT

Context

)

Definition at line 465 of file ppbridge.c.

{
    PIO_RESOURCE_DESCRIPTOR Limit;
    PULONG BarArray;
    PHYSICAL_ADDRESS MemoryLimit;
    ULONG i;
    PPCI_COMMON_HEADER Working;
    PPCI_PDO_EXTENSION PdoExtension;
 
    /* Get the pointers from the context */
    Working = Context->PciData;
    PdoExtension = Context->PdoExtension;
 
    /* Scan the BARs into the limit descriptors */
    BarArray = Working->u.type1.BaseAddresses;
    Limit = PdoExtension->Resources->Limit;
 
    /* First of all, loop all the BARs */
    for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
    {
        /* Create a descriptor for their limits */
        if (PciCreateIoDescriptorFromBarLimit(&Limit[i], &BarArray[i], FALSE))
        {
            /* This was a 64-bit descriptor, make sure there's space */
            ASSERT((i + 1) < PCI_TYPE1_ADDRESSES);
 
            /* Skip the next descriptor since this one is double sized */
            i++;
            Limit[i].Type = CmResourceTypeNull;
        }
    }
 
    /* Check if this is a subtractive decode bridge */
    if (PciBridgeIsSubtractiveDecode(Context))
    {
        /* This bridge is subtractive */
        PdoExtension->Dependent.type1.SubtractiveDecode = TRUE;
 
        /* Subtractive bridges cannot use legacy ISA or VGA functionality */
        PdoExtension->Dependent.type1.IsaBitSet = FALSE;
        PdoExtension->Dependent.type1.VgaBitSet = FALSE;
    }
 
    /* For normal decode bridges, we'll need to find the bridge limits too */
    if (!PdoExtension->Dependent.type1.SubtractiveDecode)
    {
        /* Loop the descriptors that are left, to store the bridge limits */
        for (i = PCI_TYPE1_ADDRESSES; i < 5; i++)
        {
            /* No 64-bit memory addresses, and set the address to 0 to begin */
            MemoryLimit.HighPart = 0;
            (&Limit[i])->u.Port.MinimumAddress.QuadPart = 0;
 
            /* Are we getting the I/O limit? */
            if (i == 2)
            {
                /* There should be one, get it */
                ASSERT(Working->u.type1.IOLimit != 0);
                ASSERT((Working->u.type1.IOLimit & 0x0E) == 0);
                MemoryLimit.LowPart = PciBridgeIoLimit(Working);
 
                /* Build a descriptor for this limit */
                (&Limit[i])->Type = CmResourceTypePort;
                (&Limit[i])->Flags = CM_RESOURCE_PORT_WINDOW_DECODE |
                                     CM_RESOURCE_PORT_POSITIVE_DECODE;
                (&Limit[i])->u.Port.Alignment = 0x1000;
                (&Limit[i])->u.Port.MinimumAddress.QuadPart = 0;
                (&Limit[i])->u.Port.MaximumAddress = MemoryLimit;
                (&Limit[i])->u.Port.Length = 0;
            }
            else if (i == 3)
            {
                /* There should be a valid memory limit, get it */
                ASSERT((Working->u.type1.MemoryLimit & 0xF) == 0);
                MemoryLimit.LowPart = PciBridgeMemoryLimit(Working);
 
                /* Build the descriptor for it */
                (&Limit[i])->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
                (&Limit[i])->Type = CmResourceTypeMemory;
                (&Limit[i])->u.Memory.Alignment = 0x100000;
                (&Limit[i])->u.Memory.MinimumAddress.QuadPart = 0;
                (&Limit[i])->u.Memory.MaximumAddress = MemoryLimit;
                (&Limit[i])->u.Memory.Length = 0;
            }
            else if (Working->u.type1.PrefetchLimit)
            {
                /* Get the prefetch memory limit, if there is one */
                MemoryLimit = PciBridgePrefetchMemoryLimit(Working);
 
                /* Write out the descriptor for it */
                (&Limit[i])->Flags = CM_RESOURCE_MEMORY_PREFETCHABLE;
                (&Limit[i])->Type = CmResourceTypeMemory;
                (&Limit[i])->u.Memory.Alignment = 0x100000;
                (&Limit[i])->u.Memory.MinimumAddress.QuadPart = 0;
                (&Limit[i])->u.Memory.MaximumAddress = MemoryLimit;
                (&Limit[i])->u.Memory.Length = 0;
            }
            else
            {
                /* Blank descriptor */
                (&Limit[i])->Type = CmResourceTypeNull;
            }
        }
    }
 
    /* Does the ROM have its own BAR? */
    if (Working->u.type1.ROMBaseAddress & PCI_ROMADDRESS_ENABLED)
    {
        /* Build a limit for it as well */
        PciCreateIoDescriptorFromBarLimit(&Limit[i],
                                          &Working->u.type1.ROMBaseAddress,
                                          TRUE);
    }
}

routeintrf_Constructor()

NTSTATUS NTAPI routeintrf_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 47 of file routintf.c.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(InterfaceData);
    UNREFERENCED_PARAMETER(Size);
    UNREFERENCED_PARAMETER(Interface);
 
    /* Only version 1 is supported */
    if (Version != PCI_INT_ROUTE_INTRF_STANDARD_VER) return STATUS_NOINTERFACE;
 
    /* Not yet implemented */
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

routeintrf_Initializer()

NTSTATUS NTAPI routeintrf_Initializer

(

IN PVOID

Instance

)

Definition at line 37 of file routintf.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI routeintrf_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

tranirq_Constructor()

NTSTATUS NTAPI tranirq_Constructor	(	IN PVOID	DeviceExtension,
		IN PVOID	Instance,
		IN PVOID	InterfaceData,
		IN USHORT	Version,
		IN USHORT	Size,
		IN PINTERFACE	Interface
	)

Definition at line 45 of file tr_irq.c.

{
    PPCI_FDO_EXTENSION FdoExtension = (PPCI_FDO_EXTENSION)DeviceExtension;
    ULONG BaseBus, ParentBus;
    INTERFACE_TYPE ParentInterface;
    ASSERT_FDO(FdoExtension);
 
    UNREFERENCED_PARAMETER(Instance);
    UNREFERENCED_PARAMETER(Version);
    UNREFERENCED_PARAMETER(Size);
 
    /* Make sure it's the right resource type */
    if ((ULONG_PTR)InterfaceData != CmResourceTypeInterrupt)
    {
        /* Fail this invalid request */
        DPRINT1("PCI - IRQ trans constructor doesn't like %p in InterfaceSpecificData\n",
                InterfaceData);
        return STATUS_INVALID_PARAMETER_3;
    }
 
    /* Get the bus, and use this as the interface-specific data */
    BaseBus = FdoExtension->BaseBus;
    InterfaceData = UlongToPtr(BaseBus);
 
    /* Check if this is the root bus */
    if (PCI_IS_ROOT_FDO(FdoExtension))
    {
        /* It is, so there is no parent, and it's connected on the system bus */
        ParentBus = 0;
        ParentInterface = Internal;
        DPRINT1("      Is root FDO\n");
    }
    else
    {
        /* It's not, so we have to get the root bus' bus number instead */
        #if 0 // when have PDO commit
        ParentBus = FdoExtension->PhysicalDeviceObject->DeviceExtension->ParentFdoExtension->BaseBus;
        ParentInterface = PCIBus;
        DPRINT1("      Is bridge FDO, parent bus %x, secondary bus %x\n",
                ParentBus, BaseBus);
        #endif
    }
 
    /* Now call the legacy HAL interface to get the correct translator */
    return HalGetInterruptTranslator(ParentInterface,
                                     ParentBus,
                                     PCIBus,
                                     sizeof(TRANSLATOR_INTERFACE),
                                     0,
                                     (PTRANSLATOR_INTERFACE)Interface,
                                     (PULONG)&InterfaceData);
}

tranirq_Initializer()

NTSTATUS NTAPI tranirq_Initializer

(

IN PVOID

Instance

)

Definition at line 35 of file tr_irq.c.

{
    UNREFERENCED_PARAMETER(Instance);
    /* PnP Interfaces don't get Initialized */
    ASSERTMSG("PCI tranirq_Initializer, unexpected call.\n", FALSE);
    return STATUS_UNSUCCESSFUL;
}

Variable Documentation

AgpTargetInterface

PCI_INTERFACE AgpTargetInterface

extern

Definition at line 20 of file agpintrf.c.

ArbiterInterfaceBusNumber

PCI_INTERFACE ArbiterInterfaceBusNumber

extern

Definition at line 18 of file ar_busno.c.

ArbiterInterfaceIo

PCI_INTERFACE ArbiterInterfaceIo

extern

Definition at line 31 of file ar_memio.c.

ArbiterInterfaceMemory

PCI_INTERFACE ArbiterInterfaceMemory

extern

Definition at line 18 of file ar_memio.c.

BusHandlerInterface

PCI_INTERFACE BusHandlerInterface

extern

Definition at line 18 of file busintrf.c.

InitSafeBootMode

NTSYSAPI BOOLEAN InitSafeBootMode

extern

Definition at line 71 of file init.c.

Referenced by PciApplyHacks().

PciAddDevice

DRIVER_ADD_DEVICE PciAddDevice

Definition at line 619 of file pci.h.

PciAssignBusNumbers

BOOLEAN PciAssignBusNumbers

extern

Definition at line 18 of file config.c.

Referenced by PciGetConfigHandlers(), PciProcessBus(), and PciReadWriteConfigSpace().

PciCardbusPrivateInterface

PCI_INTERFACE PciCardbusPrivateInterface

extern

Definition at line 18 of file cardbus.c.

PciDevicePresentInterface

PCI_INTERFACE PciDevicePresentInterface

extern

Definition at line 18 of file devhere.c.

Referenced by PdoQueryInterface(), and VideoPortCheckForDeviceExistence().

PciDispatchIrp

DRIVER_DISPATCH PciDispatchIrp

Definition at line 541 of file pci.h.

Referenced by DriverEntry().

PciDriverObject

PDRIVER_OBJECT PciDriverObject

extern

Definition at line 19 of file init.c.

Referenced by DriverEntry(), and PciGetDescriptionMessage().

PciEnableNativeModeATA

BOOLEAN PciEnableNativeModeATA

extern

Definition at line 24 of file init.c.

Referenced by DriverEntry(), and PciApplyHacks().

PciExecuteCriticalSystemRoutine

KIPI_BROADCAST_WORKER PciExecuteCriticalSystemRoutine

Definition at line 1132 of file pci.h.

Referenced by PcipGetFunctionLimits(), and PciUpdateHardware().

PciFdoExtensionListHead

SINGLE_LIST_ENTRY PciFdoExtensionListHead

extern

Definition at line 18 of file fdo.c.

Referenced by PciAddDevice(), PciFindParentPciFdoExtension(), and PciFindPdoByLocation().

PciGlobalLock

KEVENT PciGlobalLock

extern

Definition at line 20 of file init.c.

Referenced by DriverEntry(), PciAddDevice(), PciAssignSlotResources(), and PciFindPdoByLocation().

PciHackTable

PPCI_HACK_ENTRY PciHackTable

extern

Definition at line 28 of file init.c.

Referenced by PciBuildHackTable(), and PciGetHackFlags().

PciInterfaces

PPCI_INTERFACE PciInterfaces[]

extern

Definition at line 18 of file intrface.c.

Referenced by PciInitializeArbiters(), and PciQueryInterface().

PciIrqRoutingTable

PPCI_IRQ_ROUTING_TABLE PciIrqRoutingTable

extern

Definition at line 26 of file init.c.

Referenced by DriverEntry(), and PciDetermineSlotNumber().

PciLegacyDeviceDetectionInterface

PCI_INTERFACE PciLegacyDeviceDetectionInterface

extern

Definition at line 18 of file lddintrf.c.

PciLocationInterface

PCI_INTERFACE PciLocationInterface

extern

Definition at line 18 of file locintrf.c.

PciPmeInterface

PCI_INTERFACE PciPmeInterface

extern

Definition at line 18 of file pmeintf.c.

PciRoutingInterface

PCI_INTERFACE PciRoutingInterface

extern

Definition at line 20 of file routintf.c.

PciRunningDatacenter

BOOLEAN PciRunningDatacenter

extern

Definition at line 18 of file init.c.

Referenced by DriverEntry().

TranslatorInterfaceInterrupt

PCI_INTERFACE TranslatorInterfaceInterrupt

extern

Definition at line 18 of file tr_irq.c.

WdTable

PWATCHDOG_TABLE WdTable

extern

Definition at line 27 of file init.c.

Referenced by PciScanBus().