pci.h File Reference

#include <ntifs.h>
#include <cmreslist.h>
#include <ntstrsafe.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_DEVICE
struct	_COMMON_DEVICE_EXTENSION
struct	_PDO_DEVICE_EXTENSION
struct	_FDO_DEVICE_EXTENSION
struct	_PCI_DRIVER_EXTENSION
union	_PCI_TYPE1_CFG_CYCLE_BITS

Macros
#define	TAG_PCI   '0ICP'

Typedefs
typedef struct _PCI_DEVICE	PCI_DEVICE
typedef struct _PCI_DEVICE *	PPCI_DEVICE
typedef struct _COMMON_DEVICE_EXTENSION	COMMON_DEVICE_EXTENSION
typedef struct _COMMON_DEVICE_EXTENSION *	PCOMMON_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION	PDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION	FDO_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct _PCI_DRIVER_EXTENSION	PCI_DRIVER_EXTENSION
typedef struct _PCI_DRIVER_EXTENSION *	PPCI_DRIVER_EXTENSION
typedef union _PCI_TYPE1_CFG_CYCLE_BITS	PCI_TYPE1_CFG_CYCLE_BITS
typedef union _PCI_TYPE1_CFG_CYCLE_BITS *	PPCI_TYPE1_CFG_CYCLE_BITS

Enumerations
enum	PCI_DEVICE_STATE {   dsStopped , dsStarted , dsPaused , dsRemoved ,   dsSurpriseRemoved }

Functions
NTSTATUS	FdoPnpControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	FdoPowerControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	PciCreateDeviceIDString (PUNICODE_STRING DeviceID, PPCI_DEVICE Device)
NTSTATUS	PciCreateInstanceIDString (PUNICODE_STRING InstanceID, PPCI_DEVICE Device)
NTSTATUS	PciCreateHardwareIDsString (PUNICODE_STRING HardwareIDs, PPCI_DEVICE Device)
NTSTATUS	PciCreateCompatibleIDsString (PUNICODE_STRING HardwareIDs, PPCI_DEVICE Device)
NTSTATUS	PciCreateDeviceDescriptionString (PUNICODE_STRING DeviceDescription, PPCI_DEVICE Device)
NTSTATUS	PciCreateDeviceLocationString (PUNICODE_STRING DeviceLocation, PPCI_DEVICE Device)
NTSTATUS	PciDuplicateUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)
NTSTATUS	PdoPnpControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	PdoPowerControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

Variables
PPCI_DRIVER_EXTENSION	DriverExtension
BOOLEAN	HasDebuggingDevice
PCI_TYPE1_CFG_CYCLE_BITS	PciDebuggingDevice [2]

Macro Definition Documentation

TAG_PCI

#define TAG_PCI   '0ICP'

Definition at line 8 of file pci.h.

Typedef Documentation

COMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION COMMON_DEVICE_EXTENSION

FDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION FDO_DEVICE_EXTENSION

PCI_DEVICE

typedef struct _PCI_DEVICE PCI_DEVICE

PCI_DRIVER_EXTENSION

typedef struct _PCI_DRIVER_EXTENSION PCI_DRIVER_EXTENSION

PCI_TYPE1_CFG_CYCLE_BITS

typedef union _PCI_TYPE1_CFG_CYCLE_BITS PCI_TYPE1_CFG_CYCLE_BITS

PCOMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION

PDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION PDO_DEVICE_EXTENSION

PFDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PPCI_DEVICE

typedef struct _PCI_DEVICE * PPCI_DEVICE

PPCI_DRIVER_EXTENSION

typedef struct _PCI_DRIVER_EXTENSION * PPCI_DRIVER_EXTENSION

PPCI_TYPE1_CFG_CYCLE_BITS

typedef union _PCI_TYPE1_CFG_CYCLE_BITS * PPCI_TYPE1_CFG_CYCLE_BITS

PPDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

Enumeration Type Documentation

PCI_DEVICE_STATE

enum PCI_DEVICE_STATE

Enumerator
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved

Definition at line 33 of file pci.h.

{
    dsStopped,
    dsStarted,
    dsPaused,
    dsRemoved,
    dsSurpriseRemoved
} PCI_DEVICE_STATE;

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 367 of file beep.c.

