//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) SCM Microsystems, 1998 - 1999
//
//  File:       drvnt5.c
//
//--------------------------------------------------------------------------

#include "DriverNT.h"
#include "DrvNT5.h"
#include "CBHndlr.h"
#include "STCCmd.h"
#include "SRVers.h"

// declare pageable/initialization code
#pragma alloc_text( INIT, DriverEntry )
#pragma alloc_text( PAGEABLE, DrvAddDevice )
#pragma alloc_text( PAGEABLE, DrvCreateDevice )
#pragma alloc_text( PAGEABLE, DrvRemoveDevice )
#pragma alloc_text( PAGEABLE, DrvDriverUnload )


//________________________________ D R I V E R   E N T R Y ________________________________________

NTSTATUS
DriverEntry(
   IN  PDRIVER_OBJECT  DriverObject,
   IN  PUNICODE_STRING RegistryPath
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS NTStatus = STATUS_SUCCESS;
   
   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DriverEntry: Enter\n"));

   // initialization of the drivers entry points
   DriverObject->DriverUnload                   = DrvDriverUnload;
   DriverObject->MajorFunction[IRP_MJ_CREATE]         = DrvCreateClose;
   DriverObject->MajorFunction[IRP_MJ_CLOSE]       = DrvCreateClose;
   DriverObject->MajorFunction[IRP_MJ_CLEANUP]        = DrvCleanup;
   DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DrvDeviceIoControl;
   DriverObject->MajorFunction[IRP_MJ_PNP]            = DrvPnPHandler;
   DriverObject->MajorFunction[IRP_MJ_POWER]       = DrvPowerHandler;
   DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = DrvSystemControl;
   DriverObject->DriverExtension->AddDevice        = DrvAddDevice;

   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DriverEntry: Exit\n"));

   return( NTStatus );
}

//________________________________ I N I T I A L I Z A T I O N ____________________________________

