|
|
/***************************************************************************
Copyright (c) 2002 Microsoft Corporation
Module Name:
pnp.C
Abstract:
PnP Routines for Smartcard Driver Utility Library
Environment:
Kernel Mode Only
Notes:
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
Copyright (c) 2001 Microsoft Corporation. All Rights Reserved.
Revision History:
05/14/2002 : created
Authors:
Randy Aull
****************************************************************************/#include "pch.h"
#include "pnp.h"
#include "irplist.h"
#include "scutil.h"
#include "scpriv.h"
PNPSTATESetPnPState( PSCUTIL_EXTENSION pExt, PNPSTATE State ){ PNPSTATE prevState;
prevState = pExt->PrevState; pExt->PrevState = pExt->PnPState; pExt->PnPState = State;
return prevState;}
NTSTATUSScUtilDefaultPnpHandler( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Passes IRP_MJ_PNP to next lower driver
Arguments:
Return Value:
--*/{
PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); NTSTATUS status = STATUS_SUCCESS;
__try { SmartcardDebug( DEBUG_TRACE, ("ScUtilDefaultPnpHandler Enter\n"));
IoSkipCurrentIrpStackLocation(Irp); ASSERT(pExt->LowerDeviceObject); status = IoCallDriver(pExt->LowerDeviceObject, Irp);
}
__finally { SmartcardDebug( DEBUG_TRACE, ("ScUtilDefaultPnpHandler Exit : 0x%x\n",status ));
}
return status;
}
NTSTATUSScUtil_PnP( PDEVICE_OBJECT DeviceObject, PIRP Irp ){ NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); PIO_STACK_LOCATION irpStack; BOOLEAN deviceRemoved = FALSE;
PSMARTCARD_EXTENSION smartcardExtension = pExt->SmartcardExtension;
ASSERT(pExt);
PAGED_CODE();
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_PnP\n")); status = IoAcquireRemoveLock(pExt->RemoveLock, Irp);
if (!NT_SUCCESS(status)) {
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); __leave;
}
irpStack = IoGetCurrentIrpStackLocation(Irp);
switch (irpStack->MinorFunction) { case IRP_MN_START_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_START_DEVICE \n"));
SetPnPState(pExt, DEVICE_STATE_STARTING);
status = ScUtil_ForwardAndWait(DeviceObject, Irp); if (NT_SUCCESS(status)) { status = ScUtilStartDevice(DeviceObject, Irp); }
break;
case IRP_MN_QUERY_REMOVE_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_QUERY_REMOVE_DEVICE\n"));
status = ScUtilQueryRemoveDevice(DeviceObject, Irp);
if (!NT_SUCCESS(status)) {
break; }
Irp->IoStatus.Status = STATUS_SUCCESS; status = ScUtilDefaultPnpHandler(DeviceObject, Irp); __leave; case IRP_MN_REMOVE_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_REMOVE_DEVICE\n"));
status = ScUtilRemoveDevice(DeviceObject, Irp);
if (NT_SUCCESS(status)) {
deviceRemoved = TRUE;
__leave;
} break;
case IRP_MN_SURPRISE_REMOVAL: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_SUPRISE_REMOVE\n"));
status = ScUtilSurpriseRemoval(DeviceObject, Irp);
if (!NT_SUCCESS(status)) {
break;
}
Irp->IoStatus.Status = STATUS_SUCCESS; status = ScUtilDefaultPnpHandler(DeviceObject, Irp); __leave;
case IRP_MN_CANCEL_REMOVE_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_CANCEL_REMOVE_DEVICE\n"));
status = ScUtil_ForwardAndWait(DeviceObject, Irp); if (NT_SUCCESS(status)) { status = ScUtilCancelRemoveDevice(DeviceObject, Irp);
} break;
case IRP_MN_STOP_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_STOP_DEVICE\n")); status = ScUtilStopDevice(DeviceObject, Irp); if (NT_SUCCESS(status)) {
Irp->IoStatus.Status = STATUS_SUCCESS; status = ScUtilDefaultPnpHandler(DeviceObject, Irp); __leave;
}
break;
case IRP_MN_QUERY_STOP_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_QUERY_STOP_DEVICE\n"));
status = ScUtilQueryStopDevice(DeviceObject, Irp);
if (!NT_SUCCESS(status)) { break; } Irp->IoStatus.Status = STATUS_SUCCESS; status = ScUtilDefaultPnpHandler(DeviceObject, Irp);
__leave; // We don't need to complete this so just skip it.
case IRP_MN_CANCEL_STOP_DEVICE: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_CANCEL_STOP_DEVICE\n"));
// Lower drivers must handle this irp first
status = ScUtil_ForwardAndWait(DeviceObject, Irp);
if (NT_SUCCESS(status)) {
status = ScUtilCancelStopDevice(DeviceObject, Irp);
} break;
case IRP_MN_QUERY_CAPABILITIES: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_QUERY_CAPABILITIES\n"));
status = ScUtil_ForwardAndWait(DeviceObject, Irp); if (NT_SUCCESS(status)) {
pExt->DeviceCapabilities = *irpStack->Parameters.DeviceCapabilities.Capabilities;
}
break;
default: SmartcardDebug( DEBUG_DRIVER, ("ScUtil_PnP: IRP_MN_...%lx\n", irpStack->MinorFunction ));
status = ScUtilDefaultPnpHandler(DeviceObject, Irp); __leave; // We don't need to complete this so just skip it.
}
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
__finally {
if (deviceRemoved == FALSE) {
IoReleaseRemoveLock(pExt->RemoveLock, Irp); }
SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_PnP (0x%x)\n", status)); }
return status;
}
NTSTATUSScUtilStartDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Handles the IRP_MN_START_DEVICE Gets the usb descriptors from the reader and configures it. Also starts "polling" the interrupt pipe
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); __try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilStartDevice Enter\n" ));
status = pExt->StartDevice(DeviceObject, Irp);
if (!NT_SUCCESS(status)) { SetPnPState(pExt, DEVICE_STATE_START_FAILURE); __leave; } SetPnPState(pExt, DEVICE_STATE_START_SUCCESS);
StartIoctls(pExt); IncIoCount(pExt);
status = IoSetDeviceInterfaceState(&pExt->DeviceName, TRUE);
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilStartDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilStopDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Handles IRP_MN_STOP_DEVICE Stops "polling" the interrupt pipe and frees resources allocated in StartDevice
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilStopDevice Enter\n" ));
if (!DeviceObject) { __leave; }
pExt->StopDevice(DeviceObject, Irp);
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilStopDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilQueryRemoveDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Handles IRP_MN_QUERY_REMOVE Disables the reader and prepares it for the IRP_MN_REMOVE
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_SUCCESS; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilQueryRemoveDevice Enter\n" ));
// check if the reader has been opened
if (pExt->ReaderOpen) { status = STATUS_UNSUCCESSFUL; __leave;
}
SetPnPState(pExt, DEVICE_STATE_REMOVING);
StopIoctls(pExt); }
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilQueryRemoveDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilCancelRemoveDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: handles IRP_MN_CANCEL_REMOVE undoes actions in QueryRemove
Arguments:
Return Value: STATUS_SUCCESS
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilCancelRemoveDevice Enter\n" ));
if (pExt->PnPState != DEVICE_STATE_REMOVING) { status = STATUS_SUCCESS; __leave; }
if (pExt->PrevState == DEVICE_STATE_START_SUCCESS) {
StartIoctls(pExt); }
SetPnPState(pExt, pExt->PrevState);
status = STATUS_SUCCESS;
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilCancelRemoveDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilRemoveDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: handles IRP_MN_REMOVE_DEVICE stops and unloads the device.
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); __try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilRemoveDevice Enter\n" ));
if (pExt->PnPState != DEVICE_STATE_SUPRISE_REMOVING) {
FailIoctls(pExt);
status = IoSetDeviceInterfaceState(&pExt->DeviceName, FALSE);
if (pExt->FreeResources) { pExt->FreeResources(DeviceObject, Irp); } }
IoReleaseRemoveLockAndWait(pExt->RemoveLock, Irp);
SetPnPState(pExt, DEVICE_STATE_REMOVED);
Irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation (Irp); status = IoCallDriver (pExt->LowerDeviceObject, Irp);
pExt->RemoveDevice(DeviceObject, Irp);
// delete the symbolic link
if( pExt->DeviceName.Buffer != NULL ) {
RtlFreeUnicodeString(&pExt->DeviceName); pExt->DeviceName.Buffer = NULL;
}
if( pExt->SmartcardExtension->OsData != NULL ) {
SmartcardExit(pExt->SmartcardExtension);
}
if (pExt->SmartcardExtension->ReaderExtension != NULL) {
ExFreePool(pExt->SmartcardExtension->ReaderExtension); pExt->SmartcardExtension->ReaderExtension = NULL;
}
// Detach from the usb driver
if (pExt->LowerDeviceObject) {
IoDetachDevice(pExt->LowerDeviceObject); pExt->LowerDeviceObject = NULL;
}
ExFreePool(pExt);
// delete the device object
IoDeleteDevice(DeviceObject); }
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilRemoveDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilSurpriseRemoval( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: handles IRP_MN_SUPRISE_REMOVE Does the same as QueryRemove Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilSurpriseRemoval Enter\n" )); FailIoctls(pExt); SetPnPState(pExt, DEVICE_STATE_REMOVING); status = IoSetDeviceInterfaceState(&pExt->DeviceName, FALSE);
if (pExt->FreeResources) { pExt->FreeResources(DeviceObject, Irp); }
status = STATUS_SUCCESS;
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilSurpriseRemoval Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilQueryStopDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: handles IRP_MN_QUERY_STOP Stops interrupt "polling" and waits for I/O to complete
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilQueryStopDevice Enter\n"));
if (!NT_SUCCESS(status)) {
__leave;
}
SetPnPState(pExt, DEVICE_STATE_STOPPING);
StopIoctls(pExt); DecIoCount(pExt);
// Wait for all IO to complete before stopping
status = KeWaitForSingleObject(&pExt->OkToStop, Executive, KernelMode, FALSE, NULL);
if (!NT_SUCCESS(status)) {
__leave;
} }
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilQueryStopDevice Exit : 0x%x\n", status ));
}
return status;
}
NTSTATUSScUtilCancelStopDevice( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Restarts Interrupt polling
Arguments:
Return Value:
--*/{
NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension);
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilCancelStopDevice Enter\n"));
SetPnPState(pExt, pExt->PrevState);
IncIoCount(pExt);
StartIoctls(pExt); status = STATUS_SUCCESS;
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilCancelStopDevice Exit : 0x%x\n", status ));
}
return status;
}
|