{
    PDEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Beep");
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    /* Create the device */
    Status = IoCreateDevice(DriverObject,
                            sizeof(DEVICE_EXTENSION),
                            &DeviceName,
                            FILE_DEVICE_BEEP,
                            0,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Make it use buffered I/O */
    DeviceObject->Flags |= DO_BUFFERED_IO;
 
    /* Setup the Driver Object */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
    DriverObject->DriverUnload = BeepUnload;
    DriverObject->DriverStartIo = BeepStartIo;
 
    /* Set up device extension */
    DeviceExtension = DeviceObject->DeviceExtension;
    DeviceExtension->ReferenceCount = 0;
    DeviceExtension->TimerActive = FALSE;
    IoInitializeDpcRequest(DeviceObject, (PIO_DPC_ROUTINE)BeepDPC);
    KeInitializeTimer(&DeviceExtension->Timer);
    ExInitializeFastMutex(&DeviceExtension->Mutex);
 
    /* Page the entire driver */
    MmPageEntireDriver(DriverEntry);
    return STATUS_SUCCESS;
}

FdoPnpControl()

NTSTATUS FdoPnpControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 469 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status = Irp->IoStatus.Status;
 
    DPRINT("Called\n");
 
    DeviceExtension = DeviceObject->DeviceExtension;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
    switch (IrpSp->MinorFunction)
    {
#if 0
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
#endif
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations)
                break;
 
            Status = FdoQueryBusRelations(DeviceObject, Irp, IrpSp);
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
#if 0
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
#endif
        case IRP_MN_START_DEVICE:
            DPRINT("IRP_MN_START_DEVICE received\n");
            Status = STATUS_UNSUCCESSFUL;
 
            if (IoForwardIrpSynchronously(DeviceExtension->Ldo, Irp))
            {
                Status = Irp->IoStatus.Status;
                if (NT_SUCCESS(Status))
                {
                    Status = FdoStartDevice(DeviceObject, Irp);
                }
            }
 
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
 
        case IRP_MN_QUERY_STOP_DEVICE:
            /* We don't support stopping yet */
            Status = STATUS_UNSUCCESSFUL;
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
 
        case IRP_MN_STOP_DEVICE:
            /* We can't fail this one so we fail the QUERY_STOP request that precedes it */
            break;
#if 0
        case IRP_MN_SURPRISE_REMOVAL:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
#endif
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            /* Detach the device object from the device stack */
            IoDetachDevice(DeviceExtension->Ldo);
 
            /* Delete the device object */
            IoDeleteDevice(DeviceObject);
 
            /* Return success */
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            /* Don't print the warning, too much noise */
            break;
 
        default:
            DPRINT1("Unknown PNP minor function 0x%x\n", IrpSp->MinorFunction);
            break;
    }
 
    Irp->IoStatus.Status = Status;
    IoSkipCurrentIrpStackLocation(Irp);
    Status = IoCallDriver(DeviceExtension->Ldo, Irp);
 
    DPRINT("Leaving. Status 0x%lx\n", Status);
 
    return Status;
}

Referenced by PciPnpControl().

FdoPowerControl()

NTSTATUS FdoPowerControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 594 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    DPRINT("Called\n");
 
    DeviceExtension = DeviceObject->DeviceExtension;
 
    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    Status = PoCallDriver(DeviceExtension->Ldo, Irp);
 
    DPRINT("Leaving. Status 0x%X\n", Status);
 
    return Status;
}

Referenced by PciPowerControl().

PciCreateCompatibleIDsString()

NTSTATUS PciCreateCompatibleIDsString	(	PUNICODE_STRING	HardwareIDs,
		PPCI_DEVICE	Device
	)

Definition at line 366 of file pci.c.