NTSTATUS
DrvAddDevice(
   IN PDRIVER_OBJECT DriverObject,
   IN PDEVICE_OBJECT PhysicalDeviceObject
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   PDEVICE_OBJECT DeviceObject = NULL;
   NTSTATUS NTStatus = STATUS_SUCCESS;
   ULONG deviceInstance;
   UNICODE_STRING vendorNameU, ifdTypeU;
   ANSI_STRING vendorNameA, ifdTypeA;
   HANDLE regKey = NULL;

    // this is a list of our supported data rates
    static ULONG dataRatesSupported[] = {
      9600, 19200, 28800, 38400, 48000, 57600, 67200, 76800, 86400, 96000, 115200
      };

   PAGED_CODE();

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvAddDevice: Enter\n" ));

   __try
   {
      PDEVICE_EXTENSION DeviceExtension;
      PSMARTCARD_EXTENSION SmartcardExtension;
      PREADER_EXTENSION ReaderExtension;
      RTL_QUERY_REGISTRY_TABLE parameters[3];

      RtlZeroMemory(parameters, sizeof(parameters));
      RtlZeroMemory(&vendorNameU, sizeof(vendorNameU));
      RtlZeroMemory(&ifdTypeU, sizeof(ifdTypeU));
      RtlZeroMemory(&vendorNameA, sizeof(vendorNameA));
      RtlZeroMemory(&ifdTypeA, sizeof(ifdTypeA));

      // create the device object
      NTStatus = IoCreateDevice(
         DriverObject,
         sizeof( DEVICE_EXTENSION ),
         NULL,
         FILE_DEVICE_SMARTCARD,
         0,
         TRUE,
         &DeviceObject
         );

      if( NTStatus != STATUS_SUCCESS )
      {
         SmartcardLogError( DriverObject, STC_CANT_CREATE_DEVICE, NULL, 0 );
         __leave;
      }

      // initialize device extension
      DeviceExtension   = DeviceObject->DeviceExtension;
      SmartcardExtension = &DeviceExtension->SmartcardExtension;

      KeInitializeEvent(
            &DeviceExtension->ReaderStarted,
            NotificationEvent,
            FALSE
            );
      // Used to keep track of open close calls
      DeviceExtension->ReaderOpen = FALSE;

      KeInitializeSpinLock(&DeviceExtension->SpinLock);

      // initialize smartcard extension - version & callbacks

      SmartcardExtension->Version = SMCLIB_VERSION;

      SmartcardExtension->ReaderFunction[RDF_TRANSMIT] = CBTransmit;
      SmartcardExtension->ReaderFunction[RDF_SET_PROTOCOL] = CBSetProtocol;
      SmartcardExtension->ReaderFunction[RDF_CARD_POWER] = CBCardPower;
      SmartcardExtension->ReaderFunction[RDF_CARD_TRACKING] = CBCardTracking;

      // initialize smartcard extension - vendor attribute
      RtlCopyMemory(
         SmartcardExtension->VendorAttr.VendorName.Buffer,
         SR_VENDOR_NAME,
         sizeof( SR_VENDOR_NAME )
         );

      SmartcardExtension->VendorAttr.VendorName.Length =
            sizeof( SR_VENDOR_NAME );

      RtlCopyMemory(
         SmartcardExtension->VendorAttr.IfdType.Buffer,
         SR_PRODUCT_NAME,
         sizeof( SR_PRODUCT_NAME )
         );

      SmartcardExtension->VendorAttr.IfdType.Length =
            sizeof( SR_PRODUCT_NAME );

      SmartcardExtension->VendorAttr.UnitNo = MAXULONG;

      for (deviceInstance = 0; deviceInstance < MAXULONG; deviceInstance++) {

         PDEVICE_OBJECT devObj;

         for (devObj = DeviceObject;
             devObj != NULL;
             devObj = devObj->NextDevice) {

             PDEVICE_EXTENSION devExt = devObj->DeviceExtension;
             PSMARTCARD_EXTENSION smcExt = &devExt->SmartcardExtension;

             if (deviceInstance == smcExt->VendorAttr.UnitNo) {

                break;
             }
         }
         if (devObj == NULL) {

            SmartcardExtension->VendorAttr.UnitNo = deviceInstance;
            break;
         }
      }

      SmartcardExtension->VendorAttr.IfdVersion.BuildNumber = 0;

      // initialize smartcard extension - reader capabilities
      SmartcardExtension->ReaderCapabilities.SupportedProtocols =
            SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
      SmartcardExtension->ReaderCapabilities.ReaderType =
            SCARD_READER_TYPE_SERIAL;
      SmartcardExtension->ReaderCapabilities.MechProperties = 0;
      SmartcardExtension->ReaderCapabilities.Channel = 0;
      SmartcardExtension->ReaderCapabilities.MaxIFSD =
         STC_BUFFER_SIZE - PACKET_OVERHEAD;

      SmartcardExtension->ReaderCapabilities.CLKFrequency.Default = 3571;
      SmartcardExtension->ReaderCapabilities.CLKFrequency.Max = 3571;

      SmartcardExtension->ReaderCapabilities.DataRate.Default =
      SmartcardExtension->ReaderCapabilities.DataRate.Max =
          dataRatesSupported[0];

      // reader could support higher data rates
      SmartcardExtension->ReaderCapabilities.DataRatesSupported.List =
         dataRatesSupported;
      SmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries =
         sizeof(dataRatesSupported) / sizeof(dataRatesSupported[0]);

      SmartcardExtension->ReaderCapabilities.CurrentState   = (ULONG) SCARD_UNKNOWN;

      SmartcardExtension->SmartcardRequest.BufferSize = MIN_BUFFER_SIZE;
      SmartcardExtension->SmartcardReply.BufferSize = MIN_BUFFER_SIZE;

      // allocate & initialize reader extension
      SmartcardExtension->ReaderExtension = ExAllocatePool(
            NonPagedPool,
            sizeof( READER_EXTENSION )
            );

      if( SmartcardExtension->ReaderExtension == NULL )
      {
         SmartcardLogError( DriverObject, STC_NO_MEMORY, NULL, 0 );
         NTStatus = STATUS_INSUFFICIENT_RESOURCES;
         __leave;
      }

      ReaderExtension = SmartcardExtension->ReaderExtension;

      ASSERT( ReaderExtension != NULL );

      RtlZeroMemory(ReaderExtension, sizeof( READER_EXTENSION ));

        ReaderExtension->SmartcardExtension = SmartcardExtension;
        ReaderExtension->ReadTimeout = 5000;

      KeInitializeEvent(
         &ReaderExtension->SerialCloseDone,
         NotificationEvent,
         TRUE
         );

      ReaderExtension->CloseSerial = IoAllocateWorkItem(
         DeviceObject
         );

      ReaderExtension->ReadWorkItem = IoAllocateWorkItem(
         DeviceObject
         );

      if (ReaderExtension->CloseSerial == NULL ||
         ReaderExtension->ReadWorkItem == NULL) {

         NTStatus = STATUS_INSUFFICIENT_RESOURCES;
         __leave;
      }

      KeInitializeEvent(
         &ReaderExtension->DataAvailable,
         NotificationEvent,
         FALSE
         );

      KeInitializeEvent(
         &ReaderExtension->IoEvent,
         NotificationEvent,
         FALSE
         );

      NTStatus = SmartcardInitialize( SmartcardExtension );

      if( NTStatus != STATUS_SUCCESS )
      {
         SmartcardLogError(
            DriverObject,
            (SmartcardExtension->OsData ? STC_WRONG_LIB_VERSION : STC_NO_MEMORY ),
            NULL,
            0
            );
         __leave;
      }
      // Save deviceObject
      SmartcardExtension->OsData->DeviceObject = DeviceObject;

      // save the current Power state of the reader
      SmartcardExtension->ReaderExtension->ReaderPowerState = PowerReaderWorking;

      DeviceExtension   = DeviceObject->DeviceExtension;
      ReaderExtension   = DeviceExtension->SmartcardExtension.ReaderExtension;

      // attach the device object to the physical device object
      ReaderExtension->SerialDeviceObject =
         IoAttachDeviceToDeviceStack(
         DeviceObject,
         PhysicalDeviceObject
         );

      ASSERT( ReaderExtension->SerialDeviceObject != NULL );

      if( ReaderExtension->SerialDeviceObject == NULL )
      {
         SmartcardLogError(
            DriverObject,
            STC_CANT_CONNECT_TO_ASSIGNED_PORT,
            NULL,
            NTStatus
            );
         NTStatus = STATUS_UNSUCCESSFUL;
         __leave;
      }

      // register our new device
      NTStatus = IoRegisterDeviceInterface(
         PhysicalDeviceObject,
         &SmartCardReaderGuid,
         NULL,
         &DeviceExtension->PnPDeviceName
         );

      ASSERT( NTStatus == STATUS_SUCCESS );

      DeviceObject->Flags |= DO_BUFFERED_IO;
      DeviceObject->Flags |= DO_POWER_PAGABLE;
      DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

      //
      // 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) {

         __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) {

         __leave;
      }

      if (RtlUnicodeStringToAnsiString(
         &vendorNameA,
         &vendorNameU,
         TRUE
         ) != STATUS_SUCCESS) {

         __leave;
      }

      if (RtlUnicodeStringToAnsiString(
         &ifdTypeA,
         &ifdTypeU,
         TRUE
         ) != STATUS_SUCCESS) {

         __leave;
      }

      if (vendorNameA.Length == 0 ||
         vendorNameA.Length > MAXIMUM_ATTR_STRING_LENGTH ||
         ifdTypeA.Length == 0 ||
         ifdTypeA.Length > MAXIMUM_ATTR_STRING_LENGTH) {

         __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;
   }
   __finally
   {
      if (vendorNameU.Buffer) {

         RtlFreeUnicodeString(&vendorNameU);
      }

      if (ifdTypeU.Buffer) {

         RtlFreeUnicodeString(&ifdTypeU);
      }

      if (vendorNameA.Buffer) {

         RtlFreeAnsiString(&vendorNameA);
      }

      if (ifdTypeA.Buffer) {

         RtlFreeAnsiString(&ifdTypeA);
      }

      if (regKey != NULL) {

         ZwClose(regKey);
      }

      if (NTStatus != STATUS_SUCCESS) {

         DrvRemoveDevice( DeviceObject );
      }

      SmartcardDebug(
         DEBUG_TRACE,
         ( "SCMSTCS!DrvAddDevice: Exit (%lx)\n", NTStatus )
         );
   }
    return NTStatus;
}

