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.
620 lines
17 KiB
620 lines
17 KiB
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
pnp.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the code for a serial imaging devices driver
|
|
supporting PnP functionality
|
|
|
|
Author:
|
|
|
|
Vlad Sadovsky vlads 10-April-1998
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History :
|
|
|
|
vlads 04/10/1998 Created first draft
|
|
|
|
--*/
|
|
|
|
#include "serscan.h"
|
|
#include "serlog.h"
|
|
|
|
//#include <ntpoapi.h>
|
|
|
|
extern ULONG SerScanDebugLevel;
|
|
|
|
extern const PHYSICAL_ADDRESS PhysicalZero ;
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, SerScanPnp)
|
|
#pragma alloc_text(PAGE, SerScanPower)
|
|
#endif
|
|
|
|
NTSTATUS
|
|
SerScanPnp (
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles all PNP IRPs, dispatching them as appropriate .
|
|
|
|
Arguments:
|
|
|
|
pDeviceObject - represents a device
|
|
|
|
pIrp - PNP Irp
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS - if successful.
|
|
STATUS_UNSUCCESSFUL - otherwise.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status ;
|
|
PDEVICE_EXTENSION Extension;
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PVOID pObject;
|
|
ULONG NewReferenceCount;
|
|
NTSTATUS ReturnStatus;
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation( pIrp );
|
|
|
|
Extension = pDeviceObject->DeviceExtension;
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
DebugDump(SERINITDEV,("Entering PnP Dispatcher\n"));
|
|
|
|
switch (pIrpStack->MinorFunction) {
|
|
|
|
case IRP_MN_START_DEVICE:
|
|
|
|
//
|
|
// Initialize PendingIoEvent. Set the number of pending i/o requests for this device to 1.
|
|
// When this number falls to zero, it is okay to remove, or stop the device.
|
|
//
|
|
|
|
DebugDump(SERINITDEV,("Entering Start Device \n"));
|
|
|
|
KeInitializeEvent(&Extension -> PdoStartEvent, SynchronizationEvent, FALSE);
|
|
|
|
IoCopyCurrentIrpStackLocationToNext(pIrp);
|
|
|
|
Status = WaitForLowerDriverToCompleteIrp(
|
|
Extension->LowerDevice,
|
|
pIrp,
|
|
&Extension->PdoStartEvent);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
pIrp->IoStatus.Status = Status;
|
|
pIrp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return (Status);
|
|
|
|
}
|
|
|
|
#ifdef CREATE_SYMBOLIC_NAME
|
|
|
|
//
|
|
// Now setup the symbolic link for windows.
|
|
//
|
|
|
|
Status = IoCreateUnprotectedSymbolicLink(&Extension->SymbolicLinkName, &Extension->ClassName);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
// We were able to create the symbolic link, so record this
|
|
// value in the extension for cleanup at unload time.
|
|
|
|
Extension->CreatedSymbolicLink = TRUE;
|
|
|
|
// Write out the result of the symbolic link to the registry.
|
|
|
|
Status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP,
|
|
L"Serial Scanners",
|
|
Extension->ClassName.Buffer,
|
|
REG_SZ,
|
|
Extension->SymbolicLinkName.Buffer,
|
|
Extension->SymbolicLinkName.Length + sizeof(WCHAR));
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// It didn't work. Just go to cleanup.
|
|
//
|
|
|
|
DebugDump(SERERRORS,
|
|
("SerScan: Couldn't create the device map entry\n"
|
|
"-------- for port %wZ\n",
|
|
&Extension->ClassName));
|
|
|
|
SerScanLogError(pDeviceObject->DriverObject,
|
|
pDeviceObject,
|
|
PhysicalZero,
|
|
PhysicalZero,
|
|
0,
|
|
0,
|
|
0,
|
|
6,
|
|
Status,
|
|
SER_NO_DEVICE_MAP_CREATED);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Couldn't create the symbolic link.
|
|
//
|
|
|
|
Extension->CreatedSymbolicLink = FALSE;
|
|
|
|
ExFreePool(Extension->SymbolicLinkName.Buffer);
|
|
Extension->SymbolicLinkName.Buffer = NULL;
|
|
|
|
DebugDump(SERERRORS,
|
|
("SerScan: Couldn't create the symbolic link\n"
|
|
"-------- for port %wZ\n",
|
|
&Extension->ClassName));
|
|
|
|
SerScanLogError(pDeviceObject->DriverObject,
|
|
pDeviceObject,
|
|
PhysicalZero,
|
|
PhysicalZero,
|
|
0,
|
|
0,
|
|
0,
|
|
5,
|
|
Status,
|
|
SER_NO_SYMLINK_CREATED);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
ExFreePool(Extension->ClassName.Buffer);
|
|
Extension->ClassName.Buffer = NULL;
|
|
|
|
//
|
|
// Ignore status of link registry write - always succeed
|
|
//
|
|
|
|
//
|
|
// Clear InInit flag to indicate device object can be used
|
|
//
|
|
pDeviceObject->Flags &= ~(DO_DEVICE_INITIALIZING);
|
|
|
|
pIrp->IoStatus.Status = Status;
|
|
pIrp->IoStatus.Information = 0;
|
|
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return (Status);
|
|
|
|
break;
|
|
|
|
case IRP_MN_QUERY_REMOVE_DEVICE:
|
|
//
|
|
// Always pass to lower device in stack after indicating that we don't object
|
|
//
|
|
DebugDump(SERALWAYS,("IRP_MN_QUERY_REMOVE_DEVICE\n"));
|
|
|
|
Extension->Removing = TRUE;
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
|
|
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
|
//
|
|
// Always pass to lower device in stack , reset indicator as somebody canceled
|
|
//
|
|
DebugDump(SERALWAYS,("IRP_MN_CANCEL_REMOVE_DEVICE\n"));
|
|
|
|
Extension->Removing = FALSE;
|
|
|
|
//
|
|
// Kill symbolic link
|
|
//
|
|
if (Extension->CreatedSymbolicLink) {
|
|
IoDeleteSymbolicLink(&Extension->SymbolicLinkName);
|
|
Extension->CreatedSymbolicLink = FALSE;
|
|
}
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
|
|
|
|
case IRP_MN_SURPRISE_REMOVAL:
|
|
//
|
|
// Should not ever happen with us, but still process
|
|
//
|
|
|
|
DebugDump(SERALWAYS,("IRP_MN_SURPRISE_REMOVAL\n"));
|
|
|
|
Extension->Removing = TRUE;
|
|
|
|
//
|
|
// Get rid of the symbolic link
|
|
//
|
|
SerScanHandleSymbolicLink(
|
|
Extension->Pdo,
|
|
&Extension->InterfaceNameString,
|
|
FALSE
|
|
);
|
|
|
|
#ifdef USE_EXECUTIVE_RESOURCE
|
|
ExAcquireResourceExclusiveLite(
|
|
&Extension->Resource,
|
|
TRUE
|
|
);
|
|
#else
|
|
ExAcquireFastMutex(&Extension->Mutex);
|
|
#endif
|
|
|
|
pObject = InterlockedExchangePointer(&Extension->AttachedFileObject,NULL);
|
|
if (pObject) {
|
|
ObDereferenceObject(pObject);
|
|
}
|
|
|
|
pObject = InterlockedExchangePointer(&Extension->AttachedDeviceObject,NULL);
|
|
if (pObject) {
|
|
ObDereferenceObject(pObject);
|
|
}
|
|
|
|
#ifdef USE_EXECUTIVE_RESOURCE
|
|
ExReleaseResourceLite(&Extension->Resource);
|
|
#else
|
|
ExReleaseFastMutex(&Extension->Mutex);
|
|
#endif
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
|
|
break;
|
|
|
|
case IRP_MN_REMOVE_DEVICE:
|
|
|
|
DebugDump(SERALWAYS,("IRP_MN_REMOVE_DEVICE\n"));
|
|
|
|
DebugDump(SERINITDEV,("Entering PnP Remove Device\n"));
|
|
|
|
|
|
//
|
|
// Stop new requests - device is being removed
|
|
//
|
|
Extension->Removing = TRUE;
|
|
|
|
//
|
|
// Get rid of the symbolic link
|
|
//
|
|
SerScanHandleSymbolicLink(
|
|
Extension->Pdo,
|
|
&Extension->InterfaceNameString,
|
|
FALSE
|
|
);
|
|
|
|
|
|
#ifdef USE_EXECUTIVE_RESOURCE
|
|
ExAcquireResourceExclusiveLite(
|
|
&Extension->Resource,
|
|
TRUE
|
|
);
|
|
#else
|
|
ExAcquireFastMutex(&Extension->Mutex);
|
|
#endif
|
|
|
|
pObject = InterlockedExchangePointer(&Extension->AttachedFileObject,NULL);
|
|
if (pObject) {
|
|
ObDereferenceObject(pObject);
|
|
}
|
|
|
|
pObject = InterlockedExchangePointer(&Extension->AttachedDeviceObject,NULL);
|
|
if (pObject) {
|
|
ObDereferenceObject(pObject);
|
|
}
|
|
|
|
#ifdef USE_EXECUTIVE_RESOURCE
|
|
ExReleaseResourceLite(&Extension->Resource);
|
|
#else
|
|
ExReleaseFastMutex(&Extension->Mutex);
|
|
#endif
|
|
|
|
//
|
|
// Send IRP down to lower device
|
|
//
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
ReturnStatus = IoCallDriver(Extension->LowerDevice, pIrp);
|
|
|
|
//
|
|
// Decrement ref count
|
|
//
|
|
NewReferenceCount = InterlockedDecrement(&Extension->ReferenceCount);
|
|
|
|
if (NewReferenceCount != 0) {
|
|
//
|
|
// Wait for any io requests pending in our driver to
|
|
// complete before finishing the remove
|
|
//
|
|
KeWaitForSingleObject(&Extension -> RemoveEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
// ASSERT(&Extension->ReferenceCount == 0);
|
|
#ifdef USE_EXECUTIVE_RESOURCE
|
|
ExDeleteResourceLite(&Extension->Resource);
|
|
#endif
|
|
|
|
DebugDump(SERALWAYS,("IRP_MN_QUERY_REMOVE_DEVICE - Calling IoDeleteDevice - gone\n"));
|
|
|
|
IoDetachDevice(Extension->LowerDevice);
|
|
|
|
//
|
|
// Free allocated resource.
|
|
//
|
|
|
|
if(NULL != Extension->ClassName.Buffer){
|
|
ExFreePool(Extension->ClassName.Buffer);
|
|
} // if(NULL != Extension->ClassName.Buffer)
|
|
|
|
if(NULL != Extension->SymbolicLinkName.Buffer){
|
|
ExFreePool(Extension->SymbolicLinkName.Buffer);
|
|
} // if(NULL != Extension->SymbolicLinkName.Buffer)
|
|
|
|
IoDeleteDevice(pDeviceObject);
|
|
|
|
return ReturnStatus;
|
|
|
|
break;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
//
|
|
// Pass down
|
|
//
|
|
DebugDump(SERALWAYS,("IRP_MN_STOP_DEVICE\n"));
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
|
|
case IRP_MN_QUERY_STOP_DEVICE:
|
|
//
|
|
// Check open counts
|
|
//
|
|
DebugDump(SERALWAYS,("IRP_MN_QUERY_STOP_DEVICE\n"));
|
|
|
|
if (Extension->OpenCount > 0 ) {
|
|
DebugDump(SERALWAYS,("Rejecting QUERY_STOP_DEVICE\n"));
|
|
|
|
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
|
|
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
|
|
|
|
case IRP_MN_CANCEL_STOP_DEVICE:
|
|
//
|
|
// Nothing to do here, but pass to lower
|
|
//
|
|
DebugDump(SERALWAYS,("IRP_MN_CANCEL_STOP_DEVICE\n"));
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
|
|
|
|
case IRP_MN_QUERY_CAPABILITIES:
|
|
{
|
|
|
|
ULONG i;
|
|
KEVENT WaitEvent;
|
|
|
|
//
|
|
// Send this down to the PDO first
|
|
//
|
|
|
|
KeInitializeEvent(&WaitEvent, SynchronizationEvent, FALSE);
|
|
|
|
IoCopyCurrentIrpStackLocationToNext(pIrp);
|
|
|
|
Status=WaitForLowerDriverToCompleteIrp(
|
|
Extension->LowerDevice,
|
|
pIrp,
|
|
&WaitEvent
|
|
);
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
|
|
for (i = PowerSystemUnspecified; i < PowerSystemMaximum; i++) {
|
|
|
|
Extension->SystemPowerStateMap[i]=PowerDeviceD3;
|
|
}
|
|
|
|
for (i = PowerSystemUnspecified; i < PowerSystemHibernate; i++) {
|
|
|
|
Extension->SystemPowerStateMap[i]=pIrpStack->Parameters.DeviceCapabilities.Capabilities->DeviceState[i];
|
|
}
|
|
|
|
Extension->SystemPowerStateMap[PowerSystemWorking]=PowerDeviceD0;
|
|
|
|
Extension->SystemWake=pIrpStack->Parameters.DeviceCapabilities.Capabilities->SystemWake;
|
|
Extension->DeviceWake=pIrpStack->Parameters.DeviceCapabilities.Capabilities->DeviceWake;
|
|
|
|
IoCompleteRequest(
|
|
pIrp,
|
|
IO_NO_INCREMENT
|
|
);
|
|
return Status;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Unknown function - pass down
|
|
//
|
|
DebugDump(SERALWAYS,("Passing Pnp Irp down. MnFunc=%x , status = %x\n",pIrpStack->MinorFunction, Status));
|
|
|
|
IoCopyCurrentIrpStackLocationToNext( pIrp );
|
|
return (IoCallDriver(Extension->LowerDevice, pIrp));
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Complete the IRP...
|
|
//
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
pIrp -> IoStatus.Status = Status;
|
|
pIrp->IoStatus.Information = 0;
|
|
IoCompleteRequest( pIrp, IO_NO_INCREMENT );
|
|
}
|
|
else {
|
|
|
|
DebugDump(SERALWAYS,("Passing Pnp Irp down, status = %x\n", Status));
|
|
|
|
IoCopyCurrentIrpStackLocationToNext(pIrp);
|
|
Status = IoCallDriver(Extension->LowerDevice, pIrp);
|
|
}
|
|
|
|
return( Status );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DevicePowerCompleteRoutine(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PVOID Context,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
)
|
|
{
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SerScanPower(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process the Power IRPs sent to the PDO for this device.
|
|
|
|
Arguments:
|
|
|
|
pDeviceObject - pointer to the functional device object (FDO) for this device.
|
|
pIrp - pointer to an I/O Request Packet
|
|
|
|
Return Value:
|
|
|
|
NT status code
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PDEVICE_EXTENSION Extension = pDeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
POWER_STATE PowerState;
|
|
|
|
PAGED_CODE();
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
switch (pIrpStack->MinorFunction) {
|
|
|
|
case IRP_MN_SET_POWER:
|
|
|
|
if (pIrpStack->Parameters.Power.Type == SystemPowerState) {
|
|
//
|
|
// system power state change
|
|
//
|
|
//
|
|
// request the change in device power state based on systemstate map
|
|
//
|
|
PowerState.DeviceState=Extension->SystemPowerStateMap[pIrpStack->Parameters.Power.State.SystemState];
|
|
|
|
PoRequestPowerIrp(
|
|
Extension->Pdo,
|
|
IRP_MN_SET_POWER,
|
|
PowerState,
|
|
DevicePowerCompleteRoutine,
|
|
pIrp,
|
|
NULL
|
|
);
|
|
|
|
|
|
} else {
|
|
//
|
|
// changing device state
|
|
//
|
|
PoSetPowerState(
|
|
Extension->Pdo,
|
|
pIrpStack->Parameters.Power.Type,
|
|
pIrpStack->Parameters.Power.State
|
|
);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IRP_MN_QUERY_POWER:
|
|
|
|
pIrp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
PoStartNextPowerIrp(pIrp);
|
|
|
|
IoSkipCurrentIrpStackLocation(pIrp);
|
|
|
|
Status=PoCallDriver(Extension->LowerDevice, pIrp);
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
|