{
    WCHAR Buffer[256];
    UNICODE_STRING BufferU;
    ULONG Index;
 
    Index = 0;
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X&REV_%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID,
                      Device->PciConfig.RevisionID);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&CC_%02X%02X%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass,
                      Device->PciConfig.ProgIf);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&CC_%02X%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X",
                      Device->PciConfig.VendorID);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\CC_%02X%02X%02X",
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass,
                      Device->PciConfig.ProgIf);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\CC_%02X%02X",
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass);
    Index++;
 
    Buffer[Index] = UNICODE_NULL;
 
    BufferU.Length = BufferU.MaximumLength = (USHORT)Index * sizeof(WCHAR);
    BufferU.Buffer = Buffer;
 
    return PciDuplicateUnicodeString(0, &BufferU, CompatibleIDs);
}

Referenced by FdcFdoQueryBusRelations(), and FdoQueryBusRelations().

PciCreateDeviceDescriptionString()

NTSTATUS PciCreateDeviceDescriptionString	(	PUNICODE_STRING	DeviceDescription,
		PPCI_DEVICE	Device
	)

Definition at line 430 of file pci.c.

{
    PCWSTR Description;
 
    switch (Device->PciConfig.BaseClass)
    {
        case PCI_CLASS_PRE_20:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_PRE_20_VGA:
                    Description = L"VGA device";
                    break;
 
                default:
                case PCI_SUBCLASS_PRE_20_NON_VGA:
                    Description = L"PCI device";
                    break;
            }
            break;
 
        case PCI_CLASS_MASS_STORAGE_CTLR:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_MSC_SCSI_BUS_CTLR:
                    Description = L"SCSI controller";
                    break;
 
                case PCI_SUBCLASS_MSC_IDE_CTLR:
                    Description = L"IDE controller";
                    break;
 
                case PCI_SUBCLASS_MSC_FLOPPY_CTLR:
                    Description = L"Floppy disk controller";
                    break;
 
                case PCI_SUBCLASS_MSC_IPI_CTLR:
                    Description = L"IPI controller";
                    break;
 
                case PCI_SUBCLASS_MSC_RAID_CTLR:
                    Description = L"RAID controller";
                    break;
 
                default:
                    Description = L"Mass storage controller";
                    break;
            }
            break;
 
        case PCI_CLASS_NETWORK_CTLR:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_NET_ETHERNET_CTLR:
                    Description = L"Ethernet controller";
                    break;
 
                case PCI_SUBCLASS_NET_TOKEN_RING_CTLR:
                    Description = L"Token-Ring controller";
                    break;
 
                case PCI_SUBCLASS_NET_FDDI_CTLR:
                    Description = L"FDDI controller";
                    break;
 
                case PCI_SUBCLASS_NET_ATM_CTLR:
                    Description = L"ATM controller";
                    break;
 
                default:
                    Description = L"Network controller";
                    break;
            }
            break;
 
        case PCI_CLASS_DISPLAY_CTLR:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_VID_VGA_CTLR:
                    Description = L"VGA display controller";
                    break;
 
                case PCI_SUBCLASS_VID_XGA_CTLR:
                    Description = L"XGA display controller";
                    break;
 
                case PCI_SUBCLASS_VID_3D_CTLR:
                    Description = L"Multimedia display controller";
                    break;
 
                default:
                    Description = L"Other display controller";
                    break;
            }
            break;
 
        case PCI_CLASS_MULTIMEDIA_DEV:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_MM_VIDEO_DEV:
                    Description = L"Multimedia video device";
                    break;
 
                case PCI_SUBCLASS_MM_AUDIO_DEV:
                    Description = L"Multimedia audio device";
                    break;
 
                case PCI_SUBCLASS_MM_TELEPHONY_DEV:
                    Description = L"Multimedia telephony device";
                    break;
 
                default:
                    Description = L"Other multimedia device";
                    break;
            }
            break;
 
        case PCI_CLASS_MEMORY_CTLR:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_MEM_RAM:
                    Description = L"PCI Memory";
                    break;
 
                case PCI_SUBCLASS_MEM_FLASH:
                    Description = L"PCI Flash Memory";
                    break;
 
                default:
                    Description = L"Other memory controller";
                    break;
            }
            break;
 
        case PCI_CLASS_BRIDGE_DEV:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_BR_HOST:
                    Description = L"PCI-Host bridge";
                    break;
 
                case PCI_SUBCLASS_BR_ISA:
                    Description = L"PCI-ISA bridge";
                    break;
 
                case PCI_SUBCLASS_BR_EISA:
                    Description = L"PCI-EISA bridge";
                    break;
 
                case PCI_SUBCLASS_BR_MCA:
                    Description = L"PCI-Micro Channel bridge";
                    break;
 
                case PCI_SUBCLASS_BR_PCI_TO_PCI:
                    Description = L"PCI-PCI bridge";
                    break;
 
                case PCI_SUBCLASS_BR_PCMCIA:
                    Description = L"PCI-PCMCIA bridge";
                    break;
 
                case PCI_SUBCLASS_BR_NUBUS:
                    Description = L"PCI-NUBUS bridge";
                    break;
 
                case PCI_SUBCLASS_BR_CARDBUS:
                    Description = L"PCI-CARDBUS bridge";
                    break;
 
                default:
                    Description = L"Other bridge device";
                    break;
            }
            break;
 
        case PCI_CLASS_SIMPLE_COMMS_CTLR:
            switch (Device->PciConfig.SubClass)
            {
 
                default:
                    Description = L"Communication device";
                    break;
            }
            break;
 
        case PCI_CLASS_BASE_SYSTEM_DEV:
            switch (Device->PciConfig.SubClass)
            {
 
                default:
                    Description = L"System device";
                    break;
            }
            break;
 
        case PCI_CLASS_INPUT_DEV:
            switch (Device->PciConfig.SubClass)
            {
 
                default:
                    Description = L"Input device";
                    break;
            }
            break;
 
        case PCI_CLASS_DOCKING_STATION:
            switch (Device->PciConfig.SubClass)
            {
 
                default:
                    Description = L"Docking station";
                    break;
            }
            break;
 
        case PCI_CLASS_PROCESSOR:
            switch (Device->PciConfig.SubClass)
            {
 
                default:
                    Description = L"Processor";
                    break;
            }
            break;
 
        case PCI_CLASS_SERIAL_BUS_CTLR:
            switch (Device->PciConfig.SubClass)
            {
                case PCI_SUBCLASS_SB_IEEE1394:
                    Description = L"FireWire controller";
                    break;
 
                case PCI_SUBCLASS_SB_ACCESS:
                    Description = L"ACCESS bus controller";
                    break;
 
                case PCI_SUBCLASS_SB_SSA:
                    Description = L"SSA controller";
                    break;
 
                case PCI_SUBCLASS_SB_USB:
                    Description = L"USB controller";
                    break;
 
                case PCI_SUBCLASS_SB_FIBRE_CHANNEL:
                    Description = L"Fibre Channel controller";
                    break;
 
                case PCI_SUBCLASS_SB_SMBUS:
                    Description = L"SMBus controller";
                    break;
 
                default:
                    Description = L"Other serial bus controller";
                    break;
            }
            break;
 
        default:
            Description = L"Other PCI Device";
            break;
    }
 
    return RtlCreateUnicodeString(DeviceDescription, Description) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by FdcFdoQueryBusRelations(), and FdoQueryBusRelations().