NTSTATUS
DrvStartDevice(
   IN PDEVICE_OBJECT DeviceObject
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS NTStatus;
   PIRP     Irp;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvStartDevice: Enter\n" ));

   Irp = IoAllocateIrp((CCHAR)( DeviceObject->StackSize + 1 ), FALSE );

   ASSERT( Irp != NULL );

   if( Irp != NULL )
   {
      PDEVICE_EXTENSION    DeviceExtension;
      PIO_STACK_LOCATION      IrpStack;
      IO_STATUS_BLOCK         IoStatusBlock;
      PSMARTCARD_EXTENSION SmartcardExtension;
      PREADER_EXTENSION    ReaderExtension;

      DeviceExtension      = DeviceObject->DeviceExtension;
      SmartcardExtension   = &DeviceExtension->SmartcardExtension;
      ReaderExtension      = SmartcardExtension->ReaderExtension;

      ASSERT( DeviceExtension != NULL );
      ASSERT( SmartcardExtension != NULL );
      ASSERT( ReaderExtension != NULL );

      KeClearEvent( &ReaderExtension->SerialCloseDone );

      //
      // send MJ_CREATE to the serial driver. a side effect of this call is that the serial
      // enumerator will be informed about the device and not longer poll the interface
      //
      Irp->UserIosb = &IoStatusBlock;

      IoSetNextIrpStackLocation( Irp );
      IrpStack = IoGetCurrentIrpStackLocation( Irp );

      IrpStack->MajorFunction                = IRP_MJ_CREATE;
      IrpStack->Parameters.Create.Options       = 0;
      IrpStack->Parameters.Create.ShareAccess      = 0;
      IrpStack->Parameters.Create.FileAttributes   = 0;
      IrpStack->Parameters.Create.EaLength      = 0;

      NTStatus = DrvCallSerialDriver(
            ReaderExtension->SerialDeviceObject,
            Irp
            );

      if( NTStatus == STATUS_SUCCESS )
      {
         SERIAL_PORT_CONFIG      COMConfig;

         // configure the serial port
         COMConfig.BaudRate.BaudRate         = SR_BAUD_RATE;
         COMConfig.LineControl.StopBits      = SR_STOP_BITS;
         COMConfig.LineControl.Parity     = SR_PARITY;
         COMConfig.LineControl.WordLength = SR_DATA_LENGTH;

         // timeouts
         COMConfig.Timeouts.ReadIntervalTimeout =
                SR_READ_INTERVAL_TIMEOUT;
         COMConfig.Timeouts.ReadTotalTimeoutConstant  =
                SR_READ_TOTAL_TIMEOUT_CONSTANT;
         COMConfig.Timeouts.ReadTotalTimeoutMultiplier = 0;

         COMConfig.Timeouts.WriteTotalTimeoutConstant =
            SR_WRITE_TOTAL_TIMEOUT_CONSTANT;
         COMConfig.Timeouts.WriteTotalTimeoutMultiplier = 0;

         // special characters
         COMConfig.SerialChars.ErrorChar     = 0;
         COMConfig.SerialChars.EofChar    = 0;
         COMConfig.SerialChars.EventChar     = 0;
         COMConfig.SerialChars.XonChar    = 0;
         COMConfig.SerialChars.XoffChar      = 0;
         COMConfig.SerialChars.BreakChar     = 0;

         // handflow
         COMConfig.HandFlow.XonLimit         = 0;
         COMConfig.HandFlow.XoffLimit     = 0;
         COMConfig.HandFlow.ControlHandShake = 0;
         COMConfig.HandFlow.FlowReplace      =
              SERIAL_XOFF_CONTINUE;

         // miscellenaeous
         COMConfig.WaitMask               = SR_NOTIFICATION_EVENT;
         COMConfig.Purge                  = SR_PURGE;

         NTStatus = IFInitializeInterface( ReaderExtension, &COMConfig );

         if( NTStatus == STATUS_SUCCESS )
         {
            // configure the reader & initialize the card state
            NTStatus = STCConfigureSTC(
                    ReaderExtension,
                    ( PSTC_REGISTER ) STCInitialize
                    );

            CBUpdateCardState( SmartcardExtension, SCARD_UNKNOWN );
            //
            // store firmware revision in ifd version
            //
            STCGetFirmwareRevision( ReaderExtension );
            SmartcardExtension->VendorAttr.IfdVersion.VersionMajor =
               ReaderExtension->FirmwareMajor;
            SmartcardExtension->VendorAttr.IfdVersion.VersionMinor =
               ReaderExtension->FirmwareMinor;
            SmartcardExtension->VendorAttr.IfdSerialNo.Length     = 0;

            if( NTStatus == STATUS_SUCCESS )
            {
               NTStatus = IoSetDeviceInterfaceState(
                        &DeviceExtension->PnPDeviceName,
                        TRUE
                        );

               if( NTStatus == STATUS_SUCCESS )
               {
                  KeSetEvent( &DeviceExtension->ReaderStarted, 0, FALSE );
               }
            }
            else
            {
               SmartcardLogError( DeviceObject, STC_NO_READER_FOUND, NULL, 0 );
            }
         }
         else
         {
            SmartcardLogError( DeviceObject, STC_ERROR_INIT_INTERFACE, NULL, 0 );
         }
      }
      else
      {
         SmartcardLogError( DeviceObject, STC_CONNECT_FAILS, NULL, 0 );
      }
      IoFreeIrp( Irp );
   }
   else
   {
      SmartcardLogError( DeviceObject, STC_NO_MEMORY, NULL, 0 );
      NTStatus = STATUS_NO_MEMORY;
   }

    if (NTStatus != STATUS_SUCCESS) {

        DrvStopDevice(DeviceObject->DeviceExtension);
    }

   SmartcardDebug(
        (NTStatus == STATUS_SUCCESS ? DEBUG_TRACE : DEBUG_ERROR),
        ( "SCMSTCS!DrvStartDevice: Exit %lx\n",
        NTStatus )
        );

   return( NTStatus );
}

//________________________________________ U N L O A D ____________________________________________

