You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
996 lines
26 KiB
996 lines
26 KiB
/*++
|
|
|
|
Copyright (c) 1990-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
fdopnp.c
|
|
|
|
Abstract:
|
|
|
|
This file contains the PNP IRP dispatch code for FDOs
|
|
|
|
Environment:
|
|
|
|
Kernel Mode Driver.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "busp.h"
|
|
#include "pnpisa.h"
|
|
#include <wdmguid.h>
|
|
#include "halpnpp.h"
|
|
|
|
|
|
//
|
|
// Function Prototypes
|
|
//
|
|
|
|
NTSTATUS
|
|
PiDeferProcessingFdo(
|
|
IN PPI_BUS_EXTENSION BusExtension,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiStartFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiQueryRemoveStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiCancelRemoveStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiQueryDeviceRelationsFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiRemoveFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiQueryLegacyBusInformationFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiQueryInterfaceFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiQueryPnpDeviceState(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiSurpriseRemoveFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE,PiDispatchPnpFdo)
|
|
#pragma alloc_text(PAGE,PiDeferProcessingFdo)
|
|
#pragma alloc_text(PAGE,PiStartFdo)
|
|
#pragma alloc_text(PAGE,PiQueryRemoveStopFdo)
|
|
#pragma alloc_text(PAGE,PiRemoveFdo)
|
|
#pragma alloc_text(PAGE,PiCancelRemoveStopFdo)
|
|
#pragma alloc_text(PAGE,PiStopFdo)
|
|
#pragma alloc_text(PAGE,PiQueryRemoveStopFdo)
|
|
#pragma alloc_text(PAGE,PiCancelRemoveStopFdo)
|
|
#pragma alloc_text(PAGE,PiQueryDeviceRelationsFdo)
|
|
#pragma alloc_text(PAGE,PiQueryInterfaceFdo)
|
|
#pragma alloc_text(PAGE,PipPassIrp)
|
|
#pragma alloc_text(PAGE,PiQueryLegacyBusInformationFdo)
|
|
#pragma alloc_text(PAGE,PiQueryPnpDeviceState)
|
|
#pragma alloc_text(PAGE,PiSurpriseRemoveFdo)
|
|
#endif
|
|
|
|
|
|
//
|
|
// PNP IRP Dispatch table for FDOs
|
|
//
|
|
|
|
PPI_DISPATCH PiPnpDispatchTableFdo[] = {
|
|
PiStartFdo, // IRP_MN_START_DEVICE
|
|
PiQueryRemoveStopFdo, // IRP_MN_QUERY_REMOVE_DEVICE
|
|
PiRemoveFdo, // IRP_MN_REMOVE_DEVICE
|
|
PiCancelRemoveStopFdo, // IRP_MN_CANCEL_REMOVE_DEVICE
|
|
PiStopFdo, // IRP_MN_STOP_DEVICE
|
|
PiQueryRemoveStopFdo, // IRP_MN_QUERY_STOP_DEVICE
|
|
PiCancelRemoveStopFdo, // IRP_MN_CANCEL_STOP_DEVICE
|
|
PiQueryDeviceRelationsFdo, // IRP_MN_QUERY_DEVICE_RELATIONS
|
|
PiQueryInterfaceFdo, // IRP_MN_QUERY_INTERFACE
|
|
PipPassIrp, // IRP_MN_QUERY_CAPABILITIES
|
|
PipPassIrp, // IRP_MN_QUERY_RESOURCES
|
|
PipPassIrp, // IRP_MN_QUERY_RESOURCE_REQUIREMENTS
|
|
PipPassIrp, // IRP_MN_QUERY_DEVICE_TEXT
|
|
PipPassIrp, // IRP_MN_FILTER_RESOURCE_REQUIREMENTS
|
|
PipPassIrp, // Unused
|
|
PipPassIrp, // IRP_MN_READ_CONFIG
|
|
PipPassIrp, // IRP_MN_WRITE_CONFIG
|
|
PipPassIrp, // IRP_MN_EJECT
|
|
PipPassIrp, // IRP_MN_SET_LOCK
|
|
PipPassIrp, // IRP_MN_QUERY_ID
|
|
PiQueryPnpDeviceState, // IRP_MN_QUERY_PNP_DEVICE_STATE
|
|
PipPassIrp, // IRP_MN_QUERY_BUS_INFORMATION
|
|
PipPassIrp, // IRP_MN_DEVICE_USAGE_NOTIFICATION
|
|
PiSurpriseRemoveFdo, // IRP_MN_SURPRISE_REMOVAL
|
|
PiQueryLegacyBusInformationFdo // IRP_MN_QUERY_LEGACY_BUS_INFORMATION
|
|
};
|
|
|
|
//
|
|
// Function declarations
|
|
//
|
|
|
|
NTSTATUS
|
|
PiDispatchPnpFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles IRP_MJ_PNP IRPs for FDOs.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the FDO for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Get a pointer to our stack location and take appropriate action based
|
|
// on the minor function.
|
|
//
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
if (irpSp->MinorFunction > IRP_MN_PNP_MAXIMUM_FUNCTION) {
|
|
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
|
|
} else {
|
|
|
|
status = PiPnpDispatchTableFdo[irpSp->MinorFunction](DeviceObject, Irp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
} //PipDispatchPnpFdo
|
|
|
|
NTSTATUS
|
|
PiPnPFdoCompletion(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to defer processing of an IRP until drivers
|
|
lower in the stack including the bus driver have done their
|
|
processing.
|
|
|
|
This routine triggers the event to indicate that processing of the
|
|
irp can now continue.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the FDO for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
|
|
{
|
|
KeSetEvent((PKEVENT) Context, EVENT_INCREMENT, FALSE);
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
NTSTATUS
|
|
PiDeferProcessingFdo(
|
|
IN PPI_BUS_EXTENSION BusExtension,
|
|
IN OUT PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to defer processing of an IRP until drivers
|
|
lower in the stack including the bus driver have done their
|
|
processing.
|
|
|
|
This routine uses an IoCompletion routine along with an event to
|
|
wait until the lower level drivers have completed processing of
|
|
the irp.
|
|
|
|
Arguments:
|
|
|
|
BusExtension - FDO extension for the FDO devobj in question
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP IRP to defer
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
KEVENT event;
|
|
NTSTATUS status;
|
|
|
|
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
|
|
|
//
|
|
// Set our completion routine
|
|
//
|
|
|
|
IoCopyCurrentIrpStackLocationToNext(Irp);
|
|
IoSetCompletionRoutine(Irp,
|
|
PiPnPFdoCompletion,
|
|
&event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE
|
|
);
|
|
status = IoCallDriver(BusExtension->AttachedDevice, Irp);
|
|
if (status == STATUS_PENDING) {
|
|
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
|
status = Irp->IoStatus.Status;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PiStartFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
PPI_BUS_EXTENSION busExtension;
|
|
NTSTATUS status;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** StartDevice irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
//
|
|
// Postpones start operations until all lower drivers have
|
|
// finished with the IRP.
|
|
//
|
|
|
|
status = PiDeferProcessingFdo(busExtension, Irp);
|
|
if (NT_SUCCESS(status)) {
|
|
busExtension->SystemPowerState = PowerSystemWorking;
|
|
busExtension->DevicePowerState = PowerDeviceD0;
|
|
}
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
return status;
|
|
} // PiStartFdo
|
|
|
|
|
|
NTSTATUS
|
|
PiQueryRemoveStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** QR/R/StopDevice irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
KeWaitForSingleObject( &IsaBusNumberLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
if (busExtension->BusNumber != 0) {
|
|
|
|
status = PipReleaseInterfaces(busExtension);
|
|
if (!NT_SUCCESS(status)) {
|
|
PipCompleteRequest(Irp,status,NULL);
|
|
return status;
|
|
}
|
|
|
|
ActiveIsaCount--;
|
|
busExtension->Flags |= DF_QUERY_STOPPED;
|
|
|
|
} else {
|
|
|
|
Irp->IoStatus.Status = status = STATUS_UNSUCCESSFUL;
|
|
IoCompleteRequest (Irp,IO_NO_INCREMENT);
|
|
}
|
|
|
|
KeSetEvent( &IsaBusNumberLock,
|
|
0,
|
|
FALSE );
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
status = PipPassIrp(DeviceObject, Irp);
|
|
}
|
|
|
|
DebugPrint((DEBUG_PNP, "QR/R/Stop Device returning: %x\n",status));
|
|
|
|
return status;
|
|
|
|
} // PiQueryRemoveStopFdo
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiCancelRemoveStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** Cancel R/Stop Device irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
status = PiDeferProcessingFdo(busExtension, Irp);
|
|
// NTRAID#53498
|
|
// ASSERT(status == STATUS_SUCCESS);
|
|
// Uncomment after PCI state machine is fixed to not fail bogus stops
|
|
|
|
//
|
|
// Add back to active count
|
|
//
|
|
KeWaitForSingleObject( &IsaBusNumberLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
if (busExtension->Flags & DF_QUERY_STOPPED) {
|
|
ActiveIsaCount++;
|
|
}
|
|
|
|
busExtension->Flags &= ~DF_QUERY_STOPPED;
|
|
|
|
|
|
KeSetEvent( &IsaBusNumberLock,
|
|
0,
|
|
FALSE );
|
|
|
|
status = PipRebuildInterfaces (busExtension);
|
|
ASSERT(status == STATUS_SUCCESS);
|
|
|
|
PipCompleteRequest(Irp, STATUS_SUCCESS, NULL);
|
|
|
|
DebugPrint((DEBUG_PNP, "Cancel R/Stop Device returning: %x\n",status));
|
|
return STATUS_SUCCESS;
|
|
} // PiCancelRemoveStopFdo
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiStopFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
PPI_BUS_EXTENSION busExtension;
|
|
NTSTATUS status;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** Stop Device irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
|
|
|
|
KeWaitForSingleObject( &IsaBusNumberLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
//
|
|
//Actually clear the bitmap
|
|
//
|
|
ASSERT (RtlAreBitsSet (BusNumBM,busExtension->BusNumber,1));
|
|
RtlClearBits (BusNumBM,busExtension->BusNumber,1);
|
|
|
|
KeSetEvent( &IsaBusNumberLock,
|
|
0,
|
|
FALSE );
|
|
|
|
|
|
busExtension->DevicePowerState = PowerDeviceD3;
|
|
//
|
|
// Handled in QueryStop, pass it down.
|
|
//
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
status = PipPassIrp (DeviceObject,Irp);
|
|
|
|
DebugPrint((DEBUG_PNP, "Stop Device returning: %x\n",status));
|
|
|
|
return status;
|
|
} // PiStopFdo
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiQueryDeviceRelationsFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
PPI_BUS_EXTENSION busExtension;
|
|
PIO_STACK_LOCATION irpSp;
|
|
PDEVICE_RELATIONS deviceRelations;
|
|
PDEVICE_INFORMATION deviceInfo;
|
|
PSINGLE_LIST_ENTRY deviceLink;
|
|
BOOLEAN creatingRDP=FALSE,accessHW;
|
|
NTSTATUS status;
|
|
|
|
DebugPrint((DEBUG_PNP, "QueryDeviceRelations FDO %x\n",
|
|
DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
#if ISOLATE_CARDS
|
|
|
|
//
|
|
// Only support BusRelations on PnpIsa bus PDO.
|
|
//
|
|
switch (irpSp->Parameters.QueryDeviceRelations.Type) {
|
|
case BusRelations: {
|
|
|
|
//
|
|
// Isolation may have been disabled via registry key. In
|
|
// that case, never enumerate an RDP.
|
|
//
|
|
// Note: Must return success and empty relations list
|
|
// *RATHER* than just passing the irp down to accomplish
|
|
// the same task due because of assumptions in the pnpres
|
|
// code.
|
|
//
|
|
if (PipIsolationDisabled) {
|
|
deviceRelations = ExAllocatePool(PagedPool,
|
|
sizeof(DEVICE_RELATIONS));
|
|
if (deviceRelations) {
|
|
deviceRelations->Count = 0;
|
|
Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
} else {
|
|
PipCompleteRequest(Irp,STATUS_INSUFFICIENT_RESOURCES,NULL);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// All relations exist on the 'root' isa bus. (don't ask)
|
|
//
|
|
if (busExtension->BusNumber != 0) {
|
|
break;
|
|
}
|
|
|
|
if (PipRDPNode) {
|
|
//
|
|
// overload the notion of "creating" for multi-bridge systems
|
|
//
|
|
if (PipRDPNode->Flags & (DF_PROCESSING_RDP|DF_ACTIVATED)) {
|
|
creatingRDP=TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (PipReadDataPort == NULL && !creatingRDP && !PipRDPNode ) {
|
|
|
|
status = PipCreateReadDataPort(busExtension);
|
|
if (!NT_SUCCESS(status)) {
|
|
PipCompleteRequest(Irp, status, NULL);
|
|
return status;
|
|
}
|
|
|
|
creatingRDP=TRUE;
|
|
}
|
|
|
|
if ((PipRDPNode && (creatingRDP) &&
|
|
!(PipRDPNode->Flags & DF_ACTIVATED)) ||
|
|
|
|
(PipRDPNode && (PipRDPNode->Flags & DF_REMOVED))) {
|
|
|
|
deviceRelations = (PDEVICE_RELATIONS) ExAllocatePool(
|
|
PagedPool,
|
|
sizeof(DEVICE_RELATIONS) );
|
|
|
|
if (deviceRelations) {
|
|
|
|
//
|
|
// If a device exists, mark it as disappeared so
|
|
// it's not reported again
|
|
//
|
|
PipLockDeviceDatabase();
|
|
deviceLink = busExtension->DeviceList.Next;
|
|
while (deviceLink) {
|
|
deviceInfo = CONTAINING_RECORD (deviceLink, DEVICE_INFORMATION, DeviceList);
|
|
if (!(deviceInfo->Flags & DF_READ_DATA_PORT)) {
|
|
deviceInfo->Flags &= ~DF_ENUMERATED;
|
|
}
|
|
deviceLink = deviceInfo->DeviceList.Next;
|
|
}
|
|
PipUnlockDeviceDatabase();
|
|
|
|
deviceRelations->Count = 1;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"QueryDeviceRelations handing back the FDO\n"));
|
|
ObReferenceObject(PipRDPNode->PhysicalDeviceObject);
|
|
deviceRelations->Objects[0] = PipRDPNode->PhysicalDeviceObject;
|
|
(PDEVICE_RELATIONS)Irp->IoStatus.Information = deviceRelations;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
break;
|
|
} else {
|
|
PipCompleteRequest(Irp, STATUS_INSUFFICIENT_RESOURCES,NULL);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Perform bus check to enumerate all the device under pnpisa bus.
|
|
//
|
|
|
|
|
|
PipLockDeviceDatabase();
|
|
|
|
if ((PipRDPNode->Flags & (DF_ACTIVATED|DF_QUERY_STOPPED)) == DF_ACTIVATED) {
|
|
accessHW = TRUE;
|
|
deviceLink = busExtension->DeviceList.Next;
|
|
while (deviceLink) {
|
|
deviceInfo = CONTAINING_RECORD (deviceLink,
|
|
DEVICE_INFORMATION,
|
|
DeviceList);
|
|
if (!(deviceInfo->Flags & DF_READ_DATA_PORT)) {
|
|
accessHW = FALSE;
|
|
DebugPrint((DEBUG_PNP,
|
|
"QueryDeviceRelations: Found 1 card, no more isolation\n"));
|
|
break;
|
|
}
|
|
deviceLink = deviceInfo->DeviceList.Next;
|
|
}
|
|
} else {
|
|
accessHW = FALSE;
|
|
}
|
|
|
|
if (PipRDPNode->Flags & DF_NEEDS_RESCAN) {
|
|
DebugPrint((DEBUG_PNP,
|
|
"QueryDeviceRelations: Force rescan\n"));
|
|
PipRDPNode->Flags &= ~DF_NEEDS_RESCAN;
|
|
accessHW = TRUE;
|
|
}
|
|
|
|
if (accessHW) {
|
|
PipCheckBus(busExtension);
|
|
} else {
|
|
DebugPrint((DEBUG_PNP, "QueryDeviceRelations: Using cached data\n"));
|
|
}
|
|
|
|
status = PipQueryDeviceRelations(
|
|
busExtension,
|
|
(PDEVICE_RELATIONS *)&Irp->IoStatus.Information,
|
|
FALSE );
|
|
PipUnlockDeviceDatabase();
|
|
Irp->IoStatus.Status = status;
|
|
if (!NT_SUCCESS(status)) {
|
|
PipCompleteRequest(Irp, status, NULL);
|
|
return status;
|
|
}
|
|
}
|
|
break;
|
|
case EjectionRelations: {
|
|
|
|
if (PipRDPNode) {
|
|
deviceRelations = (PDEVICE_RELATIONS) ExAllocatePool(
|
|
PagedPool,
|
|
sizeof(DEVICE_RELATIONS) );
|
|
if (deviceRelations) {
|
|
deviceRelations->Count = 1;
|
|
|
|
ObReferenceObject(PipRDPNode->PhysicalDeviceObject);
|
|
deviceRelations->Objects[0] = PipRDPNode->PhysicalDeviceObject;
|
|
(PDEVICE_RELATIONS)Irp->IoStatus.Information = deviceRelations;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
} else {
|
|
PipCompleteRequest(Irp,STATUS_INSUFFICIENT_RESOURCES,NULL);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#else
|
|
if (irpSp->Parameters.QueryDeviceRelations.Type == BusRelations &&
|
|
busExtension->BusNumber == 0) {
|
|
|
|
deviceRelations = (PDEVICE_RELATIONS) ExAllocatePool(
|
|
PagedPool,
|
|
sizeof(DEVICE_RELATIONS) );
|
|
if (deviceRelations) {
|
|
deviceRelations->Count = 0;
|
|
(PDEVICE_RELATIONS)Irp->IoStatus.Information = deviceRelations;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
} else {
|
|
PipCompleteRequest(Irp,STATUS_INSUFFICIENT_RESOURCES,NULL);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
} // PiQueryDeviceRelationsFdo
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiRemoveFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
PSINGLE_LIST_ENTRY child;
|
|
PBUS_EXTENSION_LIST busList,prevBus;
|
|
USHORT count=0;
|
|
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** Remove Device irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
|
|
//
|
|
// Clear the entry in the BM. Count dropped in
|
|
// Query Remove.
|
|
//
|
|
KeWaitForSingleObject( &IsaBusNumberLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
if (!(busExtension->Flags & DF_SURPRISE_REMOVED)) {
|
|
|
|
#ifdef DBG
|
|
ASSERT (RtlAreBitsSet (BusNumBM,busExtension->BusNumber,1));
|
|
#endif
|
|
|
|
RtlClearBits (BusNumBM,busExtension->BusNumber,1);
|
|
}
|
|
|
|
#if ISOLATE_CARDS
|
|
|
|
PipLockDeviceDatabase();
|
|
|
|
//
|
|
// Walk the list of children and delete them
|
|
//
|
|
child=PopEntryList (&busExtension->DeviceList);
|
|
while (child) {
|
|
ASSERT (CONTAINING_RECORD (child, DEVICE_INFORMATION,DeviceList)->PhysicalDeviceObject);
|
|
//
|
|
// This pulls them from the list!
|
|
//
|
|
count ++;
|
|
if (CONTAINING_RECORD (child, DEVICE_INFORMATION,DeviceList)->Flags & DF_READ_DATA_PORT) {
|
|
//
|
|
// Force the recreate of the RDP
|
|
//
|
|
PipCleanupAcquiredResources (busExtension);
|
|
PipReadDataPort = NULL;
|
|
PipRDPNode = NULL;
|
|
} else {
|
|
PipReleaseDeviceResources ((PDEVICE_INFORMATION)child);
|
|
|
|
}
|
|
IoDeleteDevice (CONTAINING_RECORD (child, DEVICE_INFORMATION,DeviceList)->PhysicalDeviceObject);
|
|
child=PopEntryList (&busExtension->DeviceList);
|
|
}
|
|
|
|
PipUnlockDeviceDatabase();
|
|
|
|
#endif
|
|
//
|
|
// Delete this extension.
|
|
//
|
|
prevBus= busList = PipBusExtension;
|
|
|
|
ASSERT (busList != NULL);
|
|
|
|
while (busList->BusExtension != busExtension) {
|
|
prevBus= busList;
|
|
busList = busList->Next;
|
|
ASSERT (busList != NULL);
|
|
}
|
|
//
|
|
// Remove the node
|
|
//
|
|
if (prevBus == busList) {
|
|
//
|
|
// First Node.
|
|
//
|
|
PipBusExtension=busList->Next;
|
|
}else {
|
|
prevBus->Next = busList->Next;
|
|
}
|
|
|
|
ExFreePool (busList);
|
|
KeSetEvent( &IsaBusNumberLock,
|
|
0,
|
|
FALSE );
|
|
|
|
|
|
if (count > 0 ) {
|
|
//
|
|
// If we STILL have an ISA bus. Do this.
|
|
//
|
|
if (ActiveIsaCount > 0 ) {
|
|
ASSERT (PipBusExtension->BusExtension);
|
|
IoInvalidateDeviceRelations (PipBusExtension->BusExtension->PhysicalBusDevice,BusRelations);
|
|
}
|
|
}
|
|
|
|
#if ISOLATE_CARDS
|
|
//
|
|
// Cleanup all the resources on the last remove.
|
|
//
|
|
if (!(busExtension->Flags & DF_SURPRISE_REMOVED)) {
|
|
PipCleanupAcquiredResources (busExtension);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// The PnpISa bus PDO is being removed...
|
|
//
|
|
IoDetachDevice(busExtension->AttachedDevice);
|
|
Irp->IoStatus.Status=STATUS_SUCCESS;
|
|
status = PipPassIrp(DeviceObject, Irp);
|
|
busExtension->AttachedDevice = NULL;
|
|
busExtension->Flags |= DF_DELETED;
|
|
busExtension->DevicePowerState = PowerDeviceD3;
|
|
IoDeleteDevice(busExtension->FunctionalBusDevice);
|
|
return status;
|
|
|
|
} // PiRemoveFdo
|
|
|
|
|
|
NTSTATUS
|
|
PiQueryLegacyBusInformationFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
PLEGACY_BUS_INFORMATION legacyBusInfo;
|
|
PVOID information = NULL;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
NTSTATUS status;
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
legacyBusInfo = (PLEGACY_BUS_INFORMATION) ExAllocatePool(PagedPool, sizeof(LEGACY_BUS_INFORMATION));
|
|
if (legacyBusInfo) {
|
|
legacyBusInfo->BusTypeGuid = GUID_BUS_TYPE_ISAPNP;
|
|
legacyBusInfo->LegacyBusType = Isa;
|
|
legacyBusInfo->BusNumber = busExtension->BusNumber;
|
|
information = legacyBusInfo;
|
|
status = STATUS_SUCCESS;
|
|
} else {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = (ULONG_PTR) information;
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
|
|
} else {
|
|
|
|
PipCompleteRequest (Irp,status,NULL);
|
|
return status;
|
|
}
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
PiQueryInterfaceFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
//
|
|
// We are a FDO - check if we are being asked for an interface we
|
|
// support
|
|
//
|
|
|
|
status = PiQueryInterface(busExtension, Irp);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = 0;
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
|
|
} else if (status == STATUS_NOT_SUPPORTED) {
|
|
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
|
|
} else {
|
|
|
|
PipCompleteRequest (Irp,status,NULL);
|
|
return status;
|
|
}
|
|
|
|
} // PiQueryInterfaceFdo
|
|
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiQueryPnpDeviceState(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
//
|
|
// We are a FDO
|
|
//
|
|
|
|
(PNP_DEVICE_STATE) Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
return PipPassIrp(DeviceObject, Irp);
|
|
|
|
} // PiQueryPnpDeviceState
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
NTSTATUS
|
|
PiSurpriseRemoveFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
{
|
|
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
DebugPrint((DEBUG_PNP,
|
|
"*** Surprise Remove Device irp received FDO: %x\n",DeviceObject));
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
|
|
//
|
|
// Clear the entry in the BM. Count dropped in
|
|
// Query Remove.
|
|
//
|
|
KeWaitForSingleObject( &IsaBusNumberLock,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
#ifdef DBG
|
|
ASSERT (RtlAreBitsSet (BusNumBM,busExtension->BusNumber,1));
|
|
#endif
|
|
RtlClearBits (BusNumBM,busExtension->BusNumber,1);
|
|
|
|
|
|
|
|
|
|
KeSetEvent( &IsaBusNumberLock,
|
|
0,
|
|
FALSE );
|
|
|
|
#if ISOLATE_CARDS
|
|
PipCleanupAcquiredResources (busExtension);
|
|
#endif
|
|
|
|
//
|
|
// The PnpISa bus PDO is being removed...
|
|
//
|
|
Irp->IoStatus.Status=STATUS_SUCCESS;
|
|
status = PipPassIrp(DeviceObject, Irp);
|
|
|
|
busExtension->AttachedDevice = NULL;
|
|
busExtension->Flags |= DF_SURPRISE_REMOVED;
|
|
busExtension->DevicePowerState = PowerDeviceD3;
|
|
return status;
|
|
|
|
} // PiSurpriseRemoveFdo
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|