able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/smartcrd/cmbp0/cmbp0wdm.c

1669 lines
54 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************
@doc INT EXT
******************************************************************************
* $ProjectName: $
* $ProjectRevision: $
*-----------------------------------------------------------------------------
* $Source: z:/pr/cmbp0/sw/cmbp0.ms/rcs/cmbp0wdm.c $
* $Revision: 1.11 $
*-----------------------------------------------------------------------------
* $Author: WFrischauf $
*-----------------------------------------------------------------------------
* History: see EOF
*-----------------------------------------------------------------------------
*
* Copyright <EFBFBD> 2000 OMNIKEY AG
******************************************************************************/
#include <cmbp0wdm.h>
#ifdef NT4
#include <cmbp0nt4.h>
#else
#include <cmbp0pnp.h>
#endif
#include <cmbp0scr.h>
#include <cmbp0log.h>
BOOLEAN DeviceSlot[CMMOB_MAX_DEVICE];
// this is a list of our supported data rates
ULONG SupportedDataRates[] = { 9600, 19200, 38400, 76800, 115200,
153600, 192000, 307200};
// this is a list of our supported clock frequencies
ULONG SupportedCLKFrequencies[] = { 4000, 8000};
/*****************************************************************************
DriverEntry:
entry function of the driver. setup the callbacks for the OS and try to
initialize a device object for every device in the system
Arguments:
DriverObject context of the driver
RegistryPath path to the registry entry for the driver
Return Value:
STATUS_SUCCESS
STATUS_UNSUCCESSFUL
******************************************************************************/
NTSTATUS DriverEntry(
PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath
)
{
NTSTATUS NTStatus = STATUS_SUCCESS;
ULONG ulDevice;
//#if DBG
// SmartcardSetDebugLevel(DEBUG_ALL);
//#endif
SmartcardDebug(DEBUG_TRACE,
("%s!DriverEntry: Enter - %s %s\n",DRIVER_NAME,__DATE__,__TIME__));
//
// tell the system our entry points
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = CMMOB_CreateClose;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = CMMOB_CreateClose;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = CMMOB_DeviceIoControl;
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = CMMOB_SystemControl;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = CMMOB_Cleanup;
DriverObject->DriverUnload = CMMOB_UnloadDriver;
#ifndef NT4
DriverObject->MajorFunction[IRP_MJ_PNP] = CMMOB_PnPDeviceControl;
DriverObject->MajorFunction[IRP_MJ_POWER] = CMMOB_PowerDeviceControl;
DriverObject->DriverExtension->AddDevice = CMMOB_AddDevice;
SmartcardDebug(DEBUG_TRACE,
("%s!DriverEntry: PnP Version\n",DRIVER_NAME));
#else
//
// try to initialize all devices
//
for (ulDevice = 0; ulDevice < CMMOB_MAX_DEVICE; ulDevice++)
{
//
// create and start all connected devices
//
if (CMMOB_CreateAndStartDevice(DriverObject) != STATUS_SUCCESS)
{
break;
}
}
//
// report a failure if no device was found
//
if (DriverObject->DeviceObject == NULL)
{
NTStatus = STATUS_UNSUCCESSFUL;
SmartcardLogError(DriverObject,
CMMOB_NO_DEVICE_FOUND,
NULL,
0);
}
#endif
SmartcardDebug(DEBUG_TRACE,
("%s!DriverEntry: Exit %x\n",DRIVER_NAME,NTStatus));
return NTStatus;
}
/*****************************************************************************
Routine Description:
Trys to read the reader name from the registry
Arguments:
DriverObject context of call
SmartcardExtension ptr to smartcard extension
Return Value:
none
******************************************************************************/
VOID CMMOB_SetVendorAndIfdName(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PSMARTCARD_EXTENSION SmartcardExtension
)
{
RTL_QUERY_REGISTRY_TABLE parameters[3];
UNICODE_STRING vendorNameU;
ANSI_STRING vendorNameA;
UNICODE_STRING ifdTypeU;
ANSI_STRING ifdTypeA;
HANDLE regKey = NULL;
RtlZeroMemory (parameters, sizeof(parameters));
RtlZeroMemory (&vendorNameU, sizeof(vendorNameU));
RtlZeroMemory (&vendorNameA, sizeof(vendorNameA));
RtlZeroMemory (&ifdTypeU, sizeof(ifdTypeU));
RtlZeroMemory (&ifdTypeA, sizeof(ifdTypeA));
try
{
//
// try to read the reader name from the registry
// if that does not work, we will use the default
// (hardcoded) name
//
if (IoOpenDeviceRegistryKey(PhysicalDeviceObject,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
&regKey) != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,
("%s!SetVendorAndIfdName: IoOpenDeviceRegistryKey failed\n",DRIVER_NAME));
leave;
}
parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
parameters[0].Name = L"VendorName";
parameters[0].EntryContext = &vendorNameU;
parameters[0].DefaultType = REG_SZ;
parameters[0].DefaultData = &vendorNameU;
parameters[0].DefaultLength = 0;
parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
parameters[1].Name = L"IfdType";
parameters[1].EntryContext = &ifdTypeU;
parameters[1].DefaultType = REG_SZ;
parameters[1].DefaultData = &ifdTypeU;
parameters[1].DefaultLength = 0;
if (RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
(PWSTR) regKey,
parameters,
NULL,
NULL) != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,
("%s!SetVendorAndIfdName: RtlQueryRegistryValues failed\n",DRIVER_NAME));
leave;
}
if (RtlUnicodeStringToAnsiString(&vendorNameA,&vendorNameU,TRUE) != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,
("%s!SetVendorAndIfdName: RtlUnicodeStringToAnsiString failed\n",DRIVER_NAME));
leave;
}
if (RtlUnicodeStringToAnsiString(&ifdTypeA,&ifdTypeU,TRUE) != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,
("%s!SetVendorAndIfdName: RtlUnicodeStringToAnsiString failed\n",DRIVER_NAME));
leave;
}
if (vendorNameA.Length == 0 ||
vendorNameA.Length > MAXIMUM_ATTR_STRING_LENGTH ||
ifdTypeA.Length == 0 ||
ifdTypeA.Length > MAXIMUM_ATTR_STRING_LENGTH)
{
SmartcardDebug(DEBUG_ERROR,
("%s!SetVendorAndIfdName: vendor name or ifdtype not found or to long\n",DRIVER_NAME));
leave;
}
RtlCopyMemory(SmartcardExtension->VendorAttr.VendorName.Buffer,
vendorNameA.Buffer,
vendorNameA.Length);
SmartcardExtension->VendorAttr.VendorName.Length = vendorNameA.Length;
RtlCopyMemory(SmartcardExtension->VendorAttr.IfdType.Buffer,
ifdTypeA.Buffer,
ifdTypeA.Length);
SmartcardExtension->VendorAttr.IfdType.Length = ifdTypeA.Length;
SmartcardDebug(DEBUG_DRIVER,
("%s!SetVendorAndIfdName: overwritting vendor name and ifdtype\n",DRIVER_NAME));
}
finally
{
if (vendorNameU.Buffer != NULL)
{
RtlFreeUnicodeString(&vendorNameU);
}
if (vendorNameA.Buffer != NULL)
{
RtlFreeAnsiString(&vendorNameA);
}
if (ifdTypeU.Buffer != NULL)
{
RtlFreeUnicodeString(&ifdTypeU);
}
if (ifdTypeA.Buffer != NULL)
{
RtlFreeAnsiString(&ifdTypeA);
}
if (regKey != NULL)
{
ZwClose (regKey);
}
}
}
/*****************************************************************************
Routine Description:
creates a new device object for the driver, allocates & initializes all
neccessary structures (i.e. SmartcardExtension & ReaderExtension).
Arguments:
DriverObject context of call
DeviceObject ptr to the created device object
Return Value:
STATUS_SUCCESS
STATUS_INSUFFICIENT_RESOURCES
NTStatus returned by smclib.sys
******************************************************************************/
NTSTATUS CMMOB_CreateDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject,
OUT PDEVICE_OBJECT *DeviceObject
)
{
NTSTATUS NTStatus = STATUS_SUCCESS;
NTSTATUS RegStatus;
RTL_QUERY_REGISTRY_TABLE ParamTable[2];
UNICODE_STRING RegistryPath;
UNICODE_STRING RegistryValue;
WCHAR szRegValue[256];
UNICODE_STRING DeviceName;
UNICODE_STRING Tmp;
WCHAR Buffer[64];
SmartcardDebug(DEBUG_TRACE,
( "%s!CreateDevice: Enter\n",DRIVER_NAME ));
try
{
ULONG ulDeviceInstance;
PDEVICE_EXTENSION DeviceExtension;
PREADER_EXTENSION ReaderExtension;
PSMARTCARD_EXTENSION SmartcardExtension;
*DeviceObject = NULL;
for (ulDeviceInstance = 0; ulDeviceInstance < CMMOB_MAX_DEVICE; ulDeviceInstance++)
{
if (DeviceSlot[ulDeviceInstance] == FALSE)
{
DeviceSlot[ulDeviceInstance] = TRUE;
break;
}
}
if (ulDeviceInstance == CMMOB_MAX_DEVICE)
{
NTStatus = STATUS_INSUFFICIENT_RESOURCES;
leave;
}
//
// construct the device name
//
DeviceName.Buffer = Buffer;
DeviceName.MaximumLength = sizeof(Buffer);
DeviceName.Length = 0;
RtlInitUnicodeString(&Tmp,CARDMAN_MOBILE_DEVICE_NAME);
RtlCopyUnicodeString(&DeviceName,&Tmp);
DeviceName.Buffer[(DeviceName.Length)/sizeof(WCHAR)-1] = L'0' + (WCHAR)ulDeviceInstance;
//
// Create the device object
//
NTStatus = IoCreateDevice(DriverObject,
sizeof(DEVICE_EXTENSION),
&DeviceName,
FILE_DEVICE_SMARTCARD,
0,
TRUE,
DeviceObject);
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DriverObject,
CMMOB_INSUFFICIENT_RESOURCES,
NULL,
0);
leave;
}
//
// tell the OS that we supposed to do buffered io
//
(*DeviceObject)->Flags |= DO_BUFFERED_IO;
#ifndef NT4
// this is necessary, that power routine is called at IRQL_PASSIVE
(*DeviceObject)->Flags |= DO_POWER_PAGABLE;
// tells the IO Manager initialization is done
(*DeviceObject)->Flags &= ~DO_DEVICE_INITIALIZING;
#endif
//
// set up the device extension.
//
DeviceExtension = (*DeviceObject)->DeviceExtension;
RtlZeroMemory( DeviceExtension, sizeof( DEVICE_EXTENSION ));
SmartcardExtension = &DeviceExtension->SmartcardExtension;
// used for synchronise access to lIoCount
KeInitializeSpinLock(&DeviceExtension->SpinLockIoCount);
// Used for stop / start notification
KeInitializeEvent(&DeviceExtension->ReaderStarted,
NotificationEvent,
FALSE);
// Used for update thread notification after hibernation
KeInitializeEvent(&DeviceExtension->CanRunUpdateThread,
NotificationEvent,
TRUE);
//
// allocate the reader extension
//
ReaderExtension = ExAllocatePool(NonPagedPool,sizeof( READER_EXTENSION ));
if (ReaderExtension == NULL)
{
SmartcardLogError(DriverObject,
CMMOB_INSUFFICIENT_RESOURCES,
NULL,
0);
NTStatus = STATUS_INSUFFICIENT_RESOURCES;
leave;
}
RtlZeroMemory( ReaderExtension, sizeof( READER_EXTENSION ));
SmartcardExtension->ReaderExtension = ReaderExtension;
// ----------------------------------------------
// initialize mutex
// ----------------------------------------------
KeInitializeMutex(&SmartcardExtension->ReaderExtension->CardManIOMutex,0L);
//
// enter correct version of the lib
//
SmartcardExtension->Version = SMCLIB_VERSION;
//
// setup smartcard extension - callback's
//
SmartcardExtension->ReaderFunction[RDF_CARD_POWER] = CMMOB_CardPower;
SmartcardExtension->ReaderFunction[RDF_TRANSMIT] = CMMOB_Transmit;
SmartcardExtension->ReaderFunction[RDF_SET_PROTOCOL] = CMMOB_SetProtocol;
SmartcardExtension->ReaderFunction[RDF_CARD_TRACKING] = CMMOB_CardTracking;
SmartcardExtension->ReaderFunction[RDF_IOCTL_VENDOR] = CMMOB_IoCtlVendor;
//
// setup smartcard extension - vendor attribute
//
// default values
RtlCopyMemory(SmartcardExtension->VendorAttr.VendorName.Buffer,
CMMOB_VENDOR_NAME,sizeof(CMMOB_VENDOR_NAME));
SmartcardExtension->VendorAttr.VendorName.Length = sizeof(CMMOB_VENDOR_NAME);
RtlCopyMemory(SmartcardExtension->VendorAttr.IfdType.Buffer,
CMMOB_PRODUCT_NAME,sizeof(CMMOB_PRODUCT_NAME));
SmartcardExtension->VendorAttr.IfdType.Length = sizeof(CMMOB_PRODUCT_NAME);
// try to overwrite with registry values
CMMOB_SetVendorAndIfdName(PhysicalDeviceObject, SmartcardExtension);
SmartcardExtension->VendorAttr.UnitNo = ulDeviceInstance;
SmartcardExtension->VendorAttr.IfdVersion.VersionMajor = CMMOB_MAJOR_VERSION;
SmartcardExtension->VendorAttr.IfdVersion.VersionMinor = CMMOB_MINOR_VERSION;
SmartcardExtension->VendorAttr.IfdVersion.BuildNumber = CMMOB_BUILD_NUMBER;
SmartcardExtension->VendorAttr.IfdSerialNo.Length = 0;
//
// setup smartcard extension - reader capabilities
//
SmartcardExtension->ReaderCapabilities.SupportedProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
SmartcardExtension->ReaderCapabilities.ReaderType = SCARD_READER_TYPE_PCMCIA;
SmartcardExtension->ReaderCapabilities.MechProperties = 0;
SmartcardExtension->ReaderCapabilities.Channel = 0;
// set supported frequencies
SmartcardExtension->ReaderCapabilities.CLKFrequency.Default = 4000; //not used if CLKFrequenciesSupported is supplied
SmartcardExtension->ReaderCapabilities.CLKFrequency.Max = 8000; //not used if CLKFrequenciesSupported is supplied
SmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.Entries =
sizeof(SupportedCLKFrequencies) / sizeof(SupportedCLKFrequencies[0]);
SmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.List =
SupportedCLKFrequencies;
// set supported baud rates
SmartcardExtension->ReaderCapabilities.DataRate.Default = 9600; //not used if DataRatesSupported is supplied
SmartcardExtension->ReaderCapabilities.DataRate.Max = 307200; //not used if DataRatesSupported is supplied
SmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries =
sizeof(SupportedDataRates) / sizeof(SupportedDataRates[0]);
SmartcardExtension->ReaderCapabilities.DataRatesSupported.List =
SupportedDataRates;
// maximum buffer size
SmartcardExtension->ReaderCapabilities.MaxIFSD = 254;
//
// Current state of the reader
//
SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_UNKNOWN;
SmartcardExtension->ReaderExtension->ulOldCardState = UNKNOWN;
SmartcardExtension->ReaderExtension->ulNewCardState = UNKNOWN;
SmartcardExtension->ReaderExtension->ulFWVersion = 100;
//
// Initialization of buffers
//
SmartcardExtension->SmartcardRequest.BufferSize = MIN_BUFFER_SIZE;
SmartcardExtension->SmartcardReply.BufferSize = MIN_BUFFER_SIZE;
NTStatus = SmartcardInitialize(SmartcardExtension);
SmartcardExtension->ReaderExtension->ReaderPowerState = PowerReaderWorking;
SmartcardExtension->ReaderExtension->CardParameters.bStopBits=2;
SmartcardExtension->ReaderExtension->CardParameters.fSynchronousCard=FALSE;
SmartcardExtension->ReaderExtension->CardParameters.fInversRevers=FALSE;
SmartcardExtension->ReaderExtension->CardParameters.bClockFrequency=4;
SmartcardExtension->ReaderExtension->CardParameters.fT0Mode=FALSE;
SmartcardExtension->ReaderExtension->CardParameters.fT0Write=FALSE;
SmartcardExtension->ReaderExtension->fReadCIS = FALSE;
SmartcardExtension->ReaderExtension->bPreviousFlags1 = 0;
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DriverObject,
CMMOB_INSUFFICIENT_RESOURCES,
NULL,
0);
leave;
}
//
// tell the lib our device object & create symbolic link
//
SmartcardExtension->OsData->DeviceObject = *DeviceObject;
#ifndef NT4
// W2000 is till now the only OS which supports WDM version 1.10
// So check this to determine if we have an Plug&Play able resource manager
// Otherwise it is Windows 98 / ME
if (IoIsWdmVersionAvailable (1,10))
{
DeviceExtension->OSVersion = OS_Windows2000;
}
else
{
// Read HKLM\Software\Microsoft\Windows\CurrentVersion\VersionNumber
// to determine the version of Windows (95, 98, 98SE and ME)
RegistryValue.Length=0;
RegistryValue.MaximumLength=sizeof(szRegValue);
RegistryValue.Buffer=szRegValue;
RtlZeroMemory(ParamTable,sizeof(ParamTable));
ParamTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
ParamTable[0].Name = L"VersionNumber";
ParamTable[0].EntryContext = &RegistryValue;
ParamTable[0].DefaultType = REG_SZ;
ParamTable[0].DefaultData = &RegistryValue;
ParamTable[0].DefaultLength = RegistryValue.MaximumLength;
RtlInitUnicodeString(&RegistryPath,
L"\\Registry\\Machine\\Software\\Microsoft\\Windows\\CurrentVersion");
RegStatus = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
RegistryPath.Buffer,
ParamTable,
NULL,
NULL);
if (RegStatus == STATUS_SUCCESS)
{
ULONG ulMajorVersion;
ULONG ulMinorVersion;
ULONG ulBuild;
ULONG ulStrLength;
ULONG ulStrPos;
ULONG ulStrPosPrevious;
ulStrLength=RegistryValue.Length;
ulStrPos=0;
ulStrPosPrevious=ulStrPos;
while (szRegValue[ulStrPos] != L'.' &&
szRegValue[ulStrPos] != L'\0' &&
ulStrPos != ulStrLength/sizeof(WCHAR))
{
ulStrPos ++;
}
szRegValue[ulStrPos] = L'\0';
RegistryValue.Length= (USHORT) ((ulStrPos-ulStrPosPrevious)*sizeof(WCHAR));
RtlUnicodeStringToInteger(&RegistryValue,10,&ulMajorVersion);
ulStrPos++;
if (ulStrPos < ulStrLength/sizeof(WCHAR))
{
ulStrPosPrevious=ulStrPos;
while (szRegValue[ulStrPos] != L'.' &&
szRegValue[ulStrPos] != L'\0' &&
ulStrPos != ulStrLength)
{
ulStrPos ++;
}
szRegValue[ulStrPos] = L'\0';
RegistryValue.Length= (USHORT) ((ulStrPos-ulStrPosPrevious)*sizeof(WCHAR));
RegistryValue.Buffer=&szRegValue[ulStrPosPrevious];
RtlUnicodeStringToInteger(&RegistryValue,10,&ulMinorVersion);
ulStrPos++;
if (ulStrPos < ulStrLength/sizeof(WCHAR))
{
ulStrPosPrevious=ulStrPos;
while (szRegValue[ulStrPos] != L'.' &&
szRegValue[ulStrPos] != L'\0' &&
ulStrPos != ulStrLength)
{
ulStrPos ++;
}
szRegValue[ulStrPos] = L'\0';
RegistryValue.Length= (USHORT) ((ulStrPos-ulStrPosPrevious)*sizeof(WCHAR));
RegistryValue.Buffer=&szRegValue[ulStrPosPrevious];
RtlUnicodeStringToInteger(&RegistryValue,10,&ulBuild);
}
}
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: MS Windows Version %li.%li.%li\n",DRIVER_NAME,
ulMajorVersion,ulMinorVersion,ulBuild));
if (ulMajorVersion > 4 ||
(ulMajorVersion == 4 &&
ulMinorVersion > 10 ))
{
DeviceExtension->OSVersion = OS_WindowsME;
}
else if (ulMajorVersion == 4 &&
ulMinorVersion == 10 )
{
if (ulBuild < 2222)
{
DeviceExtension->OSVersion = OS_Windows98;
}
else
{
DeviceExtension->OSVersion = OS_Windows98SE;
}
}
else
{
DeviceExtension->OSVersion = OS_Windows95;
}
}
else
{
// assume it's Windows 98 -> no standby mode
DeviceExtension->OSVersion = OS_Windows98;
}
}
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: Operating system is %s\n",DRIVER_NAME,
szOSVersion[DeviceExtension->OSVersion]));
if (DeviceExtension->OSVersion == OS_Windows2000)
{
if (DeviceExtension->PnPDeviceName.Buffer == NULL)
{
// ----------------------------------------------
// register our new device
// ----------------------------------------------
NTStatus = IoRegisterDeviceInterface(PhysicalDeviceObject,
&SmartCardReaderGuid,
NULL,
&DeviceExtension->PnPDeviceName);
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: PnPDeviceName.Buffer = %lx\n",DRIVER_NAME,
DeviceExtension->PnPDeviceName.Buffer));
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: PnPDeviceName.BufferLength = %lx\n",DRIVER_NAME,
DeviceExtension->PnPDeviceName.Length));
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: IoRegisterDeviceInterface returned=%lx\n",DRIVER_NAME,NTStatus));
}
else
{
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: Interface already exists\n",DRIVER_NAME));
}
}
else
#endif
{
// ----------------------------------------------
// create symbolic link
// ----------------------------------------------
NTStatus = SmartcardCreateLink(&DeviceExtension->LinkDeviceName,&DeviceName);
SmartcardDebug(DEBUG_DRIVER,
("%s!CreateDevice: SmartcardCreateLink returned=%lx\n",DRIVER_NAME,NTStatus));
}
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DriverObject,
CMMOB_INSUFFICIENT_RESOURCES,
NULL,
0);
leave;
}
}
finally
{
if (NTStatus != STATUS_SUCCESS)
{
CMMOB_UnloadDevice(*DeviceObject);
*DeviceObject = NULL;
}
}
SmartcardDebug(DEBUG_TRACE,
( "%s!CreateDevice: Exit %x\n",DRIVER_NAME,NTStatus ));
return NTStatus;
}
/*****************************************************************************
Routine Description:
get the actual configuration from the passed FullResourceDescriptor
and initializes the reader hardware
Note:
for an NT 4.00 build the resources must be translated by the HAL
Arguments:
DeviceObject context of call
FullResourceDescriptor actual configuration of the reader
Return Value:
STATUS_SUCCESS
NTStatus returned from the HAL (NT 4.00 only )
NTStatus returned by LowLevel routines
******************************************************************************/
NTSTATUS CMMOB_StartDevice(
PDEVICE_OBJECT DeviceObject,
PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor
)
{
NTSTATUS NTStatus = STATUS_SUCCESS;
PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
PSMARTCARD_EXTENSION SmartcardExtension = &DeviceExtension->SmartcardExtension;
PREADER_EXTENSION ReaderExtension = SmartcardExtension->ReaderExtension;
ULONG ulCount;
ULONG ulCISIndex;
UCHAR bTupleCode[2];
UCHAR bFirmware[2];
SmartcardDebug(DEBUG_TRACE,
("%s!StartDevice: Enter\n",DRIVER_NAME));
//
// Get the number of resources we need
//
ulCount = FullResourceDescriptor->PartialResourceList.Count;
PartialDescriptor = FullResourceDescriptor->PartialResourceList.PartialDescriptors;
//
// parse all partial descriptors
//
while (ulCount--)
{
switch (PartialDescriptor->Type)
{
#ifdef MEMORYCARD
case CmResourceTypeMemory:
{
//
// 0 - memory, 1 - IO
//
#ifdef NT4
ULONG AddressSpace = 0;
BOOLEAN fTranslated;
PHYSICAL_ADDRESS PhysicalAddress;
#endif
//
// Get Mem-length
//
ReaderExtension->ulMemWindow = PartialDescriptor->u.Memory.Length;
ASSERT(PartialDescriptor->u.Memory.Length >= 4096);
//
// Get Mem-base
//
#ifndef NT4
ReaderExtension->pMemBase = MmMapIoSpace (PartialDescriptor->u.Memory.Start,
PartialDescriptor->u.Memory.Length,
FALSE);
DeviceExtension->fUnMapMem = TRUE;
#else
//
// let the hal translate the address
//
fTranslated = HalTranslateBusAddress(FullResourceDescriptor->InterfaceType,
FullResourceDescriptor->BusNumber,
PartialDescriptor->u.Memory.Start,
&AddressSpace,
&PhysicalAddress);
if (fTranslated == TRUE && AddressSpace == 0)
{
ReaderExtension->pMemBase = MmMapIoSpace(PhysicalAddress,
PartialDescriptor->u.Memory.Length,
FALSE);
DeviceExtension->fUnMapMem = TRUE;
}
else
{
ReaderExtension->pMemBase = (PVOID) PhysicalAddress.LowPart;
}
#endif
SmartcardDebug(DEBUG_TRACE,
("%s!StartDevice: MemBase = %lxh\n",DRIVER_NAME,ReaderExtension->pMemBase));
}
break;
#endif
#ifdef IOCARD
case CmResourceTypePort:
{
#ifdef NT4
//
// 0 - memory, 1 - IO
//
ULONG AddressSpace = 1;
BOOLEAN fTranslated;
PHYSICAL_ADDRESS PhysicalAddress;
#endif
//
// Get IO-length
//
ReaderExtension->ulIoWindow = PartialDescriptor->u.Port.Length;
ASSERT(PartialDescriptor->u.Port.Length >= 8);
//
// Get IO-base
//
#ifndef NT4
#ifndef _WIN64
ReaderExtension->pIoBase = (PVOID) PartialDescriptor->u.Port.Start.LowPart;
#else
ReaderExtension->pIoBase = (PVOID) PartialDescriptor->u.Port.Start.QuadPart;
#endif
#else
//
// let the hal translate the address
//
fTranslated = HalTranslateBusAddress(FullResourceDescriptor->InterfaceType,
FullResourceDescriptor->BusNumber,
PartialDescriptor->u.Port.Start,
&AddressSpace,
&PhysicalAddress);
if (fTranslated == TRUE && AddressSpace == 0)
{
ReaderExtension->pIoBase = MmMapIoSpace(PhysicalAddress,
PartialDescriptor->u.Port.Length,
FALSE);
DeviceExtension->fUnMapMem = TRUE;
}
else
{
ReaderExtension->pIoBase = (PVOID) PhysicalAddress.LowPart;
}
#endif
SmartcardDebug(DEBUG_TRACE,
("%s!StartDevice: IoBase = %lxh\n",DRIVER_NAME,ReaderExtension->pIoBase));
}
break;
#endif
default:
break;
}
PartialDescriptor++;
}
try
{
//
// Base initialized ?
//
#ifdef MEMORYCARD
if (ReaderExtension->pMemBase == NULL)
#endif
#ifdef IOCARD
if (ReaderExtension->pIoBase == NULL)
#endif
{
#ifndef NT4
//
// under NT 4.0 the failure of this fct for the second reader
// means there is only one device
//
SmartcardLogError(DeviceObject,
CMMOB_ERROR_MEM_PORT,
NULL,
0);
#endif
NTStatus = STATUS_INSUFFICIENT_RESOURCES;
leave;
}
// initialize base addresses
#ifdef MEMORYCARD
ReaderExtension->pbCISBase= (PUCHAR) ReaderExtension->pMemBase;
ReaderExtension->pbRegsBase= ReaderExtension->pbCISBase + 0x400;
ReaderExtension->pbDataBase= ReaderExtension->pbCISBase + 0x800;
#endif
#ifdef IOCARD
ReaderExtension->pbRegsBase= (PUCHAR) ReaderExtension->pIoBase;
#endif
NTStatus=CMMOB_ResetReader (ReaderExtension);
SmartcardDebug(DEBUG_DRIVER,
("%s!DEBUG_DRIVER: ResetReader retval = %x\n",DRIVER_NAME, NTStatus));
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DeviceObject,
CMMOB_CANT_INITIALIZE_READER,
NULL,
0);
leave;
}
#ifdef IOCARD
//
// read firmware version from CIS
//
ReaderExtension->fReadCIS=TRUE;
ReaderExtension->fTActive=TRUE;
NTStatus=CMMOB_SetFlags1 (ReaderExtension);
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DeviceObject,
CMMOB_CANT_INITIALIZE_READER,
NULL,
0);
leave;
}
ulCISIndex = 0;
do
{
NTStatus=CMMOB_ReadBuffer(ReaderExtension, ulCISIndex, 2, bTupleCode);
if (NTStatus != STATUS_SUCCESS)
{
leave;
}
if (bTupleCode[0] == 0x15)
{
// this is the version tuple
// read firmware version
NTStatus=CMMOB_ReadBuffer(ReaderExtension, ulCISIndex+2, 2, bFirmware);
if (NTStatus != STATUS_SUCCESS)
{
leave;
}
SmartcardExtension->ReaderExtension->ulFWVersion = 100*(ULONG)bFirmware[0]+bFirmware[1];
SmartcardDebug(DEBUG_TRACE,
("%s!StartDevice: Firmware version = %li\n",
DRIVER_NAME, SmartcardExtension->ReaderExtension->ulFWVersion));
}
ulCISIndex += bTupleCode[1] + 2;
}
while (bTupleCode[1] != 0 &&
bTupleCode[0] != 0x15 &&
bTupleCode[0] != 0xFF &&
ulCISIndex < CMMOB_MAX_CIS_SIZE);
ReaderExtension->fReadCIS=FALSE;
ReaderExtension->fTActive=FALSE;
NTStatus=CMMOB_SetFlags1 (ReaderExtension);
if (NTStatus != STATUS_SUCCESS)
{
SmartcardLogError(DeviceObject,
CMMOB_CANT_INITIALIZE_READER,
NULL,
0);
leave;
}
#endif
//
// start update thread
//
NTStatus = CMMOB_StartCardTracking(DeviceObject);
// signal that the reader has been started (again)
KeSetEvent(&DeviceExtension->ReaderStarted, 0, FALSE);
#ifndef NT4
if (DeviceExtension->OSVersion == OS_Windows2000)
{
NTStatus = IoSetDeviceInterfaceState(&DeviceExtension->PnPDeviceName,TRUE);
}
#endif
}
finally
{
if (NTStatus != STATUS_SUCCESS)
{
CMMOB_StopDevice(DeviceObject);
}
}
SmartcardDebug(DEBUG_TRACE,
("%s!StartDevice: Exit %x\n",DRIVER_NAME,NTStatus));
return NTStatus;
}
/*****************************************************************************
Routine Description:
Unmap the IO port
Arguments:
DeviceObject context of call
Return Value:
void
******************************************************************************/
VOID
CMMOB_StopDevice(
PDEVICE_OBJECT DeviceObject
)
{
PDEVICE_EXTENSION DeviceExtension;
if (DeviceObject == NULL)
{
return;
}
SmartcardDebug(DEBUG_TRACE,
( "%s!StopDevice: Enter\n",DRIVER_NAME ));
DeviceExtension = DeviceObject->DeviceExtension;
KeClearEvent(&DeviceExtension->ReaderStarted);
//
// stop update thread
//
CMMOB_StopCardTracking(DeviceObject);
// power down the card for saftey reasons
if (DeviceExtension->SmartcardExtension.ReaderExtension->ulOldCardState == POWERED)
{
// we have to wait for the mutex before
KeWaitForSingleObject(&DeviceExtension->SmartcardExtension.ReaderExtension->CardManIOMutex,
Executive,
KernelMode,
FALSE,
NULL);
CMMOB_PowerOffCard(&DeviceExtension->SmartcardExtension);
KeReleaseMutex(&DeviceExtension->SmartcardExtension.ReaderExtension->CardManIOMutex,
FALSE);
}
//
// unmap ports
//
if (DeviceExtension->fUnMapMem)
{
#ifdef MEMORYCARD
MmUnmapIoSpace(DeviceExtension->SmartcardExtension.ReaderExtension->pMemBase,
DeviceExtension->SmartcardExtension.ReaderExtension->ulMemWindow);
#endif
#ifdef IOCARD
MmUnmapIoSpace(DeviceExtension->SmartcardExtension.ReaderExtension->pIoBase,
DeviceExtension->SmartcardExtension.ReaderExtension->ulIoWindow);
#endif
DeviceExtension->fUnMapMem = FALSE;
}
SmartcardDebug(DEBUG_TRACE,
( "%s!StopDevice: Exit\n",DRIVER_NAME ));
}
/*****************************************************************************
Routine Description:
close connections to smclib.sys and the pcmcia driver, delete symbolic
link and mark the slot as unused.
Arguments:
DeviceObject device to unload
Return Value:
void
******************************************************************************/
VOID CMMOB_UnloadDevice(
PDEVICE_OBJECT DeviceObject
)
{
PDEVICE_EXTENSION DeviceExtension;
if (DeviceObject == NULL)
{
return;
}
SmartcardDebug(DEBUG_TRACE,
( "%s!UnloadDevice: Enter\n",DRIVER_NAME ));
DeviceExtension = DeviceObject->DeviceExtension;
//
// It is possible that someone yanks out the pcmcia card when the
// resource manager still has a connection to the device.
// We need this flag to know that the device has been removed.
//
DeviceExtension->fDeviceRemoved = TRUE;
ASSERT(DeviceExtension->SmartcardExtension.VendorAttr.UnitNo < CMMOB_MAX_DEVICE);
//
// Mark this slot as available
//
DeviceSlot[DeviceExtension->SmartcardExtension.VendorAttr.UnitNo] = FALSE;
//
// report to the lib that the device will be unloaded
//
if (DeviceExtension->SmartcardExtension.OsData != NULL)
{
//
// finish pending tracking requests
//
CMMOB_CompleteCardTracking (&DeviceExtension->SmartcardExtension);
}
#ifdef NT4
// for WDM driver the remove lock is acquired in the PnP routine
// so in case of NT4 we have to acquire it her
SmartcardAcquireRemoveLock(&DeviceExtension->SmartcardExtension);
#endif
// Wait until we can safely unload the device
SmartcardReleaseRemoveLockAndWait(&DeviceExtension->SmartcardExtension);
SmartcardExit(&DeviceExtension->SmartcardExtension);
#ifndef NT4
if (DeviceExtension->OSVersion == OS_Windows2000)
{
//
// disable interface
//
if (DeviceExtension->PnPDeviceName.Buffer != NULL)
{
// disable our device so no one can open it
IoSetDeviceInterfaceState(&DeviceExtension->PnPDeviceName,FALSE);
RtlFreeUnicodeString(&DeviceExtension->PnPDeviceName);
DeviceExtension->PnPDeviceName.Buffer = NULL;
}
}
else
#endif
{
//
// Delete the symbolic link of the smart card reader
//
if (DeviceExtension->LinkDeviceName.Buffer != NULL)
{
NTSTATUS NTStatus;
NTStatus = IoDeleteSymbolicLink(&DeviceExtension->LinkDeviceName);
//
// we continue even if an error occurs
//
ASSERT(NTStatus == STATUS_SUCCESS);
RtlFreeUnicodeString(&DeviceExtension->LinkDeviceName);
DeviceExtension->LinkDeviceName.Buffer = NULL;
}
}
if (DeviceExtension->SmartcardExtension.ReaderExtension != NULL)
{
ExFreePool(DeviceExtension->SmartcardExtension.ReaderExtension);
DeviceExtension->SmartcardExtension.ReaderExtension = NULL;
}
//
// Detach from the pcmcia driver
// Under NT 4.0 we did not attach to the pcmcia driver
//
if (DeviceExtension->AttachedDeviceObject)
{
IoDetachDevice(DeviceExtension->AttachedDeviceObject);
DeviceExtension->AttachedDeviceObject = NULL;
}
//
// delete the device object
//
IoDeleteDevice(DeviceObject);
SmartcardDebug(DEBUG_TRACE,
( "%s!UnloadDevice: Exit\n",DRIVER_NAME ));
return;
}
/*****************************************************************************
CMMOB_UnloadDriver:
unloads all devices for a given driver object
Arguments:
DriverObject context of driver
Return Value:
void
******************************************************************************/
VOID CMMOB_UnloadDriver(
PDRIVER_OBJECT DriverObject
)
{
PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
ULONG ulSizeOfResources;
SmartcardDebug(DEBUG_TRACE,
( "%s!UnloadDriver: Enter\n",DRIVER_NAME ));
#ifdef NT4
if (DriverObject->DeviceObject != NULL)
{
ulSizeOfResources = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
//
// allocate memory for the resource descriptor
//
FullResourceDescriptor = ExAllocatePool(PagedPool,ulSizeOfResources);
if (FullResourceDescriptor == NULL)
{
return;
}
RtlZeroMemory(FullResourceDescriptor, ulSizeOfResources);
//
// unload all device objects of that driver object
//
while (DriverObject->DeviceObject)
{
CMMOB_StopDevice(DriverObject->DeviceObject);
CMMOB_ReportResources(DriverObject, FullResourceDescriptor);
CMMOB_UnloadDevice(DriverObject->DeviceObject);
}
//
// free local resources
//
ExFreePool(FullResourceDescriptor);
}
#endif
SmartcardDebug(DEBUG_TRACE,
( "%s!UnloadDriver: Exit\n",DRIVER_NAME ));
}
/*****************************************************************************
CMMOB_CreateClose:
allowes only one open process a time
Arguments:
DeviceObject context of device
Irp context of call
Return Value:
STATUS_SUCCESS
STATUS_DEVICE_BUSY
******************************************************************************/
NTSTATUS CMMOB_CreateClose(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
{
NTSTATUS NTStatus = STATUS_SUCCESS;
PDEVICE_EXTENSION DeviceExtension;
PSMARTCARD_EXTENSION SmartcardExtension;
PIO_STACK_LOCATION IrpStack;
SmartcardDebug(DEBUG_TRACE,
("%s!CreateClose: Enter ",DRIVER_NAME));
DeviceExtension = DeviceObject->DeviceExtension;
SmartcardExtension = &DeviceExtension->SmartcardExtension;
IrpStack = IoGetCurrentIrpStackLocation( Irp );
//
// dispatch major function
//
switch (IrpStack->MajorFunction)
{
case IRP_MJ_CREATE:
SmartcardDebug(DEBUG_IOCTL,("%s!CreateClose: IRP_MJ_CREATE\n",DRIVER_NAME));
if (DeviceExtension->fRemovePending)
{
NTStatus = STATUS_DEVICE_BUSY;
}
else
{
if (InterlockedIncrement(&DeviceExtension->lOpenCount) > 1)
{
InterlockedDecrement(&DeviceExtension->lOpenCount);
NTStatus = STATUS_ACCESS_DENIED;
}
}
break;
case IRP_MJ_CLOSE:
SmartcardDebug(DEBUG_IOCTL,("%s!CreateClose: IRP_MJ_CLOSE\n",DRIVER_NAME));
if (InterlockedDecrement(&DeviceExtension->lOpenCount) < 0)
{
InterlockedIncrement(&DeviceExtension->lOpenCount);
}
break;
default:
//
// unrecognized command
//
SmartcardDebug(DEBUG_IOCTL,("unexpected IRP\n"));
NTStatus = STATUS_INVALID_DEVICE_REQUEST;
break;
}
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = NTStatus;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
SmartcardDebug(DEBUG_TRACE,
("%s!CreateClose: Exit %x\n",DRIVER_NAME,NTStatus));
return NTStatus;
}
NTSTATUS CMMOB_SystemControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
{
PDEVICE_EXTENSION DeviceExtension;
NTSTATUS status = STATUS_SUCCESS;
DeviceExtension = DeviceObject->DeviceExtension;
IoSkipCurrentIrpStackLocation(Irp);
status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
return status;
}
/*****************************************************************************
CMMOB_DeviceIoControl:
all IRP's requiring IO are queued to the StartIo routine, other requests
are served immediately
Arguments:
DeviceObject context of device
Irp context of call
Return Value:
STATUS_SUCCESS
STATUS_PENDING
******************************************************************************/
NTSTATUS CMMOB_DeviceIoControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
{
NTSTATUS NTStatus;
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
KIRQL irql;
PIO_STACK_LOCATION irpSL;
SmartcardDebug(DEBUG_TRACE,
("%s!DeviceIoControl: Enter\n",DRIVER_NAME));
irpSL = IoGetCurrentIrpStackLocation(Irp);
#if DBG
switch (irpSL->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_SMARTCARD_EJECT:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_EJECT"));
break;
case IOCTL_SMARTCARD_GET_ATTRIBUTE:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_GET_ATTRIBUTE"));
break;
case IOCTL_SMARTCARD_GET_LAST_ERROR:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_GET_LAST_ERROR"));
break;
case IOCTL_SMARTCARD_GET_STATE:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_GET_STATE"));
break;
case IOCTL_SMARTCARD_IS_ABSENT:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_IS_ABSENT"));
break;
case IOCTL_SMARTCARD_IS_PRESENT:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_IS_PRESENT"));
break;
case IOCTL_SMARTCARD_POWER:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_POWER"));
break;
case IOCTL_SMARTCARD_SET_ATTRIBUTE:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_SET_ATTRIBUTE"));
break;
case IOCTL_SMARTCARD_SET_PROTOCOL:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_SET_PROTOCOL"));
break;
case IOCTL_SMARTCARD_SWALLOW:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_SWALLOW"));
break;
case IOCTL_SMARTCARD_TRANSMIT:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "IOCTL_SMARTCARD_TRANSMIT"));
break;
default:
SmartcardDebug(DEBUG_IOCTL,
("%s!DeviceIoControl: %s\n", DRIVER_NAME, "Vendor specific or unexpected IOCTL"));
break;
}
#endif
KeAcquireSpinLock(&DeviceExtension->SpinLockIoCount, &irql);
if (DeviceExtension->lIoCount == 0)
{
KeReleaseSpinLock(&DeviceExtension->SpinLockIoCount, irql);
NTStatus = KeWaitForSingleObject(&DeviceExtension->ReaderStarted,
Executive,
KernelMode,
FALSE,
NULL);
ASSERT(NTStatus == STATUS_SUCCESS);
KeAcquireSpinLock(&DeviceExtension->SpinLockIoCount, &irql);
}
ASSERT(DeviceExtension->lIoCount >= 0);
DeviceExtension->lIoCount++;
KeReleaseSpinLock(&DeviceExtension->SpinLockIoCount, irql);
// Can't accept a new io request if:
if (DeviceExtension->fDeviceRemoved == TRUE ||
//flag set when processing IRP_MN_REMOVE_DEVICE
DeviceExtension->fRemovePending == TRUE)
// flag set when driver has answered success to IRP_MN_QUERY_REMOVE_DEVICE
{
NTStatus = STATUS_DELETE_PENDING;
Irp->IoStatus.Status = NTStatus;
Irp->IoStatus.Information = 0;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
KeAcquireSpinLock(&DeviceExtension->SpinLockIoCount, &irql);
DeviceExtension->lIoCount--;
ASSERT(DeviceExtension->lIoCount >= 0);
KeReleaseSpinLock(&DeviceExtension->SpinLockIoCount, irql);
return NTStatus;
}
NTStatus = SmartcardAcquireRemoveLock(&DeviceExtension->SmartcardExtension);
if (NTStatus != STATUS_SUCCESS)
{
// the device has been removed. Fail the call
NTStatus = STATUS_DELETE_PENDING;
Irp->IoStatus.Status = NTStatus;
Irp->IoStatus.Information = 0;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
KeAcquireSpinLock(&DeviceExtension->SpinLockIoCount, &irql);
DeviceExtension->lIoCount--;
ASSERT(DeviceExtension->lIoCount >= 0);
KeReleaseSpinLock(&DeviceExtension->SpinLockIoCount, irql);
SmartcardDebug(DEBUG_TRACE,
("%s!DeviceIoControl: Exit %x\n",DRIVER_NAME,NTStatus));
return NTStatus;
}
KeWaitForSingleObject(&DeviceExtension->SmartcardExtension.ReaderExtension->CardManIOMutex,
Executive,
KernelMode,
FALSE,
NULL);
// get current card state
NTStatus = CMMOB_UpdateCurrentState(&DeviceExtension->SmartcardExtension);
NTStatus = SmartcardDeviceControl(&DeviceExtension->SmartcardExtension,Irp);
KeReleaseMutex(&DeviceExtension->SmartcardExtension.ReaderExtension->CardManIOMutex,
FALSE);
SmartcardReleaseRemoveLock(&DeviceExtension->SmartcardExtension);
KeAcquireSpinLock(&DeviceExtension->SpinLockIoCount, &irql);
DeviceExtension->lIoCount--;
ASSERT(DeviceExtension->lIoCount >= 0);
KeReleaseSpinLock(&DeviceExtension->SpinLockIoCount, irql);
SmartcardDebug(DEBUG_TRACE,
("%s!DeviceIoControl: Exit %x\n",DRIVER_NAME,NTStatus));
return NTStatus;
}
/*****************************************************************************
Routine Description:
This routine is called by the I/O system when the calling thread terminates
Arguments:
DeviceObject - Pointer to device object for this miniport
Irp - IRP involved.
Return Value:
STATUS_CANCELLED
******************************************************************************/
NTSTATUS CMMOB_Cleanup(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
PSMARTCARD_EXTENSION SmartcardExtension = &DeviceExtension->SmartcardExtension;
SmartcardDebug(DEBUG_TRACE,
("%s!Cleanup: Enter\n",DRIVER_NAME));
if (SmartcardExtension->OsData->NotificationIrp != NULL &&
// test if there is a pending IRP at all
SmartcardExtension->ReaderExtension != NULL &&
// if the device has been removed ReaderExtension == NULL
DeviceExtension->lOpenCount == 1 )
// complete card tracking only if this is the the last close call
// otherwise the card tracking of the resource manager is canceled
{
//
// We need to complete the notification irp
//
CMMOB_CompleteCardTracking(SmartcardExtension);
}
SmartcardDebug(DEBUG_DRIVER,
("%s!Cleanup: Completing IRP %lx\n",DRIVER_NAME,Irp));
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
SmartcardDebug(DEBUG_TRACE,
("%s!Cleanup: Exit\n",DRIVER_NAME));
return STATUS_SUCCESS;
}
/*****************************************************************************
SysDelay:
performs a required delay. The usage of KeStallExecutionProcessor is
very nasty, but it happends only if SysDelay is called in the context of
our DPC routine (which is only called if a card change was detected).
For 'normal' IO we have Irql < DISPATCH_LEVEL, so if the reader is polled
while waiting for response we will not block the entire system
Arguments:
Timeout delay in milli seconds
Return Value:
void
******************************************************************************/
VOID SysDelay(
ULONG Timeout
)
{
LARGE_INTEGER SysTimeout;
if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
{
ULONG Cnt = 20 * Timeout;
SmartcardDebug(DEBUG_DRIVER,
("%s! Waiting at IRQL >= DISPATCH_LEVEL %l\n",DRIVER_NAME,Timeout));
while (Cnt--)
{
//
// KeStallExecutionProcessor: counted in us
//
KeStallExecutionProcessor( 50 );
}
}
else
{
SysTimeout = RtlConvertLongToLargeInteger(Timeout * -10000L);
//
// KeDelayExecutionThread: counted in 100 ns
//
KeDelayExecutionThread( KernelMode, FALSE, &SysTimeout );
}
return;
}
/*****************************************************************************
* History:
* $Log: cmbp0wdm.c $
* Revision 1.11 2001/01/22 08:12:22 WFrischauf
* No comment given
*
* Revision 1.9 2000/09/25 14:24:33 WFrischauf
* No comment given
*
* Revision 1.8 2000/08/24 09:05:14 TBruendl
* No comment given
*
* Revision 1.7 2000/08/16 16:52:17 WFrischauf
* No comment given
*
* Revision 1.6 2000/08/09 12:46:01 WFrischauf
* No comment given
*
* Revision 1.5 2000/07/27 13:53:06 WFrischauf
* No comment given
*
*
******************************************************************************/
Reference in a new issue Copy permalink