VOID
DrvStopDevice(
   IN PDEVICE_EXTENSION DeviceExtension
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/

{
   PSMARTCARD_EXTENSION SmartcardExtension;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvStopDevice: Enter\n" ));

   SmartcardExtension = &DeviceExtension->SmartcardExtension;

   if( KeReadStateEvent( &SmartcardExtension->ReaderExtension->SerialCloseDone ) == 0l )
   {
      NTSTATUS NTStatus;
      ULONG    WaitMask;

      SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvStopDevice: Power Down\n" ));

      // power down the reader
      STCConfigureSTC(
            SmartcardExtension->ReaderExtension,
            ( PSTC_REGISTER ) STCClose
            );

      // the following delay is neccessary to make sure the last read operation is completed
      // and a IOCTL_SERIAL_WAIT_ON_MASK is started
      SysDelay( 2 * SR_READ_TOTAL_TIMEOUT_CONSTANT );

      //
      // no more event notification neccessary. a side effect is the
      // finishing of all pending notification irp's by the serial driver,
      // so the callback will complete the irp & initiate the close of the
      // connection to the serial driver
      //
      WaitMask = 0;
      SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!Set Wait Mask\n" ));

      NTStatus = IFSerialIoctl(
         SmartcardExtension->ReaderExtension,
         IOCTL_SERIAL_SET_WAIT_MASK,
         &WaitMask,
         sizeof( ULONG ),
         NULL,
         0
         );

      SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!Wait For Done\n" ));

      // wait until the connetion to the serial driver is closed
      NTStatus = KeWaitForSingleObject(
         &SmartcardExtension->ReaderExtension->SerialCloseDone,
         Executive,
         KernelMode,
         FALSE,
         NULL
         );

   }

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvStopDevice: Exit\n" ));
}


VOID
DrvRemoveDevice(
   PDEVICE_OBJECT DeviceObject
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS          NTStatus;
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvRemoveDevice: Enter\n" ));

   PAGED_CODE();

   if( DeviceObject != NULL )
   {
      DeviceExtension      = DeviceObject->DeviceExtension;
      SmartcardExtension   = &DeviceExtension->SmartcardExtension;

      DrvStopDevice( DeviceExtension );

      if( SmartcardExtension->OsData )
      {
         ASSERT( SmartcardExtension->OsData->NotificationIrp == NULL );

         // Wait until we can safely unload the device
         SmartcardReleaseRemoveLockAndWait( SmartcardExtension );
      }

      if( SmartcardExtension->ReaderExtension->SerialDeviceObject )
      {
         IoDetachDevice( SmartcardExtension->ReaderExtension->SerialDeviceObject );
      }

      if( DeviceExtension->PnPDeviceName.Buffer != NULL )
      {
         RtlFreeUnicodeString( &DeviceExtension->PnPDeviceName );
      }

      if( SmartcardExtension->OsData != NULL )
      {
         SmartcardExit( SmartcardExtension );
      }

      if( SmartcardExtension->ReaderExtension != NULL )
      {
         if (SmartcardExtension->ReaderExtension->CloseSerial != NULL) {

            IoFreeWorkItem(SmartcardExtension->ReaderExtension->CloseSerial);
         }

         if (SmartcardExtension->ReaderExtension->ReadWorkItem != NULL) {

            IoFreeWorkItem(SmartcardExtension->ReaderExtension->ReadWorkItem);
         }

         ExFreePool( SmartcardExtension->ReaderExtension );
      }

      IoDeleteDevice( DeviceObject );
   }
   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvRemoveDevice: Exit\n" ));
}

VOID
DrvDriverUnload(
   IN PDRIVER_OBJECT DriverObject
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   PDEVICE_OBJECT DeviceObject;
   NTSTATUS    NTStatus;

   PAGED_CODE();

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvDriverUnload: Enter\n" ));

   // just make sure that all device instances have been unloaded
   while( DeviceObject = DriverObject->DeviceObject )
   {
      DrvRemoveDevice( DeviceObject );

   } while( DeviceObject = DriverObject->DeviceObject );

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvDriverUnload: Exit\n" ));
}

NTSTATUS
DrvSystemControl(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )

/*++

Routine Description:

Arguments:

    DeviceObject  - Pointer to device object for this miniport
    Irp        - IRP involved.

Return Value:

    STATUS_SUCCESS.

--*/
{
   
   PDEVICE_EXTENSION DeviceExtension; 
   PSMARTCARD_EXTENSION SmartcardExtension; 
   PREADER_EXTENSION ReaderExtension; 
   NTSTATUS status = STATUS_SUCCESS;

   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;
   ReaderExtension      = SmartcardExtension->ReaderExtension;

   IoSkipCurrentIrpStackLocation(Irp);
   status = IoCallDriver(ReaderExtension->SerialDeviceObject, Irp);
      
   return status;

} 



//______________________________ D E V I C E   I O   C O N T R O L ________________________________



NTSTATUS
DrvCreateClose(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )

/*++

Routine Description:

    This routine is called by the I/O system when the device is opened or closed.

Arguments:

    DeviceObject  - Pointer to device object for this miniport
    Irp        - IRP involved.

Return Value:

    STATUS_SUCCESS.

--*/

{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status = STATUS_SUCCESS;

   __try {

      if (irpStack->MajorFunction == IRP_MJ_CREATE) {

         status = SmartcardAcquireRemoveLockWithTag(
            &deviceExtension->SmartcardExtension,
            'lCrC'
            );

         if (status != STATUS_SUCCESS) {

            status = STATUS_DEVICE_REMOVED;
            __leave;
         }

         // test if the device has been opened already
         if (InterlockedCompareExchange(
            &deviceExtension->ReaderOpen,
            TRUE,
            FALSE) == FALSE) {

            SmartcardDebug(
               DEBUG_DRIVER,
               ("%s!DrvCreateClose: Open\n",
               DRIVER_NAME)
               );

         } else {

            // the device is already in use
            status = STATUS_UNSUCCESSFUL;

            // release the lock
            SmartcardReleaseRemoveLockWithTag(
               &deviceExtension->SmartcardExtension,
               'lCrC'
               );

         }

      } else {

         SmartcardDebug(
            DEBUG_DRIVER,
            ("%s!DrvCreateClose: Close\n",
            DRIVER_NAME)
            );

         SmartcardReleaseRemoveLockWithTag(
            &deviceExtension->SmartcardExtension,
            'lCrC'
            );
         deviceExtension->ReaderOpen = FALSE;
      }
   }
   __finally {

      Irp->IoStatus.Status = status;
      Irp->IoStatus.Information = 0;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
   }

    return status;
}

NTSTATUS
DrvDeviceIoControl(
   PDEVICE_OBJECT DeviceObject,
   PIRP        Irp
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS          NTStatus=STATUS_SUCCESS;
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;
   KIRQL             CurrentIrql;

   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;

   if (KeReadStateEvent(&(SmartcardExtension->ReaderExtension->SerialCloseDone))) {

      //
      // we have no connection to serial, the device was either
      // surprise-removed or politely removed
      //
      NTStatus = STATUS_DEVICE_REMOVED;
   }
   if (NTStatus == STATUS_SUCCESS)
   {
      KeAcquireSpinLock( &DeviceExtension->SpinLock, &CurrentIrql );

      // make sure that the reader is already started
      if( DeviceExtension->IoCount == 0 )
      {
         KeReleaseSpinLock( &DeviceExtension->SpinLock, CurrentIrql );

         // wait until the pnp manager has started the device
         NTStatus = KeWaitForSingleObject(
            &DeviceExtension->ReaderStarted,
            Executive,
            KernelMode,
            FALSE,
            NULL
            );


         KeAcquireSpinLock( &DeviceExtension->SpinLock, &CurrentIrql );
      }


      DeviceExtension->IoCount++;

      KeReleaseSpinLock( &DeviceExtension->SpinLock, CurrentIrql );

      NTStatus = SmartcardAcquireRemoveLockWithTag(SmartcardExtension, 'tcoI');
   }
   if( NTStatus != STATUS_SUCCESS )
   {
      // if no remove lock can be acquired, the device has been removed
      Irp->IoStatus.Information  = 0;
      Irp->IoStatus.Status    = STATUS_DEVICE_REMOVED;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      NTStatus = STATUS_DEVICE_REMOVED;
      SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvDeviceIoControl: the device has been removed\n" ));

   }
   else
   {
      // let the lib process the call
      NTStatus = SmartcardDeviceControl( SmartcardExtension, Irp );

       SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'tcoI');

      KeAcquireSpinLock( &DeviceExtension->SpinLock, &CurrentIrql );

      DeviceExtension->IoCount--;

      KeReleaseSpinLock(&DeviceExtension->SpinLock, CurrentIrql);
   }
   return( NTStatus );
}


