654 lines
20 KiB
C++
654 lines
20 KiB
C++
/*++
|
|
|
|
Copyright (c) 1991 - 2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
##### ## # ##### #### ##### #####
|
|
## ## ### # ## ## ## # ## ## ## ##
|
|
## ## #### # ## ## ## ## ## ## ##
|
|
## ## # #### ## ## ## ## ## ## ##
|
|
##### # ### ##### ## ##### #####
|
|
## # ## ## ## ## # ## ##
|
|
## # # ## ## #### ## ##
|
|
|
|
Abstract:
|
|
|
|
This module process all plug and play IRPs.
|
|
|
|
Author:
|
|
|
|
Wesley Witt (wesw) 1-Oct-2001
|
|
|
|
Environment:
|
|
|
|
Kernel mode only.
|
|
|
|
Notes:
|
|
|
|
|
|
--*/
|
|
|
|
#include "internal.h"
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE,SaPortAddDevice)
|
|
#pragma alloc_text(PAGE,SaPortPnp)
|
|
#endif
|
|
|
|
|
|
//
|
|
// Device names
|
|
//
|
|
|
|
PWSTR SaDeviceName[] =
|
|
{
|
|
{ NULL }, // Bogus
|
|
{ SA_DEVICE_DISPLAY_NAME_STRING }, // SA_DEVICE_DISPLAY
|
|
{ SA_DEVICE_KEYPAD_NAME_STRING }, // SA_DEVICE_KEYPAD
|
|
{ SA_DEVICE_NVRAM_NAME_STRING }, // SA_DEVICE_NVRAM
|
|
{ SA_DEVICE_WATCHDOG_NAME_STRING } // SA_DEVICE_WATCHDOG
|
|
};
|
|
|
|
|
|
//
|
|
// Prototypes
|
|
//
|
|
|
|
#define DECLARE_PNP_HANDLER(_NAME) \
|
|
NTSTATUS \
|
|
_NAME( \
|
|
IN PDEVICE_OBJECT DeviceObject, \
|
|
IN PIRP Irp, \
|
|
IN PIO_STACK_LOCATION IrpSp, \
|
|
IN PDEVICE_EXTENSION DeviceExtension \
|
|
)
|
|
|
|
DECLARE_PNP_HANDLER( DefaultPnpHandler );
|
|
DECLARE_PNP_HANDLER( HandleStartDevice );
|
|
DECLARE_PNP_HANDLER( HandleQueryCapabilities );
|
|
DECLARE_PNP_HANDLER( HandleQueryDeviceState );
|
|
|
|
|
|
//
|
|
// PNP dispatch table
|
|
//
|
|
|
|
typedef NTSTATUS (*PPNP_DISPATCH_FUNC)(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp,
|
|
IN PDEVICE_EXTENSION DeviceExtension
|
|
);
|
|
|
|
|
|
PPNP_DISPATCH_FUNC PnpDispatchTable[] =
|
|
{
|
|
HandleStartDevice, // IRP_MN_START_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_QUERY_REMOVE_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_REMOVE_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_CANCEL_REMOVE_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_STOP_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_QUERY_STOP_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_CANCEL_STOP_DEVICE
|
|
DefaultPnpHandler, // IRP_MN_QUERY_DEVICE_RELATIONS
|
|
DefaultPnpHandler, // IRP_MN_QUERY_INTERFACE
|
|
HandleQueryCapabilities, // IRP_MN_QUERY_CAPABILITIES
|
|
DefaultPnpHandler, // IRP_MN_QUERY_RESOURCES
|
|
DefaultPnpHandler, // IRP_MN_QUERY_RESOURCE_REQUIREMENTS
|
|
DefaultPnpHandler, // IRP_MN_QUERY_DEVICE_TEXT
|
|
DefaultPnpHandler, // IRP_MN_FILTER_RESOURCE_REQUIREMENTS
|
|
DefaultPnpHandler, // *unused*
|
|
DefaultPnpHandler, // IRP_MN_READ_CONFIG
|
|
DefaultPnpHandler, // IRP_MN_WRITE_CONFIG
|
|
DefaultPnpHandler, // IRP_MN_EJECT
|
|
DefaultPnpHandler, // IRP_MN_SET_LOCK
|
|
DefaultPnpHandler, // IRP_MN_QUERY_ID
|
|
HandleQueryDeviceState, // IRP_MN_QUERY_PNP_DEVICE_STATE
|
|
DefaultPnpHandler, // IRP_MN_QUERY_BUS_INFORMATION
|
|
DefaultPnpHandler, // IRP_MN_DEVICE_USAGE_NOTIFICATION
|
|
DefaultPnpHandler // IRP_MN_SURPRISE_REMOVAL
|
|
};
|
|
|
|
|
|
|
|
NTSTATUS
|
|
SaPortAddDevice(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN OUT PDEVICE_OBJECT PhysicalDeviceObject
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the driver's pnp add device entry point. It is
|
|
called by the pnp manager to initialize the driver.
|
|
|
|
Add device creates and initializes a device object for this FDO and
|
|
attaches to the underlying PDO.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - a pointer to the object that represents this device driver.
|
|
PhysicalDeviceObject - a pointer to the underlying PDO to which this new device will attach.
|
|
|
|
Return Value:
|
|
|
|
If we successfully create a device object, STATUS_SUCCESS is
|
|
returned. Otherwise, return the appropriate error code.
|
|
|
|
Notes:
|
|
|
|
The device extension that is allocated for each server appliance
|
|
miniport is really a concatination of several data structures.
|
|
|
|
|------------------------------|
|
|
| |
|
|
| Port driver extension | This is the DEVICE_EXTENSION data structure
|
|
| |
|
|
|------------------------------|
|
|
| |
|
|
| Port driver device | This is the DISPLAY_DEVICE_EXTENSION, KEYPAD_DEVICE_EXTENSION,
|
|
| specific data structure | NVRAM_DEVICE_EXTENSION, or the WATCHDOG_DEVICE_EXTENSION data structure.
|
|
| |
|
|
|------------------------------|
|
|
| |
|
|
| Size of the port driver | This is a single ULONG value and is used to back-compute the location of
|
|
| portion of the extension | the port driver extension from the miniport device extension.
|
|
| |
|
|
|------------------------------|
|
|
| |
|
|
| Miniport device extension | This is owned by the miniport driver and can be anything. The size must be
|
|
| | specified in the DeviceExtensionSize field of the SAPORT_INITIALIZATION_DATA structure.
|
|
|------------------------------|
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PSAPORT_DRIVER_EXTENSION DriverExtension;
|
|
PDEVICE_EXTENSION DeviceExtension = NULL;
|
|
PDEVICE_OBJECT deviceObject = NULL;
|
|
ULONG DeviceExtensionSize;
|
|
WCHAR DeviceNameBuffer[64];
|
|
UNICODE_STRING DeviceName;
|
|
UNICODE_STRING VmLinkName = {0};
|
|
UNICODE_STRING SaLinkName = {0};
|
|
|
|
|
|
__try {
|
|
|
|
DriverExtension = (PSAPORT_DRIVER_EXTENSION) IoGetDriverObjectExtension( DriverObject, SaPortInitialize );
|
|
if (DriverExtension == NULL) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
ERROR_RETURN( 0, "IoGetDriverObjectExtension", status );
|
|
}
|
|
|
|
DebugPrint(( DriverExtension->InitData.DeviceType, SAPORT_DEBUG_INFO_LEVEL, "SaPortAddDevice\n" ));
|
|
|
|
DeviceExtensionSize = DriverExtension->InitData.DeviceExtensionSize + sizeof(ULONG);
|
|
|
|
switch (DriverExtension->InitData.DeviceType) {
|
|
case SA_DEVICE_DISPLAY:
|
|
DeviceExtensionSize += sizeof(DISPLAY_DEVICE_EXTENSION);
|
|
break;
|
|
|
|
case SA_DEVICE_KEYPAD:
|
|
DeviceExtensionSize += sizeof(KEYPAD_DEVICE_EXTENSION);
|
|
break;
|
|
|
|
case SA_DEVICE_NVRAM:
|
|
DeviceExtensionSize += sizeof(NVRAM_DEVICE_EXTENSION);
|
|
break;
|
|
|
|
case SA_DEVICE_WATCHDOG:
|
|
DeviceExtensionSize += sizeof(WATCHDOG_DEVICE_EXTENSION);
|
|
break;
|
|
|
|
default:
|
|
DeviceExtensionSize += sizeof(DEVICE_EXTENSION);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Establish the device name
|
|
//
|
|
|
|
DeviceName.MaximumLength = sizeof(DeviceNameBuffer);
|
|
DeviceName.Buffer = DeviceNameBuffer;
|
|
|
|
wcscpy( DeviceName.Buffer, SaDeviceName[DriverExtension->InitData.DeviceType] );
|
|
|
|
DeviceName.Length = wcslen(DeviceName.Buffer) * sizeof(WCHAR);
|
|
|
|
//
|
|
// Create the device
|
|
//
|
|
|
|
status = IoCreateDeviceSecure(
|
|
DriverObject,
|
|
DeviceExtensionSize,
|
|
&DeviceName,
|
|
FILE_DEVICE_CONTROLLER,
|
|
FILE_DEVICE_SECURE_OPEN,
|
|
FALSE,
|
|
&SDDL_DEVOBJ_SYS_ALL_ADM_ALL,
|
|
NULL,
|
|
&deviceObject
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
ERROR_RETURN( DriverExtension->InitData.DeviceType, "IoCreateDevice", status );
|
|
}
|
|
|
|
DeviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
|
|
RtlZeroMemory( DeviceExtension, DeviceExtensionSize );
|
|
|
|
DeviceExtension->DeviceObject = deviceObject;
|
|
DeviceExtension->DriverObject = DriverObject;
|
|
DeviceExtension->Pdo = PhysicalDeviceObject;
|
|
DeviceExtension->InitData = &DriverExtension->InitData;
|
|
DeviceExtension->DriverExtension = DriverExtension;
|
|
DeviceExtension->DeviceType = DriverExtension->InitData.DeviceType;
|
|
|
|
DeviceExtension->MiniPortDeviceExtension =
|
|
(PUCHAR)DeviceExtension + (DeviceExtensionSize - DriverExtension->InitData.DeviceExtensionSize);
|
|
|
|
*(PULONG)((PUCHAR)DeviceExtension->MiniPortDeviceExtension - sizeof(ULONG)) = DeviceExtensionSize - DriverExtension->InitData.DeviceExtensionSize;
|
|
|
|
IoInitializeRemoveLock( &DeviceExtension->RemoveLock, 0, 0, 0 );
|
|
|
|
switch (DriverExtension->InitData.DeviceType) {
|
|
case SA_DEVICE_DISPLAY:
|
|
((PDISPLAY_DEVICE_EXTENSION)DeviceExtension)->AllowWrites = TRUE;
|
|
ExInitializeFastMutex( &((PDISPLAY_DEVICE_EXTENSION)DeviceExtension)->DisplayMutex );
|
|
DeviceExtension->DeviceExtensionType = DEVICE_EXTENSION_DISPLAY;
|
|
break;
|
|
|
|
case SA_DEVICE_KEYPAD:
|
|
DeviceExtension->DeviceExtensionType = DEVICE_EXTENSION_KEYPAD;
|
|
break;
|
|
|
|
case SA_DEVICE_NVRAM:
|
|
DeviceExtension->DeviceExtensionType = DEVICE_EXTENSION_NVRAM;
|
|
break;
|
|
|
|
case SA_DEVICE_WATCHDOG:
|
|
DeviceExtension->DeviceExtensionType = DEVICE_EXTENSION_WATCHDOG;
|
|
break;
|
|
}
|
|
|
|
DeviceExtension->TargetObject = IoAttachDeviceToDeviceStack( deviceObject, PhysicalDeviceObject );
|
|
if (DeviceExtension->TargetObject == NULL) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "IoAttachDeviceToDeviceStack", status );
|
|
}
|
|
|
|
//
|
|
// Register with the I/O manager for shutdown notification
|
|
//
|
|
|
|
status = IoRegisterShutdownNotification( deviceObject );
|
|
if (!NT_SUCCESS(status)) {
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "IoRegisterShutdownNotification", status );
|
|
}
|
|
|
|
//
|
|
// Set the device object flags
|
|
//
|
|
|
|
deviceObject->Flags |= DO_DIRECT_IO;
|
|
deviceObject->Flags |= DO_POWER_PAGABLE;
|
|
deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
} __finally {
|
|
|
|
//
|
|
// In the failure case un-do everything
|
|
//
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
if (deviceObject) {
|
|
IoDeleteSymbolicLink( &VmLinkName );
|
|
IoDeleteSymbolicLink( &SaLinkName );
|
|
if (DeviceExtension && DeviceExtension->TargetObject) {
|
|
IoDetachDevice( DeviceExtension->TargetObject );
|
|
}
|
|
IoDeleteDevice( deviceObject );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
DECLARE_PNP_HANDLER( DefaultPnpHandler )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the default PNP handler and simply calls the next lower device driver.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the object that represents the device that I/O is to be done on.
|
|
Irp - I/O Request Packet for this request.
|
|
IrpSp - IRP stack location for this request
|
|
DeviceExtension - Device extension
|
|
|
|
Return Value:
|
|
|
|
NT status code.
|
|
|
|
--*/
|
|
|
|
{
|
|
return ForwardRequest( Irp, DeviceExtension->TargetObject );
|
|
}
|
|
|
|
|
|
DECLARE_PNP_HANDLER( HandleStartDevice )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the PNP handler for the IRP_MN_START_DEVICE request.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the object that represents the device that I/O is to be done on.
|
|
Irp - I/O Request Packet for this request.
|
|
IrpSp - IRP stack location for this request
|
|
DeviceExtension - Device extension
|
|
|
|
Return Value:
|
|
|
|
NT status code.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PCM_RESOURCE_LIST ResourceList;
|
|
PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResources;
|
|
PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceInterrupt = NULL;
|
|
ULONG PartialResourceCount;
|
|
ULONG i;
|
|
|
|
|
|
if (DeviceExtension->IsStarted) {
|
|
return ForwardRequest( Irp, DeviceExtension->TargetObject );
|
|
}
|
|
|
|
__try {
|
|
|
|
ResourceList = IrpSp->Parameters.StartDevice.AllocatedResourcesTranslated;
|
|
if (ResourceList == NULL) {
|
|
|
|
Status = DeviceExtension->DriverExtension->InitData.HwInitialize(
|
|
DeviceObject,
|
|
Irp,
|
|
DeviceExtension->MiniPortDeviceExtension,
|
|
NULL,
|
|
0
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "Miniport HwInitialize", Status );
|
|
}
|
|
|
|
} else {
|
|
|
|
PartialResources = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) &ResourceList->List[0].PartialResourceList.PartialDescriptors[0];
|
|
PartialResourceCount = ResourceList->List[0].PartialResourceList.Count;
|
|
|
|
if (ResourceList == NULL || ResourceList->Count != 1) {
|
|
Status = STATUS_UNSUCCESSFUL ;
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "Resource list is empty", Status );
|
|
}
|
|
|
|
if (DeviceExtension->DriverExtension->InitData.InterruptServiceRoutine) {
|
|
|
|
//
|
|
// Find the IRQ resource
|
|
//
|
|
|
|
for (i=0; i<PartialResourceCount; i++) {
|
|
if (PartialResources[i].Type == CmResourceTypeInterrupt) {
|
|
ResourceInterrupt = &PartialResources[i];
|
|
}
|
|
}
|
|
|
|
if (ResourceInterrupt) {
|
|
|
|
//
|
|
// There is an IRQ resource so now use it
|
|
//
|
|
|
|
if (DeviceExtension->DriverExtension->InitData.IsrForDpcRoutine) {
|
|
|
|
//
|
|
// Initialize the DPC routine
|
|
//
|
|
|
|
IoInitializeDpcRequest(
|
|
DeviceExtension->DeviceObject,
|
|
DeviceExtension->DriverExtension->InitData.IsrForDpcRoutine
|
|
);
|
|
}
|
|
|
|
//
|
|
// Connect up the ISR
|
|
//
|
|
|
|
Status = IoConnectInterrupt(
|
|
&DeviceExtension->InterruptObject,
|
|
DeviceExtension->DriverExtension->InitData.InterruptServiceRoutine,
|
|
DeviceExtension->MiniPortDeviceExtension,
|
|
NULL,
|
|
ResourceInterrupt->u.Interrupt.Vector,
|
|
(KIRQL)ResourceInterrupt->u.Interrupt.Level,
|
|
(KIRQL)ResourceInterrupt->u.Interrupt.Level,
|
|
LevelSensitive,
|
|
TRUE,
|
|
ResourceInterrupt->u.Interrupt.Affinity,
|
|
FALSE
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "IoConnectInterrupt", Status );
|
|
}
|
|
}
|
|
}
|
|
|
|
Status = DeviceExtension->DriverExtension->InitData.HwInitialize(
|
|
DeviceObject,
|
|
Irp,
|
|
DeviceExtension->MiniPortDeviceExtension,
|
|
(PCM_PARTIAL_RESOURCE_DESCRIPTOR) &ResourceList->List[0].PartialResourceList.PartialDescriptors[0],
|
|
ResourceList->List[0].PartialResourceList.Count
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "Miniport HwInitialize", Status );
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// We must set this to TRUE temporarity here so that the
|
|
// the device specific start device routine can be called.
|
|
// If the call fails then IsStarted is set to FALSE
|
|
//
|
|
|
|
DeviceExtension->IsStarted = TRUE;
|
|
|
|
switch (DeviceExtension->DriverExtension->InitData.DeviceType) {
|
|
case SA_DEVICE_DISPLAY:
|
|
Status = SaDisplayStartDevice( (PDISPLAY_DEVICE_EXTENSION)DeviceExtension );
|
|
break;
|
|
|
|
case SA_DEVICE_KEYPAD:
|
|
Status = SaKeypadStartDevice( (PKEYPAD_DEVICE_EXTENSION)DeviceExtension );
|
|
break;
|
|
|
|
case SA_DEVICE_NVRAM:
|
|
Status = SaNvramStartDevice( (PNVRAM_DEVICE_EXTENSION)DeviceExtension );
|
|
break;
|
|
|
|
case SA_DEVICE_WATCHDOG:
|
|
Status = SaWatchdogStartDevice( (PWATCHDOG_DEVICE_EXTENSION)DeviceExtension );
|
|
break;
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
DeviceExtension->IsStarted = FALSE;
|
|
ERROR_RETURN( DeviceExtension->DeviceType, "Device specific start device", Status );
|
|
}
|
|
|
|
} __finally {
|
|
|
|
}
|
|
|
|
Irp->IoStatus.Status = Status;
|
|
|
|
return ForwardRequest( Irp, DeviceExtension->TargetObject );
|
|
}
|
|
|
|
|
|
DECLARE_PNP_HANDLER( HandleQueryCapabilities )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the PNP handler for the IRP_MN_QUERY_CAPABILITIES request.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the object that represents the device that I/O is to be done on.
|
|
Irp - I/O Request Packet for this request.
|
|
IrpSp - IRP stack location for this request
|
|
DeviceExtension - Device extension
|
|
|
|
Return Value:
|
|
|
|
NT status code.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PDEVICE_CAPABILITIES Capabilities = IrpSp->Parameters.DeviceCapabilities.Capabilities;
|
|
|
|
|
|
Status = CallLowerDriverAndWait( Irp, DeviceExtension->TargetObject );
|
|
|
|
Capabilities->SilentInstall = 1;
|
|
Capabilities->RawDeviceOK = 1;
|
|
|
|
return CompleteRequest( Irp, Status, Irp->IoStatus.Information );
|
|
}
|
|
|
|
|
|
DECLARE_PNP_HANDLER( HandleQueryDeviceState )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the PNP handler for the IRP_MN_QUERY_PNP_DEVICE_STATE request.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the object that represents the device that I/O is to be done on.
|
|
Irp - I/O Request Packet for this request.
|
|
IrpSp - IRP stack location for this request
|
|
DeviceExtension - Device extension
|
|
|
|
Return Value:
|
|
|
|
NT status code.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
|
|
Status = CallLowerDriverAndWait( Irp, DeviceExtension->TargetObject );
|
|
if (!NT_SUCCESS(Status)) {
|
|
REPORT_ERROR( DeviceExtension->DeviceType, "IRP_MN_QUERY_PNP_DEVICE_STATE", Status );
|
|
Irp->IoStatus.Information = 0;
|
|
}
|
|
|
|
//Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
|
|
#if MAKE_DEVICES_HIDDEN
|
|
Irp->IoStatus.Information |= PNP_DEVICE_DONT_DISPLAY_IN_UI;
|
|
#endif
|
|
|
|
return CompleteRequest( Irp, STATUS_SUCCESS, Irp->IoStatus.Information );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SaPortPnp(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Main PNP irp dispatch routine
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - a pointer to the object that represents the device
|
|
that I/O is to be done on.
|
|
|
|
Irp - a pointer to the I/O Request Packet for this request.
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
|
|
|
|
|
|
DebugPrint(( DeviceExtension->DeviceType, SAPORT_DEBUG_INFO_LEVEL, "PNP - Func [0x%02x %s]\n",
|
|
irpSp->MinorFunction,
|
|
PnPMinorFunctionString(irpSp->MinorFunction)
|
|
));
|
|
|
|
if (DeviceExtension->IsRemoved) {
|
|
return CompleteRequest( Irp, STATUS_DELETE_PENDING, 0 );
|
|
}
|
|
|
|
status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp );
|
|
if (!NT_SUCCESS(status)) {
|
|
REPORT_ERROR( DeviceExtension->DeviceType, "SaPortPnp", status );
|
|
return CompleteRequest( Irp, status, 0 );
|
|
}
|
|
|
|
if (irpSp->MinorFunction >= ARRAY_SZ(PnpDispatchTable)) {
|
|
status = DefaultPnpHandler( DeviceObject, Irp, irpSp, DeviceExtension );
|
|
} else {
|
|
status = (*PnpDispatchTable[irpSp->MinorFunction])( DeviceObject, Irp, irpSp, DeviceExtension );
|
|
}
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
REPORT_ERROR( DeviceExtension->DeviceType, "Pnp handler failed", status );
|
|
}
|
|
|
|
IoReleaseRemoveLock( &DeviceExtension->RemoveLock, Irp );
|
|
|
|
return status;
|
|
}
|