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 1604 of file cmbatt.c.

{
    NTSTATUS Status;
    PDRIVER_EXTENSION DriverExtension;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING CallbackName;
 
    /* Allocate registry path */
    GlobalRegistryPath.MaximumLength = RegistryPath->Length + sizeof(UNICODE_NULL);
    GlobalRegistryPath.Length = RegistryPath->Length;
    GlobalRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                      GlobalRegistryPath.MaximumLength,
                                                      'MtaB');
    if (!GlobalRegistryPath.Buffer)
    {
        /* Fail if we're out of memory this early */
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBatt: Couldn't allocate pool for registry path.");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Buffer allocated, copy the string */
    RtlCopyUnicodeString(&GlobalRegistryPath, RegistryPath);
    if (CmBattDebug & CMBATT_GENERIC_INFO)
        DbgPrint("CmBatt DriverEntry - Obj (%08x) Path \"%wZ\"\n",
                 DriverObject,
                 RegistryPath);
 
    /* Setup the major dispatchers */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = CmBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = CmBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = CmBattIoctl;
    DriverObject->MajorFunction[IRP_MJ_POWER] = CmBattPowerDispatch;
    DriverObject->MajorFunction[IRP_MJ_PNP] = CmBattPnpDispatch;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = CmBattSystemControl;
 
    /* And the unload routine */
    DriverObject->DriverUnload = CmBattUnload;
 
    /* And the add device routine */
    DriverExtension = DriverObject->DriverExtension;
    DriverExtension->AddDevice = CmBattAddDevice;
 
    /* Create a power callback */
    RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
    InitializeObjectAttributes(&ObjectAttributes,
                               &CallbackName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ExCreateCallback(&CmBattPowerCallBackObject, &ObjectAttributes, 0, TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* No callback, fail */
        CmBattPowerCallBackObject = 0;
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBattRegisterPowerCallBack: failed status=0x%08x\n", Status);
    }
    else
    {
        /* Register the power callback now */
        CmBattPowerCallBackRegistration = ExRegisterCallback(CmBattPowerCallBackObject,
                                                             (PVOID)CmBattPowerCallBack,
                                                             DriverObject);
        if (CmBattPowerCallBackRegistration)
        {
            /* Last thing: setup our DPC and timer for battery wake */
            KeInitializeDpc(&CmBattWakeDpcObject, (PVOID)CmBattWakeDpc, DriverObject);
            KeInitializeTimer(&CmBattWakeDpcTimerObject);
        }
        else
        {
            ObDereferenceObject(CmBattPowerCallBackObject);
            if (CmBattDebug & CMBATT_GENERIC_WARNING)
                DbgPrint("CmBattRegisterPowerCallBack: ExRegisterCallback failed.\n");
        }
 
        /* All good */
        Status = STATUS_SUCCESS;
    }
 
    /* Return failure or success */
    return Status;
}

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