NTSTATUS
DrvGenericIOCTL(
   PSMARTCARD_EXTENSION SmartcardExtension
   )
/*++

DrvGenericIOCTL:
   Performs generic callbacks to the reader

Arguments:
   SmartcardExtension   context of the call

Return Value:
   STATUS_SUCCESS

--*/
{
   NTSTATUS          NTStatus;
   PIRP              Irp;
   PIO_STACK_LOCATION      IrpStack;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvGenericIOCTL: Enter\n" ));

   // get pointer to current IRP stack location
   Irp         = SmartcardExtension->OsData->CurrentIrp;
   IrpStack = IoGetCurrentIrpStackLocation( Irp );

   // assume error
   NTStatus = STATUS_INVALID_DEVICE_REQUEST;
   Irp->IoStatus.Information = 0;

   // dispatch IOCTL
   switch( IrpStack->Parameters.DeviceIoControl.IoControlCode )
   {
      case IOCTL_GET_VERSIONS:

         if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof( VERSION_CONTROL ))
         {
            NTStatus = STATUS_BUFFER_TOO_SMALL;
         }
         else
         {
            PVERSION_CONTROL  VersionControl;

            VersionControl = (PVERSION_CONTROL)Irp->AssociatedIrp.SystemBuffer;

            VersionControl->SmclibVersion = SmartcardExtension->Version;
            VersionControl->DriverMajor      = SCMSTCS_MAJOR_VERSION;
            VersionControl->DriverMinor      = SCMSTCS_MINOR_VERSION;

            // update firmware version
            STCGetFirmwareRevision( SmartcardExtension->ReaderExtension );

            VersionControl->FirmwareMajor =
               SmartcardExtension->ReaderExtension->FirmwareMajor;

            VersionControl->FirmwareMinor =
               SmartcardExtension->ReaderExtension->FirmwareMinor;

            Irp->IoStatus.Information = sizeof( VERSION_CONTROL );
            NTStatus = STATUS_SUCCESS;
         }
         break;

      default:
         break;
   }

   // set status of the packet
   Irp->IoStatus.Status = NTStatus;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvGenericIOCTL: Exit\n" ));

   return( NTStatus );
}

NTSTATUS
DrvCancel(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )

/*++

Routine Description:
    This function is called whenever the caller wants to
    cancel a pending irp.

Arguments:
    DeviceObject - Our device object
    Irp - the pending irp that we should cancel
--*/
{
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvCancel: Enter\n" ));

   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;

   ASSERT( Irp == SmartcardExtension->OsData->NotificationIrp );

   Irp->IoStatus.Information  = 0;
   Irp->IoStatus.Status    = STATUS_CANCELLED;

   SmartcardExtension->OsData->NotificationIrp = NULL;
   IoReleaseCancelSpinLock( Irp->CancelIrql );

   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!Cancel Irp %lx\n", Irp ));
   IoCompleteRequest( Irp, IO_NO_INCREMENT );

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvCancel: Exit\n" ));

   return( STATUS_CANCELLED );
}

NTSTATUS
DrvCleanup(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )

/*++

Routine Description:
    This function is called, when the 'calling app' terminates (unexpectedly).
    We have to clean up all pending irps. In our case it can only be the
    notification irp.

--*/
{
   NTSTATUS          NTStatus = STATUS_SUCCESS;
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;
    KIRQL                   CancelIrql;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvCleanup: Enter\n" ));

   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;

   IoAcquireCancelSpinLock(&CancelIrql);

   ASSERT( Irp != SmartcardExtension->OsData->NotificationIrp );

   // cancel pending notification irps
   if( SmartcardExtension->OsData->NotificationIrp )
   {
        // reset the cancel function so that it won't be called anymore
        IoSetCancelRoutine(
            SmartcardExtension->OsData->NotificationIrp,
            NULL
            );
        SmartcardExtension->OsData->NotificationIrp->CancelIrql =
            CancelIrql;

        // DrvCancel will release the cancel spin lock
      DrvCancel(
            DeviceObject,
            SmartcardExtension->OsData->NotificationIrp
            );

   } else {

        IoReleaseCancelSpinLock(CancelIrql);
    }

   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!Completing Irp %lx\n", Irp ));

    // complete the irp that was passed to this function
   Irp->IoStatus.Information  = 0;
   Irp->IoStatus.Status    = STATUS_SUCCESS;
   IoCompleteRequest( Irp, IO_NO_INCREMENT );

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvCleanup: Exit\n" ));

   return( STATUS_SUCCESS );
}

VOID
DrvWaitForDeviceRemoval(
   IN PDEVICE_OBJECT DeviceObject,
   IN PVOID Context
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS       NTStatus;
   PDEVICE_EXTENSION DeviceExtension;
   PREADER_EXTENSION ReaderExtension;
   PIRP           Irp;
   PIO_STACK_LOCATION   IrpStack;
   IO_STATUS_BLOCK      IoStatusBlock;

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvWaitForDeviceRemoval: Enter\n" ));

   DeviceExtension = DeviceObject->DeviceExtension;
   ReaderExtension = DeviceExtension->SmartcardExtension.ReaderExtension;

   ASSERT( DeviceExtension != NULL );
   ASSERT( ReaderExtension != NULL );

   // mark the device as invalid, so no application can re-open it
   IoSetDeviceInterfaceState( &DeviceExtension->PnPDeviceName, FALSE );

   // close the connection to the serial driver
   Irp = IoAllocateIrp( (CCHAR)( DeviceObject->StackSize + 1 ), FALSE );

   ASSERT( Irp != NULL );

   if( Irp != NULL )
   {
      SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvWaitForDeviceRemoval: Sending IRP_MJ_CLOSE\n" ));

      IoSetNextIrpStackLocation( Irp );
      //
      // send MJ_CLOSE to the serial driver. a side effect of this call is that the serial
      // enumerator will be informed about changes at the COM port, so it will trigger the
      // appropriate pnp calls
      //
      Irp->UserIosb        = &IoStatusBlock;
      IrpStack          = IoGetCurrentIrpStackLocation( Irp );
      IrpStack->MajorFunction = IRP_MJ_CLOSE;

      NTStatus = DrvCallSerialDriver( ReaderExtension->SerialDeviceObject, Irp );

      IoFreeIrp( Irp );
   }

   // inform waiting threads that the close to the serial driver has finished
   KeSetEvent( &ReaderExtension->SerialCloseDone, 0, FALSE );

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvWaitForDeviceRemoval: Exit\n" ));

   return;
}