PciCreateDeviceIDString()

NTSTATUS PciCreateDeviceIDString	(	PUNICODE_STRING	DeviceID,
		PPCI_DEVICE	Device
	)

Definition at line 284 of file pci.c.

{
    WCHAR Buffer[256];
 
    swprintf(Buffer,
             L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X&REV_%02X",
             Device->PciConfig.VendorID,
             Device->PciConfig.DeviceID,
             (Device->PciConfig.u.type0.SubSystemID << 16) +
             Device->PciConfig.u.type0.SubVendorID,
             Device->PciConfig.RevisionID);
 
    return RtlCreateUnicodeString(DeviceID, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by FdoQueryBusRelations().

PciCreateDeviceLocationString()

NTSTATUS PciCreateDeviceLocationString	(	PUNICODE_STRING	DeviceLocation,
		PPCI_DEVICE	Device
	)

Definition at line 698 of file pci.c.

{
    WCHAR Buffer[256];
 
    swprintf(Buffer,
             L"PCI-Bus %lu, Device %u, Function %u",
             Device->BusNumber,
             Device->SlotNumber.u.bits.DeviceNumber,
             Device->SlotNumber.u.bits.FunctionNumber);
 
    return RtlCreateUnicodeString(DeviceLocation, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by FdcFdoQueryBusRelations(), and FdoQueryBusRelations().

PciCreateHardwareIDsString()

NTSTATUS PciCreateHardwareIDsString	(	PUNICODE_STRING	HardwareIDs,
		PPCI_DEVICE	Device
	)

Definition at line 314 of file pci.c.

{
    WCHAR Buffer[256];
    UNICODE_STRING BufferU;
    ULONG Index;
 
    Index = 0;
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X&REV_%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID,
                      (Device->PciConfig.u.type0.SubSystemID << 16) +
                      Device->PciConfig.u.type0.SubVendorID,
                      Device->PciConfig.RevisionID);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID,
                      (Device->PciConfig.u.type0.SubSystemID << 16) +
                      Device->PciConfig.u.type0.SubVendorID);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X&CC_%02X%02X%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID,
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass,
                      Device->PciConfig.ProgIf);
    Index++;
 
    Index += swprintf(&Buffer[Index],
                      L"PCI\\VEN_%04X&DEV_%04X&CC_%02X%02X",
                      Device->PciConfig.VendorID,
                      Device->PciConfig.DeviceID,
                      Device->PciConfig.BaseClass,
                      Device->PciConfig.SubClass);
    Index++;
 
    Buffer[Index] = UNICODE_NULL;
 
    BufferU.Length = BufferU.MaximumLength = (USHORT) Index * sizeof(WCHAR);
    BufferU.Buffer = Buffer;
 
    return PciDuplicateUnicodeString(0, &BufferU, HardwareIDs);
}

Referenced by FdcFdoQueryBusRelations(), and FdoQueryBusRelations().

PciCreateInstanceIDString()

NTSTATUS PciCreateInstanceIDString	(	PUNICODE_STRING	InstanceID,
		PPCI_DEVICE	Device
	)

Definition at line 302 of file pci.c.

{
    WCHAR Buffer[3];
 
    swprintf(Buffer, L"%02X", Device->SlotNumber.u.AsULONG & 0xff);
 
    return RtlCreateUnicodeString(InstanceID, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by FdcFdoQueryBusRelations(), and FdoQueryBusRelations().

PciDuplicateUnicodeString()

NTSTATUS PciDuplicateUnicodeString	(	IN ULONG	Flags,
		IN PCUNICODE_STRING	SourceString,
		OUT PUNICODE_STRING	DestinationString
	)

Definition at line 713 of file pci.c.

{
    if (SourceString == NULL ||
        DestinationString == NULL ||
        SourceString->Length > SourceString->MaximumLength ||
        (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL) ||
        Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING ||
        Flags >= 4)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    if ((SourceString->Length == 0) &&
        (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
                   RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
        DestinationString->Buffer = NULL;
    }
    else
    {
        USHORT DestMaxLength = SourceString->Length;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestMaxLength += sizeof(UNICODE_NULL);
 
        DestinationString->Buffer = ExAllocatePoolWithTag(PagedPool, DestMaxLength, TAG_PCI);
        if (DestinationString->Buffer == NULL)
            return STATUS_NO_MEMORY;
 
        RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
        DestinationString->Length = SourceString->Length;
        DestinationString->MaximumLength = DestMaxLength;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
    }
 
    return STATUS_SUCCESS;
}

Referenced by PciCreateCompatibleIDsString(), PciCreateHardwareIDsString(), PdoQueryDeviceText(), and PdoQueryId().

PdoPnpControl()

NTSTATUS PdoPnpControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 1502 of file pdo.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
 
    DPRINT("Called\n");
 
    Status = Irp->IoStatus.Status;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            DPRINT("Unimplemented IRP_MN_DEVICE_USAGE_NOTIFICATION received\n");
            break;
 
        case IRP_MN_EJECT:
            DPRINT("Unimplemented IRP_MN_EJECT received\n");
            break;
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            Status = PdoQueryBusInformation(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
            Status = PdoQueryCapabilities(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            Status = PdoQueryDeviceRelations(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            DPRINT("IRP_MN_QUERY_DEVICE_TEXT received\n");
            Status = PdoQueryDeviceText(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_ID:
            DPRINT("IRP_MN_QUERY_ID received\n");
            Status = PdoQueryId(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DPRINT("Unimplemented IRP_MN_QUERY_ID received\n");
            break;
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS received\n");
            Status = PdoQueryResourceRequirements(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_RESOURCES:
            DPRINT("IRP_MN_QUERY_RESOURCES received\n");
            Status = PdoQueryResources(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_SET_LOCK:
            DPRINT("Unimplemented IRP_MN_SET_LOCK received\n");
            break;
 
        case IRP_MN_START_DEVICE:
            Status = PdoStartDevice(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        case IRP_MN_REMOVE_DEVICE:
        case IRP_MN_SURPRISE_REMOVAL:
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_INTERFACE:
            DPRINT("IRP_MN_QUERY_INTERFACE received\n");
            Status = PdoQueryInterface(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_READ_CONFIG:
            DPRINT("IRP_MN_READ_CONFIG received\n");
            Status = PdoReadConfig(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_WRITE_CONFIG:
            DPRINT("IRP_MN_WRITE_CONFIG received\n");
            Status = PdoWriteConfig(DeviceObject, Irp, IrpSp);
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS received\n");
            /* Nothing to do */
            Irp->IoStatus.Status = Status;
            break;
 
        default:
            DPRINT1("Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
            break;
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    DPRINT("Leaving. Status 0x%X\n", Status);
 
    return Status;
}

Referenced by PciPnpControl().

PdoPowerControl()

NTSTATUS PdoPowerControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 1625 of file pdo.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status = Irp->IoStatus.Status;
 
    DPRINT("Called\n");
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_QUERY_POWER:
        case IRP_MN_SET_POWER:
            Status = STATUS_SUCCESS;
            break;
    }
 
    PoStartNextPowerIrp(Irp);
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    DPRINT("Leaving. Status 0x%X\n", Status);
 
    return Status;
}

Referenced by PciPowerControl().

Variable Documentation

DriverExtension

PPCI_DRIVER_EXTENSION DriverExtension

extern

Definition at line 31 of file pci.c.

Referenced by _Dispatch_type_(), ClassAddDevice(), ClassInitializeDispatchTables(), ConDrvCreateController(), CreateClassDeviceObject(), CreateGreenFdo(), DestroyPortDriver(), DriverEntry(), FdoStartDevice(), FsRtlAcquireFileExclusiveCommon(), FsRtlRegisterFileSystemFilterCallbacks(), GreenAddDevice(), GreenDispatch(), HidClassAddDevice(), HidRegisterMinidriver(), i8042RemoveDevice(), InterfacePciDevicePresent(), InterfacePciDevicePresentEx(), IntVideoPortAddDevice(), IntVideoPortCreateAdapterDeviceObject(), IntVideoPortDispatchOpen(), IntVideoPortFilterResourceRequirements(), IntVideoPortFindAdapter(), IntVideoPortGetLegacyResources(), IntVideoPortPnPStartDevice(), IntVideoPortResetDisplayParametersEx(), IntVideoPortSetupInterrupt(), IntVideoPortSetupTimer(), IopDeleteDriver(), IopReinitializeBootDrivers(), IopReinitializeDrivers(), PciIdeXAddDevice(), PciIdeXInitialize(), PciIdeXStartMiniport(), PortAddDevice(), PortAddDriverInitData(), PortDeleteDriverInitData(), PortGetDriverInitData(), PortUnload(), ReadRegistryEntries(), ReportGreenPdo(), SearchForLegacyDrivers(), SermouseAddDevice(), SpiInitOpenKeys(), StorPortInitialize(), VfdUnloadDriver(), VideoPortForwardDeviceControl(), VideoPortGetAccessRanges(), and VideoPortInitialize().

HasDebuggingDevice

BOOLEAN HasDebuggingDevice

extern

Definition at line 32 of file pci.c.

Referenced by HalpRegisterPciDebuggingDeviceInfo(), PciIsDebuggingDevice(), and PciLocateKdDevices().

PciDebuggingDevice

PCI_TYPE1_CFG_CYCLE_BITS PciDebuggingDevice[2]

extern

Definition at line 33 of file pci.c.

Referenced by PciIsDebuggingDevice(), and PciLocateKdDevices().