windows-xp/Source/XPSP1/NT/drivers/smartcrd/cmbp0/cmbp0wdm.c

/*****************************************************************************
@doc            INT EXT
******************************************************************************
* $ProjectName:  $
* $ProjectRevision:  $
*-----------------------------------------------------------------------------
* $Source: z:/pr/cmbp0/sw/cmbp0.ms/rcs/cmbp0wdm.c $
* $Revision: 1.11 $
*-----------------------------------------------------------------------------
* $Author: WFrischauf $
*-----------------------------------------------------------------------------
* History: see EOF
*-----------------------------------------------------------------------------
*
* Copyright � 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
*
*
******************************************************************************/