NTSTATUS
DrvIoCompletion (
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp,
   IN PKEVENT        Event
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   UNREFERENCED_PARAMETER( DeviceObject );

   if( Irp->Cancel )
   {

      Irp->IoStatus.Status = STATUS_CANCELLED;
   }
   else
   {
      Irp->IoStatus.Status = STATUS_MORE_PROCESSING_REQUIRED;
   }

   KeSetEvent( Event, 0, FALSE );

   return( STATUS_MORE_PROCESSING_REQUIRED );
}

NTSTATUS
DrvCallSerialDriver(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS NTStatus = STATUS_SUCCESS;
   KEVENT      Event;

   // copy the stack location of the actual call to the next position
   IoCopyCurrentIrpStackLocationToNext( Irp );

   // this event will be passed to the completion routine & signaled if the call
   // is finished
   KeInitializeEvent( &Event, NotificationEvent, FALSE );

   // the DrvIoCompletion signals the event & keeps the irp alive by setting the
   // status to STATUS_MORE_PROCESSING_REQUIRED
   IoSetCompletionRoutine (
      Irp,
      DrvIoCompletion,
      &Event,
      TRUE,
      TRUE,
      TRUE
      );

   // call the appropriate driver
   if( IoGetCurrentIrpStackLocation( Irp )->MajorFunction == IRP_MJ_POWER )
   {
      NTStatus = PoCallDriver( DeviceObject, Irp );
   }
   else
   {
      NTStatus = IoCallDriver( DeviceObject, Irp );
   }

   // wait until the irp was processed
   if( NTStatus == STATUS_PENDING )
   {
      NTStatus = KeWaitForSingleObject(
            &Event,
            Executive,
            KernelMode,
            FALSE,
            NULL
            );

      NTStatus = Irp->IoStatus.Status;
   }
   return( NTStatus );
}

//__________________________________ P L U G ' N ' P L A Y ________________________________________

NTSTATUS
DrvPnPHandler(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP Irp
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS          NTStatus = STATUS_SUCCESS;
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;
   PREADER_EXTENSION    ReaderExtension;

   PAGED_CODE();

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvPnPDeviceControl: Enter\n" ));

   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;
   ReaderExtension      = SmartcardExtension->ReaderExtension;

   NTStatus = SmartcardAcquireRemoveLockWithTag(SmartcardExtension, ' PnP');

   if( NTStatus != STATUS_SUCCESS )
   {
      Irp->IoStatus.Information  = 0;
      Irp->IoStatus.Status    = NTStatus;
      IoCompleteRequest( Irp, IO_NO_INCREMENT );
   }
   else
   {
      PDEVICE_OBJECT AttachedDeviceObject;
      BOOLEAN        DeviceRemoved,
                  IrpSkipped;

      AttachedDeviceObject = ReaderExtension->SerialDeviceObject;

      DeviceRemoved  = FALSE,
      IrpSkipped     = FALSE;


      // dispatch on pnp minor function
      switch(  IoGetCurrentIrpStackLocation( Irp )->MinorFunction )
      {
         case IRP_MN_START_DEVICE:

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_START_DEVICE\n" ));

            // call the serial driver first to make sure the interface is ready
            NTStatus = DrvCallSerialDriver(AttachedDeviceObject, Irp );

            if( NT_SUCCESS(NTStatus))
            {
               NTStatus = DrvStartDevice(DeviceObject);
            }
            break;

         case IRP_MN_QUERY_STOP_DEVICE:
         {
            KIRQL CurrentIrql;

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_QUERY_STOP_DEVICE\n" ));

            KeAcquireSpinLock(&DeviceExtension->SpinLock, &CurrentIrql );

            if( DeviceExtension->IoCount > 0 )
            {
               // don't stop if any io requests are pending
               KeReleaseSpinLock(&DeviceExtension->SpinLock, CurrentIrql );
               NTStatus = STATUS_DEVICE_BUSY;

            }
            else
            {
               // don't allow further io requests
               KeClearEvent( &DeviceExtension->ReaderStarted );
               KeReleaseSpinLock( &DeviceExtension->SpinLock, CurrentIrql );
               NTStatus = DrvCallSerialDriver( AttachedDeviceObject, Irp );
            }
            break;
         }

         case IRP_MN_CANCEL_STOP_DEVICE:

            SmartcardDebug( DEBUG_DRIVER,  ( "SCMSTCS!IRP_MN_CANCEL_STOP_DEVICE\n" ));

            NTStatus = DrvCallSerialDriver( AttachedDeviceObject, Irp );

            if( NTStatus == STATUS_SUCCESS )
            {
               // driver is ready to process io requests
               KeSetEvent( &DeviceExtension->ReaderStarted, 0, FALSE );
            }
            break;

         case IRP_MN_STOP_DEVICE:

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_STOP_DEVICE\n" ));

            DrvStopDevice( DeviceExtension );

            NTStatus = DrvCallSerialDriver(AttachedDeviceObject, Irp );
            break;

         case IRP_MN_QUERY_REMOVE_DEVICE:

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_QUERY_REMOVE_DEVICE\n" ));

            // disable the reader (and ignore possibles errors)
            IoSetDeviceInterfaceState(
               &DeviceExtension->PnPDeviceName,
               FALSE
               );

               // check if the reader is in use
               if(DeviceExtension->ReaderOpen)
               {
                  //
                  // someone is connected, fail the call
                  // we will enable the device interface in
                  // IRP_MN_CANCEL_REMOVE_DEVICE again
                  //
                  NTStatus = STATUS_UNSUCCESSFUL;
               }
               else
               {
                  // ready to remove the device
                  NTStatus = DrvCallSerialDriver(AttachedDeviceObject, Irp );
               }
            break;

         case IRP_MN_CANCEL_REMOVE_DEVICE:

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_CANCEL_REMOVE_DEVICE\n" ));

            NTStatus = DrvCallSerialDriver( AttachedDeviceObject, Irp );

            //
            // reenable the interface only in case that the reader is
            // still connected. This covers the following case:
            // hibernate machine, disconnect reader, wake up, stop device
            // (from task bar) and stop fails since an app. holds the device open
            //
            if(( NTStatus == STATUS_SUCCESS )&&
               (KeReadStateEvent(&(ReaderExtension->SerialCloseDone))!= TRUE))
            {
               // enable the reader
               SmartcardDebug( DEBUG_DRIVER, ( "IoSetDeviceInterfaceState( &DeviceExtension->PnPDeviceName, TRUE )\n" ));

               NTStatus = IoSetDeviceInterfaceState( &DeviceExtension->PnPDeviceName, TRUE );
            }
            break;

         case IRP_MN_REMOVE_DEVICE:

            SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!IRP_MN_REMOVE_DEVICE\n" ));

            DrvRemoveDevice( DeviceObject );
            NTStatus    = DrvCallSerialDriver( AttachedDeviceObject, Irp );
            DeviceRemoved  = TRUE;
            break;

         default:

            // the irp is not handled by the driver, so pass it to theserial driver
            SmartcardDebug(
               DEBUG_DRIVER,
               ( "SCMSTCS!IRP_MN_%lx\n",  IoGetCurrentIrpStackLocation( Irp )->MinorFunction )
               );

            IoSkipCurrentIrpStackLocation( Irp );
            NTStatus = IoCallDriver( AttachedDeviceObject, Irp );
            IrpSkipped  = TRUE;
            break;
      }

      if( IrpSkipped == FALSE)
      {
         Irp->IoStatus.Status = NTStatus;
         IoCompleteRequest( Irp, IO_NO_INCREMENT );
      }

      if( DeviceRemoved == FALSE)
      {
           SmartcardReleaseRemoveLockWithTag(SmartcardExtension, ' PnP');
      }
   }

   SmartcardDebug( DEBUG_TRACE, ( "SCMSTCS!DrvPnPDeviceControl: Exit %X\n", NTStatus ));
   return( NTStatus );
}

//__________________________________________ P O W E R ____________________________________________


VOID
DrvSystemPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PKEVENT Event,
    IN PIO_STATUS_BLOCK IoStatus
    )
/*++

Routine Description:
    This function is called when the underlying stacks
    completed the power transition.

--*/
{
    UNREFERENCED_PARAMETER (DeviceObject);
    UNREFERENCED_PARAMETER (MinorFunction);
    UNREFERENCED_PARAMETER (PowerState);
    UNREFERENCED_PARAMETER (IoStatus);

    KeSetEvent(Event, 0, FALSE);
}

NTSTATUS
DrvDevicePowerCompletion(
   IN PDEVICE_OBJECT    DeviceObject,
   IN PIRP              Irp,
   IN PSMARTCARD_EXTENSION SmartcardExtension
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    NTSTATUS NTStatus;
    PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    BOOLEAN CardPresent;
    KIRQL   irql;
    if(Irp->PendingReturned) {
       IoMarkIrpPending(Irp);
    }

   // re-initialize the the reader & get the current card state
   NTStatus = STCConfigureSTC(
      SmartcardExtension->ReaderExtension,
      ( PSTC_REGISTER ) STCInitialize
      );

    // Save the state of the card BEFORE stand by / hibernation
   KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                     &irql);
    CardPresent =
        SmartcardExtension->ReaderCapabilities.CurrentState >= SCARD_ABSENT;
    KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                      irql);

    // get the current state of the card
    CBUpdateCardState(SmartcardExtension, SCARD_UNKNOWN);

    KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                      &irql);
    
    if (CardPresent ||
        SmartcardExtension->ReaderCapabilities.CurrentState >= SCARD_ABSENT) {

        //
        // If a card was present before power down or now there is
        // a card in the reader, we complete any pending card monitor
        // request, since we do not really know what card is now in the
        // reader.
        //
        SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_ABSENT;
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);
        
        CBUpdateCardState(SmartcardExtension, SCARD_UNKNOWN);
    } else {
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);

    }


   // save the current Power state of the reader
   SmartcardExtension->ReaderExtension->ReaderPowerState = PowerReaderWorking;

    SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'rwoP');

   // inform the Power manager of our state.
   PoSetPowerState (
      DeviceObject,
      DevicePowerState,
      IoGetCurrentIrpStackLocation( Irp )->Parameters.Power.State
      );

   PoStartNextPowerIrp( Irp );

    // signal that we can process ioctls again
    KeSetEvent(&DeviceExtension->ReaderStarted, 0, FALSE);

   return( STATUS_SUCCESS );
}

typedef enum _ACTION
{
   Undefined = 0,
   SkipRequest,
   WaitForCompletion,
   CompleteRequest,
   MarkPending

} ACTION;


NTSTATUS
DrvPowerHandler(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP           Irp
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   NTSTATUS          NTStatus = STATUS_SUCCESS;
   PIO_STACK_LOCATION      IrpStack;
   PDEVICE_EXTENSION    DeviceExtension;
   PSMARTCARD_EXTENSION SmartcardExtension;
   PDEVICE_OBJECT       AttachedDeviceObject;
   POWER_STATE           PowerState;
   ACTION               Action;
   KEVENT               event;
   KIRQL                irql;

   PAGED_CODE();

   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvPowerHandler: Enter\n" ));

   IrpStack       = IoGetCurrentIrpStackLocation( Irp );
   DeviceExtension      = DeviceObject->DeviceExtension;
   SmartcardExtension   = &DeviceExtension->SmartcardExtension;
   AttachedDeviceObject = SmartcardExtension->ReaderExtension->SerialDeviceObject;

    NTStatus = SmartcardAcquireRemoveLockWithTag(SmartcardExtension, 'rwoP');

   if( !NT_SUCCESS( NTStatus ))
   {
      PoStartNextPowerIrp( Irp );
      Irp->IoStatus.Status = NTStatus;
      IoCompleteRequest( Irp, IO_NO_INCREMENT );
   }
   else
   {

      switch (IrpStack->Parameters.Power.Type) {
      case DevicePowerState:

         if (IrpStack->MinorFunction == IRP_MN_SET_POWER ) {
            switch ( IrpStack->Parameters.Power.State.DeviceState ) {
            case PowerDeviceD0:

               // turn the reader on
               SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvPowerHandler: PowerDevice D0\n" ));
               //
               // send the request to the serial driver to power up the port.
               // the reader will be powered from our completion routine
               //
               IoCopyCurrentIrpStackLocationToNext( Irp );
               IoSetCompletionRoutine (
                                      Irp,
                                      DrvDevicePowerCompletion,
                                      SmartcardExtension,
                                      TRUE,
                                      TRUE,
                                      TRUE
                                      );

               Action = WaitForCompletion;
               break;

            case PowerDeviceD3:

               // turn the reader off
               SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvPowerHandler: PowerDevice D3\n" ));

               PoSetPowerState (
                               DeviceObject,
                               DevicePowerState,
                               IrpStack->Parameters.Power.State
                               );

               //
               // check if we're still connected to the reader
               // someone might have pulled the plug without re-scanning for hw/changes
               //
               if (KeReadStateEvent( &SmartcardExtension->ReaderExtension->SerialCloseDone ) == 0l) {

                  //   power down the card
                   KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                                     &irql);

                  if ( SmartcardExtension->ReaderCapabilities.CurrentState > SCARD_ABSENT ) {

                      KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                                        irql);

                     SmartcardExtension->MinorIoControlCode = SCARD_POWER_DOWN;
                     NTStatus = CBCardPower( SmartcardExtension );
                     //
                     // This will trigger the card monitor, since we do not really
                     // know if the user will remove / re-insert a card while the
                     // system is asleep
                     //
                  } else {
                      KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                                        irql);
                  }

                  //   power down the reader
                  STCConfigureSTC(
                                 SmartcardExtension->ReaderExtension,
                                 ( PSTC_REGISTER ) STCClose
                                 );
               }

               // wait until the last read is finished to make sure we go to power
               // down with a pending tracking irp
               SysDelay( 2 * SR_READ_TOTAL_TIMEOUT_CONSTANT );

               // save the current Power state of the reader
               SmartcardExtension->ReaderExtension->ReaderPowerState = PowerReaderOff;

               Action = SkipRequest;
               break;

            default:
               Action = SkipRequest;
               break;
            }
         } else {
            Action = SkipRequest;
            break;
         }
         break;

      case SystemPowerState: {
            //
            // The system wants to change the power state.
            // We need to translate the system power state to
            // a corresponding device power state.
            //
            POWER_STATE_TYPE  PowerType = DevicePowerState;

            ASSERT(SmartcardExtension->ReaderExtension->ReaderPowerState !=
                   PowerReaderUnspecified);

            switch ( IrpStack->MinorFunction ) {

            case IRP_MN_QUERY_POWER:

               SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvPowerHandler: Query Power\n" ));

               switch (IrpStack->Parameters.Power.State.SystemState) {

               case PowerSystemMaximum:
               case PowerSystemWorking:
               case PowerSystemSleeping1:
               case PowerSystemSleeping2:
                  Action = SkipRequest;
                  break;

               case PowerSystemSleeping3:
               case PowerSystemHibernate:
               case PowerSystemShutdown:
                  KeAcquireSpinLock(&DeviceExtension->SpinLock, &irql);
                  if (DeviceExtension->IoCount == 0) {

                     // Block any further ioctls
                     KeClearEvent(&DeviceExtension->ReaderStarted);
                     Action = SkipRequest;

                  } else {

                     // can't go to sleep mode since the reader is busy.
                     NTStatus = STATUS_DEVICE_BUSY;
                     Action = CompleteRequest;
                  }
                  KeReleaseSpinLock(&DeviceExtension->SpinLock, irql);
                  break;
               }
               break;

            case IRP_MN_SET_POWER:

               SmartcardDebug(
                             DEBUG_DRIVER,
                             ( "SCMSTCS!DrvPowerHandler: PowerSystem S%d\n", IrpStack->Parameters.Power.State.SystemState - 1 )
                             );

               switch (IrpStack->Parameters.Power.State.SystemState) {
               case PowerSystemMaximum:
               case PowerSystemWorking:
               case PowerSystemSleeping1:
               case PowerSystemSleeping2:

                  if ( SmartcardExtension->ReaderExtension->ReaderPowerState ==
                       PowerReaderWorking) {
                     // We're already in the right state
                     KeSetEvent(&DeviceExtension->ReaderStarted, 0, FALSE);
                     Action = SkipRequest;
                     break;
                  }

                  PowerState.DeviceState = PowerDeviceD0;

                  // wake up the underlying stack...
                  Action = MarkPending;
                  break;

               case PowerSystemSleeping3:
               case PowerSystemHibernate:
               case PowerSystemShutdown:

                  if ( SmartcardExtension->ReaderExtension->ReaderPowerState == PowerReaderOff ) {
                     // We're already in the right state
                     Action = SkipRequest;
                     break;
                  }

                  PowerState.DeviceState = PowerDeviceD3;

                  // first, inform the Power manager of our new state.
                  PoSetPowerState (
                                  DeviceObject,
                                  SystemPowerState,
                                  PowerState
                                  );
                  Action = MarkPending;
                  break;

               default:
                  Action = CompleteRequest;
                  break;
               }
               break;

            default:
               Action = SkipRequest;
               break;
            }
         }
         break;

      default:
         Action = CompleteRequest;
         break;
      }


      switch( Action )
      {
         case CompleteRequest:
            Irp->IoStatus.Status    = NTStatus;
            Irp->IoStatus.Information  = 0;

            SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'rwoP');

            PoStartNextPowerIrp( Irp );

            IoCompleteRequest( Irp, IO_NO_INCREMENT );
            break;

         case MarkPending:

            // initialize the event we need in the completion function
            KeInitializeEvent(
               &event,
               NotificationEvent,
               FALSE
               );

            // request the device power irp
            NTStatus = PoRequestPowerIrp (
               DeviceObject,
               IRP_MN_SET_POWER,
               PowerState,
               DrvSystemPowerCompletion,
               &event,
               NULL
               );

            if (NTStatus == STATUS_PENDING) {

               // wait until the device power irp completed
               NTStatus = KeWaitForSingleObject(
                  &event,
                  Executive,
                  KernelMode,
                  FALSE,
                  NULL
                  );

               SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'rwoP');

               if (PowerState.SystemState == PowerSystemWorking) {

                  PoSetPowerState (
                     DeviceObject,
                     SystemPowerState,
                     PowerState
                     );
               }

               PoStartNextPowerIrp(Irp);
               IoSkipCurrentIrpStackLocation(Irp);
               NTStatus = PoCallDriver(AttachedDeviceObject, Irp);

            } else {

               SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'rwoP');
               Irp->IoStatus.Status = NTStatus;
               IoCompleteRequest(Irp, IO_NO_INCREMENT);
            }

            break;

         case SkipRequest:
            SmartcardReleaseRemoveLockWithTag(SmartcardExtension, 'rwoP');

            PoStartNextPowerIrp( Irp );
            IoSkipCurrentIrpStackLocation( Irp );
            NTStatus = PoCallDriver( AttachedDeviceObject, Irp );
            break;

         case WaitForCompletion:
            NTStatus = PoCallDriver( AttachedDeviceObject, Irp );
            break;

         default:
            break;
      }
   }
   SmartcardDebug( DEBUG_DRIVER, ( "SCMSTCS!DrvPowerHandler: Exit %X\n", NTStatus ));

   return( NTStatus );
}



void
SysDelay(
   ULONG Timeout
   )
/*++

SysDelay:
   performs a required delay

Arguments:
   Timeout     delay in milliseconds

--*/
{

   if( KeGetCurrentIrql() >= DISPATCH_LEVEL )
   {
      ULONG Cnt = 20 * Timeout;
      while( Cnt-- )
      {
         // KeStallExecutionProcessor: counted in us
         KeStallExecutionProcessor( 50 );
      }
   }
   else
   {
      LARGE_INTEGER SysTimeout;

      SysTimeout.QuadPart =
         (LONGLONG) Timeout * -10 * 1000;

      // KeDelayExecutionThread: counted in 100 ns
      KeDelayExecutionThread( KernelMode, FALSE, &SysTimeout );
   }
   return;
}

//_________________________________________ END OF FILE _________________________________________