windows-server-2003/drivers/smartcrd/sccmusbm/scusbcb.c

/*****************************************************************************
@doc            INT EXT
******************************************************************************
* $ProjectName:  $
* $ProjectRevision:  $
*-----------------------------------------------------------------------------
* $Source: z:/pr/cmeu0/sw/sccmusbm.ms/rcs/scusbcb.c $
* $Revision: 1.9 $
*-----------------------------------------------------------------------------
* $Author: WFrischauf $
*-----------------------------------------------------------------------------
* History: see EOF
*-----------------------------------------------------------------------------
*
* Copyright � 2000 OMNIKEY AG
******************************************************************************/
#include "wdm.h"
#include "stdarg.h"
#include "stdio.h"

#include "usbdi.h"
#include "usbdlib.h"


#include "sccmusbm.h"


ULONG dataRatesSupported[]    = { 9600, 19200, 38400, 76800, 115200};
ULONG CLKFrequenciesSupported[] = {3571};


/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_StartCardTracking(
                                IN PDEVICE_OBJECT DeviceObject
                                )
{
    NTSTATUS NTStatus;
    HANDLE hThread;
    PDEVICE_EXTENSION    DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension;
    

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


   // settings for thread synchronization
    SmartcardExtension->ReaderExtension->TimeToTerminateThread = FALSE;
    SmartcardExtension->ReaderExtension->fThreadTerminated     = FALSE;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!StartCardTracking: Enter\n",DRIVER_NAME));

    KeWaitForSingleObject(&SmartcardExtension->ReaderExtension->CardManIOMutex,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

   // create thread for updating current state
    NTStatus = PsCreateSystemThread(&hThread,
                                    THREAD_ALL_ACCESS,
                                    NULL,
                                    NULL,
                                    NULL,
                                    CMUSB_UpdateCurrentStateThread,
                                    DeviceObject);
   if (!NT_ERROR(NTStatus))
      {
      //
      // We've got the thread.  Now get a pointer to it.
      //

      NTStatus = ObReferenceObjectByHandle(hThread,
                                           THREAD_ALL_ACCESS,
                                           NULL,
                                           KernelMode,
                                           &SmartcardExtension->ReaderExtension->ThreadObjectPointer,
                                           NULL);

      if (NT_ERROR(NTStatus))
         {
         SmartcardExtension->ReaderExtension->TimeToTerminateThread = TRUE;
         }
      else
         {
         //
         // Now that we have a reference to the thread
         // we can simply close the handle.
         //
         ZwClose(hThread);
         }
      }


    SmartcardDebug(DEBUG_DRIVER,
                   ("%s!StartCardTracking: -----------------------------------------------------------\n",DRIVER_NAME));
    SmartcardDebug(DEBUG_DRIVER,
                   ("%s!StartCardTracking: STARTING THREAD\n",DRIVER_NAME));
    SmartcardDebug(DEBUG_DRIVER,
                   ("%s!StartCardTracking: -----------------------------------------------------------\n",DRIVER_NAME));
    KeReleaseMutex(&SmartcardExtension->ReaderExtension->CardManIOMutex,
                   FALSE);


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!StartCardTracking: Exit %lx\n",DRIVER_NAME,NTStatus));

    return NTStatus;
}




/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
VOID CMUSB_StopCardTracking(
                           IN PDEVICE_OBJECT DeviceObject
                           )
{
    PDEVICE_EXTENSION    DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!StopCardTracking: Enter\n",DRIVER_NAME));

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

    if (SmartcardExtension->ReaderExtension->fThreadTerminated == FALSE) {

        SmartcardDebug(DEBUG_DRIVER,
                       ("%s!StopCardTracking: waiting for mutex\n",DRIVER_NAME));

      // kill thread
        KeWaitForSingleObject(&SmartcardExtension->ReaderExtension->CardManIOMutex,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        SmartcardExtension->ReaderExtension->TimeToTerminateThread = TRUE;

        KeReleaseMutex(&SmartcardExtension->ReaderExtension->CardManIOMutex,FALSE);

        KeWaitForSingleObject(SmartcardExtension->ReaderExtension->ThreadObjectPointer,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        ObDereferenceObject(SmartcardExtension->ReaderExtension->ThreadObjectPointer);

    }

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!StopCardTracking: Exit\n",DRIVER_NAME));

}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
VOID CMUSB_UpdateCurrentStateThread(
                                   IN PVOID Context
                                   )

{
    PDEVICE_OBJECT DeviceObject  = Context;
    PDEVICE_EXTENSION    DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension;
    NTSTATUS NTStatus,DebugStatus;
    ULONG ulInterval;

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

    KeWaitForSingleObject(&DeviceExtension->CanRunUpdateThread,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

    SmartcardDebug(DEBUG_DRIVER,
                   ("%s!UpdateCurrentStateThread started\n",DRIVER_NAME));

    do {
      // every 500 ms  the s NTStatus request is sent
        ulInterval = 500;
        KeWaitForSingleObject(&SmartcardExtension->ReaderExtension->CardManIOMutex,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        if ( SmartcardExtension->ReaderExtension->TimeToTerminateThread ) {
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!UpdateCurrentStateThread: -----------------------------------------\n",DRIVER_NAME));
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!UpdateCurrentStateThread: STOPPING THREAD\n",DRIVER_NAME));
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!UpdateCurrentStateThread: -----------------------------------------\n",DRIVER_NAME));

            KeReleaseMutex(&SmartcardExtension->ReaderExtension->CardManIOMutex,FALSE);
            SmartcardExtension->ReaderExtension->fThreadTerminated = TRUE;
            PsTerminateSystemThread( STATUS_SUCCESS );
        }

        NTStatus = CMUSB_UpdateCurrentState (DeviceObject);
        if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!setting update interval to 1ms\n",DRIVER_NAME));

            ulInterval = 1;
        } else if (NTStatus != STATUS_SUCCESS) {
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!NO STATUS RECEIVED\n",DRIVER_NAME));
        }

        KeReleaseMutex(&SmartcardExtension->ReaderExtension->CardManIOMutex,FALSE);

        CMUSB_Wait (ulInterval);
    }
    while (TRUE);
}



NTSTATUS CMUSB_UpdateCurrentState(
                                 IN PDEVICE_OBJECT DeviceObject
                                 )
{
    NTSTATUS             NTStatus;
    PDEVICE_EXTENSION    DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension;
    BOOLEAN              fCardStateChanged = FALSE;
    ULONG                ulBytesRead;
    KIRQL                irql;

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


    SmartcardExtension->SmartcardRequest.BufferLength = 0;
    NTStatus = CMUSB_WriteP0(DeviceObject,
                             0x20,         //bRequest,
                             0x00,         //bValueLo,
                             0x00,         //bValueHi,
                             0x00,         //bIndexLo,
                             0x00          //bIndexHi,
                            );

    if (NTStatus == STATUS_SUCCESS) {
        SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
        SmartcardExtension->SmartcardReply.BufferLength = 1;

        NTStatus = CMUSB_ReadP1(DeviceObject);

        ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;
        if (NTStatus == STATUS_SUCCESS && ulBytesRead == 1) { /* we got the NTStatus information */

            if ((SmartcardExtension->SmartcardReply.Buffer[0] & 0x40) == 0x40) {
                if ((SmartcardExtension->SmartcardReply.Buffer[0] & 0x80) == 0x80) {
                    SmartcardExtension->ReaderExtension->ulNewCardState = POWERED;
                } else {
                    SmartcardExtension->ReaderExtension->ulNewCardState = INSERTED;
                }
            } else {
                SmartcardExtension->ReaderExtension->ulNewCardState = REMOVED;
            }

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

            if (SmartcardExtension->ReaderExtension->ulNewCardState == INSERTED &&
                SmartcardExtension->ReaderExtension->ulOldCardState == POWERED ) {
            // card has been removed and reinserted
                SmartcardExtension->ReaderExtension->ulNewCardState = REMOVED;
            }

            if (SmartcardExtension->ReaderExtension->ulNewCardState  == INSERTED &&
                (SmartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN ||
                 SmartcardExtension->ReaderExtension->ulOldCardState == REMOVED )) {
            // card has been inserted
                SmartcardDebug(DEBUG_DRIVER,( "%s!UpdateCurrentStateThread Smartcard inserted\n",DRIVER_NAME));
                fCardStateChanged = TRUE;
                SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
                SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
            }


         // state after reset of the PC
            if (SmartcardExtension->ReaderExtension->ulNewCardState == POWERED &&
                SmartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN    ) {
            // card has been inserted
                SmartcardDebug(DEBUG_DRIVER,( "%s!UpdateCurrentStateThread Smartcard inserted (and powered)\n",DRIVER_NAME));
                fCardStateChanged = TRUE;
                SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
                SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
            }


            if (SmartcardExtension->ReaderExtension->ulNewCardState == REMOVED      &&
                (SmartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN  ||
                 SmartcardExtension->ReaderExtension->ulOldCardState == INSERTED ||
                 SmartcardExtension->ReaderExtension->ulOldCardState == POWERED    )   ) {
            // card has been removed
                fCardStateChanged = TRUE;
                SmartcardDebug(DEBUG_DRIVER,( "%s!UpdateCurrentStateThread Smartcard removed\n",DRIVER_NAME));

                SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_ABSENT;
                SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
                SmartcardExtension->CardCapabilities.ATR.Length        = 0;


                RtlFillMemory((PVOID)&SmartcardExtension->ReaderExtension->CardParameters,
                              sizeof(CARD_PARAMETERS),
                              0x00);
            }

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

         // complete IOCTL_SMARTCARD_IS_ABSENT or IOCTL_SMARTCARD_IS_PRESENT
            if (fCardStateChanged == TRUE &&
                SmartcardExtension->OsData->NotificationIrp != NULL) {
                SmartcardDebug(DEBUG_DRIVER,("%s!UpdateCurrentStateThread: completing IRP\n",DRIVER_NAME));
                CMUSB_CompleteCardTracking(SmartcardExtension);
            }

         // save old state
            SmartcardExtension->ReaderExtension->ulOldCardState = SmartcardExtension->ReaderExtension->ulNewCardState;

        }
    }

    return NTStatus;
}


/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
VOID CMUSB_CompleteCardTracking(
                               IN PSMARTCARD_EXTENSION SmartcardExtension
                               )
{
    KIRQL ioIrql, keIrql;
    PIRP notificationIrp;

    IoAcquireCancelSpinLock(&ioIrql);
    KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock, &keIrql);

    notificationIrp = SmartcardExtension->OsData->NotificationIrp;
    SmartcardExtension->OsData->NotificationIrp = NULL;

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

    if (notificationIrp) {
        IoSetCancelRoutine(notificationIrp,NULL);
    }

    IoReleaseCancelSpinLock(ioIrql);

    if (notificationIrp) {
        SmartcardDebug(DEBUG_DRIVER,
                       ("%s!CompleteCardTracking: Completing NotificationIrp %lxh\n",DRIVER_NAME,notificationIrp));

      //    finish the request
        if (notificationIrp->Cancel) {
            notificationIrp->IoStatus.Status = STATUS_CANCELLED;
        } else {
            notificationIrp->IoStatus.Status = STATUS_SUCCESS;
        }

        notificationIrp->IoStatus.Information = 0;

        IoCompleteRequest(notificationIrp, IO_NO_INCREMENT);
    }
}



/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_Wait (ULONG ulMilliseconds)
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    LARGE_INTEGER   WaitTime;

   // -10000 indicates 1ms relativ
    WaitTime = RtlConvertLongToLargeInteger(ulMilliseconds * -10000);
    KeDelayExecutionThread(KernelMode,FALSE,&WaitTime);

    return NTStatus;
}


/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_CreateClose(
                          IN PDEVICE_OBJECT DeviceObject,
                          IN PIRP Irp
                          )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION DeviceExtension;
    PSMARTCARD_EXTENSION  SmartcardExtension;
    PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CreateClose: Enter\n",DRIVER_NAME));

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

   //
   //   dispatch major function
   //
    switch (IrpStack->MajorFunction) {
    case IRP_MJ_CREATE:
        SmartcardDebug(DEBUG_DRIVER,
                       ("%s!CreateClose: IRP_MJ_CREATE\n",DRIVER_NAME));
        if (DeviceExtension->RemoveDeviceRequested) {
            NTStatus = STATUS_DEVICE_BUSY;
        } else {
            if (InterlockedIncrement(&DeviceExtension->lOpenCount) > 1) {
                InterlockedDecrement(&DeviceExtension->lOpenCount);
                NTStatus = STATUS_ACCESS_DENIED;
            }
        }
        break;

    case IRP_MJ_CLOSE:
        SmartcardDebug(DEBUG_DRIVER,
                       ("%s!CreateClose: IRP_MJ_CLOSE\n",DRIVER_NAME));
        if (InterlockedDecrement(&DeviceExtension->lOpenCount) < 0) {
            InterlockedIncrement(&DeviceExtension->lOpenCount);
        }

         // check if the device has been removed
         // if so free the resources
        if (DeviceExtension->DeviceRemoved == TRUE) {
            SmartcardDebug(DEBUG_DRIVER,
                           ("%s!CreateClose: freeing resources\n",DRIVER_NAME));

            if (DeviceExtension->fPnPResourceManager == FALSE) {
               //
               // Free all allocated buffer
               //
                ExFreePool(DeviceExtension->DosDeviceName.Buffer);
            }

            ExFreePool(SmartcardExtension->ReaderExtension);
            SmartcardExtension->ReaderExtension = NULL;
            //
            // Let the lib free the send/receive buffers
            //
            SmartcardExit(SmartcardExtension);
        }

        break;


    default:
         //
         // unrecognized command
         //
        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 %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}


/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_Transmit(
                       IN PSMARTCARD_EXTENSION SmartcardExtension
                       )
{
    NTSTATUS NTStatus;

   //this seems to make problems in Windows 98
   //KeSetPriorityThread(KeGetCurrentThread(),HIGH_PRIORITY);


    switch (SmartcardExtension->CardCapabilities.Protocol.Selected) {
    case SCARD_PROTOCOL_RAW:
        NTStatus = STATUS_INVALID_DEVICE_REQUEST;
        break;

    case SCARD_PROTOCOL_T0:

        NTStatus = CMUSB_TransmitT0(SmartcardExtension);

        break;

    case SCARD_PROTOCOL_T1:
        NTStatus = CMUSB_TransmitT1(SmartcardExtension);
        break;

    default:
        NTStatus = STATUS_INVALID_DEVICE_REQUEST;
        break;

    }
   //KeSetPriorityThread(KeGetCurrentThread(),LOW_REALTIME_PRIORITY);

    return NTStatus;

}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_ResetT0ReadBuffer(
                                PSMARTCARD_EXTENSION SmartcardExtension
                                )
{

    SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByte     = -1;
    SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByteRead = -1;

    return STATUS_SUCCESS;
}



/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_ReadT0(
                     PSMARTCARD_EXTENSION SmartcardExtension
                     )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    NTSTATUS DebugStatus;
    LONG  lBytesToRead;
    LONG  lBytesRead;
    LONG  lLastByte;
    LONG  lLastByteRead;
    PDEVICE_EXTENSION DeviceExtension;
    PUSBD_PIPE_INFORMATION pipeHandle = NULL;
    PUSBD_INTERFACE_INFORMATION interface;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadT0: Enter\n",DRIVER_NAME));


    DeviceExtension =  SmartcardExtension->OsData->DeviceObject->DeviceExtension;
    interface       = DeviceExtension->UsbInterface;
    pipeHandle      =  &interface->Pipes[0];

    lBytesToRead = (LONG)SmartcardExtension->SmartcardReply.BufferLength;
    lLastByte     = SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByte;
    lLastByteRead = SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByteRead;

   // check if further bytes must be read from pipe 1
    while (lLastByteRead + lBytesToRead > lLastByte) {
        SmartcardExtension->SmartcardReply.BufferLength = 1;
        SmartcardExtension->ReaderExtension->ulTimeoutP1 = 1000 +
                                                           (ULONG)((SmartcardExtension->CardCapabilities.T0.WT/1000) * lBytesToRead);
        NTStatus = CMUSB_ReadP1(SmartcardExtension->OsData->DeviceObject);
        if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
            DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
            goto ExitReadT0;
        } else if (NTStatus != STATUS_SUCCESS) {
            goto ExitReadT0;
        }


        lBytesRead = (LONG)SmartcardExtension->SmartcardReply.BufferLength;

        RtlCopyBytes((PVOID)(SmartcardExtension->ReaderExtension->T0ReadBuffer + (lLastByte +1)),
                     (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                     lBytesRead);

        lLastByte  += lBytesRead;


    } // end of while

   // copy bytes
    SmartcardExtension->SmartcardReply.BufferLength  = lBytesToRead;
    RtlCopyBytes ((PVOID)SmartcardExtension->SmartcardReply.Buffer,
                  (PVOID)(SmartcardExtension->ReaderExtension->T0ReadBuffer + (lLastByteRead +1)),
                  lBytesToRead);

    lLastByteRead  += lBytesToRead;

/*
   SmartcardDebug(DEBUG_TRACE,
                  ("%s!lBytesToRead=%ld lLastByte=%ld lLastByteRead=%ld\n",
                   DRIVER_NAME,
                   lBytesToRead,
                   lLastByte,
                   lLastByteRead)
                 );
*/


    SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByte     = lLastByte;
    SmartcardExtension->ReaderExtension->T0ReadBuffer_OffsetLastByteRead = lLastByteRead;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadT0: Exit %lx\n",DRIVER_NAME,NTStatus));

    ExitReadT0:
    return NTStatus;
}


/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
#define T0_HEADER_LEN               0x05
#define T0_STATE_LEN                0x02
#define TIMEOUT_CANCEL_READ_P1     30000

NTSTATUS CMUSB_TransmitT0(
                         PSMARTCARD_EXTENSION SmartcardExtension
                         )
{
    NTSTATUS NTStatus;
    NTSTATUS DebugStatus;
    UCHAR    bWriteBuffer[CMUSB_BUFFER_SIZE];
    UCHAR    bReadBuffer [CMUSB_BUFFER_SIZE];
    ULONG    ulWriteBufferOffset;
    ULONG    ulReadBufferOffset;
    ULONG    ulBytesToWrite;
    ULONG    ulBytesToRead;
    ULONG    ulBytesToWriteThisStep;
    ULONG    ulBytesToReadThisStep;
    ULONG    ulBytesStillToWrite;
    ULONG    ulBytesRead;
    ULONG    ulBytesStillToRead;
    BOOLEAN  fDataDirectionFromCard;
    BYTE     bProcedureByte;
    BYTE     bINS;
    BOOLEAN  fT0TransferToCard;
    BOOLEAN  fT0TransferFromCard;
    BOOLEAN  fSW1SW2Sent;
    ULONG    ulUsedCWT;
    UCHAR    bUsedCWTHi;
    LARGE_INTEGER liTimeout;
    PDEVICE_EXTENSION DeviceExtension;
    UCHAR    bTmp;
    ULONG    i;
    PUSBD_PIPE_INFORMATION pipeHandle = NULL;
    PUSBD_INTERFACE_INFORMATION interface;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!TransmitT0 : Enter\n",DRIVER_NAME));

    fT0TransferToCard = FALSE;
    fT0TransferFromCard = FALSE;
    fSW1SW2Sent = FALSE;

   // resync CardManUSB by reading the NTStatus byte
    SmartcardExtension->SmartcardRequest.BufferLength = 0;
    NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                             0x20,         //bRequest,
                             0x00,         //bValueLo,
                             0x00,         //bValueHi,
                             0x00,         //bIndexLo,
                             0x00          //bIndexHi,
                            );

    if (NTStatus != STATUS_SUCCESS) {
      // if we can't read the NTStatus there must be a serious error
        goto ExitTransmitT0;
    }

    SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
    SmartcardExtension->SmartcardReply.BufferLength = 1;
    NTStatus = CMUSB_ReadP1(SmartcardExtension->OsData->DeviceObject);
    if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
        DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
        goto ExitTransmitT0;
    } else if (NTStatus != STATUS_SUCCESS) {
      // if we can't read the NTStatus there must be a serious error
        goto ExitTransmitT0;
    }



    DeviceExtension =  SmartcardExtension->OsData->DeviceObject->DeviceExtension;
    interface       = DeviceExtension->UsbInterface;
    pipeHandle      =  &interface->Pipes[0];

    SmartcardExtension->ReaderExtension->ulTimeoutP1 = (ULONG)(SmartcardExtension->CardCapabilities.T0.WT/1000);


   //
   // Let the lib build a T=0 packet
   //

    SmartcardExtension->SmartcardRequest.BufferLength = 0;  // no bytes additionally needed
    NTStatus = SmartcardT0Request(SmartcardExtension);
    if (NTStatus != STATUS_SUCCESS) {
      //
      // This lib detected an error in the data to send.
      //
        goto ExitTransmitT0;
    }


    ulBytesStillToWrite = ulBytesToWrite = T0_HEADER_LEN + SmartcardExtension->T0.Lc;
    ulBytesStillToRead  = ulBytesToRead  = SmartcardExtension->T0.Le;
    if (SmartcardExtension->T0.Lc)
        fT0TransferToCard = TRUE;
    if (SmartcardExtension->T0.Le)
        fT0TransferFromCard = TRUE;



   // ----------------------------
   // smart card ==> CardMan USB
   // ----------------------------
    if (fT0TransferFromCard) {
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: MODE 3\n",DRIVER_NAME));

      // granularity 256 ms
        ulUsedCWT = (ULONG)(SmartcardExtension->CardCapabilities.T0.WT/1000);
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: ulUsedCWT= %ld\n",DRIVER_NAME,ulUsedCWT));

        bUsedCWTHi = (UCHAR)(((ulUsedCWT & 0x0000FF00)>>8) + 1 + 5) ;

      // copy data to the write buffer
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: CLA = %x INS = %x P1 = %x P2 = %x L = %x\n", DRIVER_NAME,
                        SmartcardExtension->SmartcardRequest.Buffer[0],
                        SmartcardExtension->SmartcardRequest.Buffer[1],
                        SmartcardExtension->SmartcardRequest.Buffer[2],
                        SmartcardExtension->SmartcardRequest.Buffer[3],
                        SmartcardExtension->SmartcardRequest.Buffer[4]));


        RtlCopyBytes((PVOID)bWriteBuffer,
                     (PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                     ulBytesToWrite);

        bINS = bWriteBuffer[1];

        ulWriteBufferOffset = 0;
        ulReadBufferOffset = 0;


      // STEP 1 : write CLA INS P1 P2 Lc

        ulBytesToWriteThisStep = 5;
        RtlCopyBytes((PVOID)(SmartcardExtension->SmartcardRequest.Buffer),
                     (PVOID)(bWriteBuffer+ulWriteBufferOffset),
                     ulBytesToWriteThisStep);

        if (SmartcardExtension->ReaderExtension->fInverseAtr == TRUE) {
            CMUSB_InverseBuffer(SmartcardExtension->SmartcardRequest.Buffer,
                                SmartcardExtension->SmartcardRequest.BufferLength);
        }

        SmartcardExtension->SmartcardReply.BufferLength = 512;
        NTStatus = CMUSB_ReadP1_T0(SmartcardExtension->OsData->DeviceObject);
        if (NTStatus != STATUS_SUCCESS) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!TransmitT0: CMUSB_ReadP1_T0 returned = %x\n",DRIVER_NAME,NTStatus));
            goto ExitTransmitT0;
        }


        SmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWriteThisStep;
        NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                 0x03,                       // mode 3
                                 bUsedCWTHi,                 //bValueLo,
                                 0x00,                       //bValueHi,
                                 (UCHAR)(ulBytesToRead%256), //bIndexLo,
                                 (UCHAR)(SmartcardExtension->SmartcardRequest.Buffer[1]) //bIndexHi,
                                );
        if (NTStatus != STATUS_SUCCESS) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!TransmitT0: CMUSB_WriteP0 returned %x\n",DRIVER_NAME,NTStatus));
            goto ExitTransmitT0;
        }




        liTimeout = RtlConvertLongToLargeInteger(TIMEOUT_CANCEL_READ_P1 * -10000);

        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: waiting for P1 event\n",DRIVER_NAME,NTStatus));

        NTStatus = KeWaitForSingleObject(&DeviceExtension->ReadP1Completed,
                                         Executive,
                                         KernelMode,
                                         FALSE,
                                         &liTimeout);

      // -----------------------------
      // check if P1 has been stalled
      // -----------------------------
        if (SmartcardExtension->ReaderExtension->fP1Stalled == TRUE) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!STransmitT0: TATUS_DEVICE_DATA_ERROR\n",DRIVER_NAME));
            NTStatus = STATUS_DEVICE_DATA_ERROR;

         // P1 has been stalled ==> we must reset the pipe and send a NTStatus to enable it again
            DebugStatus = CMUSB_ResetPipe(SmartcardExtension->OsData->DeviceObject,
                                          pipeHandle);

            DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);

            SmartcardExtension->SmartcardReply.BufferLength = 0;
            goto ExitTransmitT0;
        }
      // -------------------------------
      // check if a timeout has occured
      // -------------------------------
        else if (NTStatus == STATUS_TIMEOUT) {
         // probably the smart card does not work
         // cancel T0 read operation by sending any P0 command
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!TransmitT0: cancelling read operation\n",DRIVER_NAME));
            SmartcardExtension->SmartcardRequest.BufferLength = 0;
            NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                     0x20,         //bRequest,
                                     0x00,         //bValueLo,
                                     0x00,         //bValueHi,
                                     0x00,         //bIndexLo,
                                     0x00          //bIndexHi,
                                    );

            NTStatus = STATUS_IO_TIMEOUT;
            goto ExitTransmitT0;
        }
      // -------------------------------------------
      // check if at least 9 bytes have been sent
      // -------------------------------------------
        else if (SmartcardExtension->SmartcardReply.BufferLength < 9) {
            NTStatus = STATUS_UNSUCCESSFUL;
            goto ExitTransmitT0;
        } else {


#if DBG
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!<==[P1] ",DRIVER_NAME));
            for (i=0;i< SmartcardExtension->SmartcardReply.BufferLength;i++) {
                bTmp =  SmartcardExtension->SmartcardReply.Buffer[i];
                if (SmartcardExtension->ReaderExtension->fInverseAtr &&
                    SmartcardExtension->ReaderExtension->ulTimeoutP1 != DEFAULT_TIMEOUT_P1) {
               //CMUSB_InverseBuffer(&bTmp,1);
                    SmartcardDebug(DEBUG_PROTOCOL,("%x ",bTmp));
                } else {
                    SmartcardDebug(DEBUG_PROTOCOL,("%x ",bTmp));
                }
            }
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("(%ld)\n",SmartcardExtension->SmartcardReply.BufferLength));
#endif


         // ignore the first 8 dummy bytes
            SmartcardExtension->SmartcardReply.BufferLength -= 8;
            RtlCopyBytes((PVOID)(bReadBuffer),
                         (PVOID)(SmartcardExtension->SmartcardReply.Buffer+8),
                         SmartcardExtension->SmartcardReply.BufferLength);

            RtlCopyBytes((PVOID)(SmartcardExtension->SmartcardReply.Buffer),
                         (PVOID)(bReadBuffer),
                         SmartcardExtension->SmartcardReply.BufferLength);

            if (SmartcardExtension->ReaderExtension->fInverseAtr) {
                CMUSB_InverseBuffer(SmartcardExtension->SmartcardReply.Buffer,
                                    SmartcardExtension->SmartcardReply.BufferLength);
            }

        }
    }

   // -----------------------------
   // CardMan USB ==> smart card or
   // no transfer
   // -----------------------------
    else {


        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: MODE 2\n",DRIVER_NAME));

      // copy data to the write buffer
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s!TransmitT0: CLA = %x INS = %x P1 = %x P2 = %X L = %x\n",DRIVER_NAME,
                        SmartcardExtension->SmartcardRequest.Buffer[0],
                        SmartcardExtension->SmartcardRequest.Buffer[1],
                        SmartcardExtension->SmartcardRequest.Buffer[2],
                        SmartcardExtension->SmartcardRequest.Buffer[3],
                        SmartcardExtension->SmartcardRequest.Buffer[4]));


        RtlCopyBytes((PVOID)bWriteBuffer,
                     (PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                     ulBytesToWrite);




      // SendingToCard:

        ulWriteBufferOffset = 0;
        ulReadBufferOffset = 0;
        bINS = bWriteBuffer[1];



      // STEP 1 : write CLA INS P1 P2 Lc

        ulBytesToWriteThisStep = 5;
        RtlCopyBytes((PVOID)(SmartcardExtension->SmartcardRequest.Buffer),
                     (PVOID)(bWriteBuffer+ulWriteBufferOffset),
                     ulBytesToWriteThisStep);
        SmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWriteThisStep;

        if (SmartcardExtension->ReaderExtension->fInverseAtr == TRUE) {
            CMUSB_InverseBuffer(SmartcardExtension->SmartcardRequest.Buffer,
                                SmartcardExtension->SmartcardRequest.BufferLength);
        }


        NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                 0x02,         //T=0
                                 0x00,         //bValueLo,
                                 0x00,         //bValueHi,
                                 0x00,         //bIndexLo,
                                 0x00          //bIndexHi,
                                );
        if (NTStatus != STATUS_SUCCESS) {
            goto ExitTransmitT0;
        }


        ulWriteBufferOffset += ulBytesToWriteThisStep;
        ulBytesStillToWrite -= ulBytesToWriteThisStep;

        NTStatus = CMUSB_ResetT0ReadBuffer(SmartcardExtension);

      // STEP 2 : read procedure byte
        do {
            do {
                SmartcardExtension->SmartcardReply.BufferLength = 1;
                NTStatus = CMUSB_ReadT0(SmartcardExtension);
                if (NTStatus != STATUS_SUCCESS) {
                    goto ExitTransmitT0;
                }
                ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;
                bProcedureByte = SmartcardExtension->SmartcardReply.Buffer[0];

                if (SmartcardExtension->ReaderExtension->fInverseAtr) {
                    CMUSB_InverseBuffer(&bProcedureByte,1);
                }

                SmartcardDebug(DEBUG_PROTOCOL,
                               ("%s!TransmitT0: procedure byte = %x\n",
                                DRIVER_NAME,
                                bProcedureByte));
                if (bProcedureByte == 0x60) {
               // wait work waitung time;
               // we just try to read again
                }
            } while (bProcedureByte == 0x60);


         // check for ACK
            if ((bProcedureByte & 0xFE) ==  (bINS & 0xFE) ) {
                ulBytesToWriteThisStep = ulBytesStillToWrite;
                if (ulBytesToWriteThisStep > 0) { // at least one byte must be sent to the card
                    RtlCopyBytes((PVOID)(SmartcardExtension->SmartcardRequest.Buffer),
                                 (PVOID)(bWriteBuffer+ulWriteBufferOffset),
                                 ulBytesToWriteThisStep);

                    SmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWriteThisStep;
                    if (SmartcardExtension->ReaderExtension->fInverseAtr == TRUE) {
                        CMUSB_InverseBuffer(SmartcardExtension->SmartcardRequest.Buffer,
                                            SmartcardExtension->SmartcardRequest.BufferLength);
                    }
                    NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                             0x02,         //bRequest,
                                             0x00,         //bValueLo,
                                             0x00,         //bValueHi,
                                             0x00,         //bIndexLo,
                                             0x00          //bIndexHi,
                                            );
                    if (NTStatus != STATUS_SUCCESS) {
                        goto ExitTransmitT0;
                    }
                    ulWriteBufferOffset += ulBytesToWriteThisStep;
                    ulBytesStillToWrite -= ulBytesToWriteThisStep;
                }
            }
         // check for NAK
            else if ( (~bProcedureByte & 0xFE) == (bINS & 0xFE)) {
                ulBytesToWriteThisStep = 1;
                RtlCopyBytes((PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                             (PVOID)(bWriteBuffer+ulWriteBufferOffset),
                             ulBytesToWriteThisStep);

                SmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWriteThisStep;
                if (SmartcardExtension->ReaderExtension->fInverseAtr == TRUE) {
                    CMUSB_InverseBuffer(SmartcardExtension->SmartcardRequest.Buffer,
                                        SmartcardExtension->SmartcardRequest.BufferLength);
                }
                NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                         0x02,         //bRequest,
                                         0x00,         //bValueLo,
                                         0x00,         //bValueHi,
                                         0x00,         //bIndexLo,
                                         0x00          //bIndexHi,
                                        );
                if (NTStatus != STATUS_SUCCESS) {
                    goto ExitTransmitT0;
                }
                ulWriteBufferOffset += ulBytesToWriteThisStep;
                ulBytesStillToWrite -= ulBytesToWriteThisStep;

            }
         // check for SW1
            else if ( (bProcedureByte > 0x60 && bProcedureByte <= 0x6F) ||
                      (bProcedureByte >= 0x90 && bProcedureByte <= 0x9F)   ) {
                bReadBuffer[ulReadBufferOffset] = SmartcardExtension->SmartcardReply.Buffer[0];
                ulReadBufferOffset++;

                SmartcardExtension->SmartcardReply.BufferLength = 1;
                NTStatus = CMUSB_ReadT0(SmartcardExtension);
                if (NTStatus != STATUS_SUCCESS) {
                    goto ExitTransmitT0;
                }
                ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;
                RtlCopyBytes((PVOID)(bReadBuffer + ulReadBufferOffset),
                             (PVOID)(SmartcardExtension->SmartcardReply.Buffer),
                             SmartcardExtension->SmartcardReply.BufferLength);
                ulReadBufferOffset += ulBytesRead;

                fSW1SW2Sent = TRUE;
            } else {
                NTStatus =  STATUS_UNSUCCESSFUL;
                goto ExitTransmitT0;
            }

        }while (!fSW1SW2Sent);

        if (SmartcardExtension->ReaderExtension->fInverseAtr) {
            CMUSB_InverseBuffer(bReadBuffer,
                                ulReadBufferOffset);
        }

      // copy received bytes
        RtlCopyBytes((PVOID)SmartcardExtension->SmartcardReply.Buffer,
                     (PVOID)bReadBuffer,
                     ulReadBufferOffset);
        SmartcardExtension->SmartcardReply.BufferLength = ulReadBufferOffset;

    }


   // let the lib copy the received bytes to the user buffer
    NTStatus = SmartcardT0Reply(SmartcardExtension);



    ExitTransmitT0:

   // ------------------------------------------
   // ITSEC E2 requirements: clear write buffers
   // ------------------------------------------
    RtlFillMemory((PVOID)bWriteBuffer,sizeof(bWriteBuffer),0x00);
    RtlFillMemory((PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                  SmartcardExtension->SmartcardRequest.BufferSize,0x00);

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!TransmitT0 : Exit %lx\n",DRIVER_NAME,NTStatus));

    return NTStatus;
}
#undef T0_HEADER_LEN
#undef T0_STATE_LEN
#undef TIMEOUT_CANCEL_READ_P1






/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_TransmitT1(
                         PSMARTCARD_EXTENSION SmartcardExtension
                         )
{
    NTSTATUS NTStatus;
    NTSTATUS DebugStatus;
    ULONG  ulBytesToRead;
    ULONG  ulCurrentWaitTime;
    ULONG  ulWTXWaitTime;
    LARGE_INTEGER   waitTime;
    BOOLEAN         fStateTimer;
    ULONG   ulTemp;
    PDEVICE_EXTENSION DeviceExtension;
    PUSBD_INTERFACE_INFORMATION interface;
    PUSBD_PIPE_INFORMATION pipeHandle = NULL;
    BOOLEAN   fCancelTimer = FALSE;
    BYTE bTemp;
    BYTE  bMultiplier;


    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!TransmitT1: CWT = %ld(ms)\n",DRIVER_NAME,
                    SmartcardExtension->CardCapabilities.T1.CWT/1000));
    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!TransmitT1: BWT = %ld(ms)\n",DRIVER_NAME,
                    SmartcardExtension->CardCapabilities.T1.BWT/1000));


    DeviceExtension = SmartcardExtension->OsData->DeviceObject->DeviceExtension;
    interface       = DeviceExtension->UsbInterface;
    pipeHandle      =  &interface->Pipes[0];


    ulCurrentWaitTime = (ULONG)(1000 + SmartcardExtension->CardCapabilities.T1.BWT/1000);
    ulWTXWaitTime     = 0;

    do {


        SmartcardExtension->SmartcardRequest.BufferLength = 0;


        NTStatus = SmartcardT1Request(SmartcardExtension);
        if (NTStatus != STATUS_SUCCESS) {
         // this should never happen, so we return immediately
            goto ExitTransmitT1;
        }



        NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                 0x01,         //T=1
                                 0x00,         //bValueLo,
                                 0x00,         //bValueHi,
                                 0x00,         //bIndexLo,
                                 0x00          //bIndexHi,
                                );

        if (NTStatus != STATUS_SUCCESS)
            break;  // there must be severe error

        if (ulWTXWaitTime ==  0 ) { // use BWT
            waitTime = RtlConvertLongToLargeInteger(ulCurrentWaitTime * -10000);
        } else { // use WTX time
            waitTime = RtlConvertLongToLargeInteger(ulWTXWaitTime * -10000);
        }
        KeSetTimer(&SmartcardExtension->ReaderExtension->WaitTimer,
                   waitTime,
                   NULL);
      // timer is now in the queue
        fCancelTimer = TRUE;
        ulTemp = 0;
        do {
            NTStatus = CMUSB_ReadP1(SmartcardExtension->OsData->DeviceObject);
            if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
                DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
                goto ExitTransmitT1;
            }

            fStateTimer = KeReadStateTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
            if (fStateTimer == TRUE) {
            // timer has been removed from the queue
                fCancelTimer = FALSE;
                SmartcardDebug(DEBUG_PROTOCOL,
                               ("%s!TransmitT1: T1 card does not respond in time\n",DRIVER_NAME));
                NTStatus = STATUS_IO_TIMEOUT;
                break;
            }

            if (SmartcardExtension->SmartcardReply.Buffer[0] >= 3) {
                if (SmartcardExtension->SmartcardReply.Buffer[1] > ulTemp) {
               // restart CWT for 32 bytes
                    ulCurrentWaitTime = (ULONG)(100 + 32*(SmartcardExtension->CardCapabilities.T1.CWT/1000));
                    waitTime = RtlConvertLongToLargeInteger(ulCurrentWaitTime * -10000);
                    KeSetTimer(&SmartcardExtension->ReaderExtension->WaitTimer,
                               waitTime,
                               NULL);
               // timer is in the queue
                    fCancelTimer = TRUE;
                    ulTemp = SmartcardExtension->SmartcardReply.Buffer[1];
                } else {
               // CardMan USB has not received further bytes
               // do nothing
                }

            }


        } while (SmartcardExtension->SmartcardReply.Buffer[0] < 3   ||
                 (SmartcardExtension->SmartcardReply.Buffer[0] !=
                  SmartcardExtension->SmartcardReply.Buffer[1] + 4 )  );


      // cancel timer now
        if (fCancelTimer == TRUE) {
            fCancelTimer = FALSE;
            KeCancelTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
         // timer is removed from the queue
        }




        if (NTStatus != STATUS_SUCCESS) {
            SmartcardExtension->SmartcardReply.BufferLength = 0L;
        } else {
            ulBytesToRead = SmartcardExtension->SmartcardReply.Buffer[0];

            SmartcardExtension->SmartcardReply.BufferLength = SmartcardExtension->SmartcardReply.Buffer[0];
            NTStatus = CMUSB_ReadP0(SmartcardExtension->OsData->DeviceObject);

        }


        bTemp = SmartcardExtension->SmartcardReply.Buffer[1];
        bMultiplier = SmartcardExtension->SmartcardReply.Buffer[3];
        if (SmartcardExtension->ReaderExtension->fInverseAtr == TRUE) {
            CMUSB_InverseBuffer(&bTemp,1);
            CMUSB_InverseBuffer(&bMultiplier,1);
        }


        if (bTemp == T1_WTX_REQUEST) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!TransmitT1: T1_WTX_REQUEST received\n",DRIVER_NAME));

            ulWTXWaitTime = (ULONG)(1000 +
                                    bMultiplier * (SmartcardExtension->CardCapabilities.T1.BWT/1000));
        } else {
            ulWTXWaitTime = 0;
        }




      // bug fix for smclib
        if (SmartcardExtension->T1.State         == T1_IFS_RESPONSE &&
            SmartcardExtension->T1.OriginalState == T1_I_BLOCK) {
            SmartcardExtension->T1.State = T1_I_BLOCK;
        }

        NTStatus = SmartcardT1Reply(SmartcardExtension);
    }
    while (NTStatus == STATUS_MORE_PROCESSING_REQUIRED);



    ExitTransmitT1:
   // ------------------------------------------
   // ITSEC E2 requirements: clear write buffers
   // ------------------------------------------
    RtlFillMemory((PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                  SmartcardExtension->SmartcardRequest.BufferSize,0x00);

   // timer will be cancelled here if there was an error
    if (fCancelTimer == TRUE) {
        KeCancelTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
      // timer is removed from the queue
    }
    return NTStatus;
}


/*****************************************************************************
Routine Description:
This function sets the desired protocol . If necessary a PTS is performed


Arguments:  pointer to SMARTCARD_EXTENSION



Return Value: NT NTStatus

*****************************************************************************/
NTSTATUS CMUSB_SetProtocol(
                          PSMARTCARD_EXTENSION SmartcardExtension
                          )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    NTSTATUS DebugStatus;
    ULONG ulNewProtocol;
    UCHAR abPTSRequest[4];
    UCHAR abReadBuffer[6];
    UCHAR abPTSReply [4];
    ULONG ulBytesRead;
    LARGE_INTEGER   liWaitTime;
    BOOLEAN         fStateTimer;
    ULONG           ulWaitTime;
    PDEVICE_EXTENSION DeviceExtension;
    PUSBD_PIPE_INFORMATION pipeHandle = NULL;
    PUSBD_INTERFACE_INFORMATION interface;
    UCHAR bTemp;
    BOOLEAN fCancelTimer = FALSE;
    KIRQL    irql;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetProtocol : Enter\n",DRIVER_NAME));

    DeviceExtension =  SmartcardExtension->OsData->DeviceObject->DeviceExtension;
    interface       = DeviceExtension->UsbInterface;
    pipeHandle      =  &interface->Pipes[0];


   //
   // Check if the card is already in specific state
   // and if the caller wants to have the already selected protocol.
   // We return success if this is the case.
   //

    if ((SmartcardExtension->CardCapabilities.Protocol.Selected & SmartcardExtension->MinorIoControlCode)) {
        NTStatus = STATUS_SUCCESS;
        goto ExitSetProtocol;
    }

    ulNewProtocol = SmartcardExtension->MinorIoControlCode;



    while (TRUE) {

      // set initial character of PTS
        abPTSRequest[0] = 0xFF;

      // set the format character
        if (SmartcardExtension->CardCapabilities.Protocol.Supported &
            ulNewProtocol &
            SCARD_PROTOCOL_T1) {
         // select T=1 and indicate that PTS1 follows
            abPTSRequest[1] = 0x11;
            SmartcardExtension->CardCapabilities.Protocol.Selected =
            SCARD_PROTOCOL_T1;
        } else if (SmartcardExtension->CardCapabilities.Protocol.Supported &
                   ulNewProtocol &
                   SCARD_PROTOCOL_T0) {
         // select T=1 and indicate that PTS1 follows
            abPTSRequest[1] = 0x10;
            SmartcardExtension->CardCapabilities.Protocol.Selected =
            SCARD_PROTOCOL_T0;
        } else {
            NTStatus = STATUS_INVALID_DEVICE_REQUEST;
            goto ExitSetProtocol;
        }


      // CardMan USB support higher baudrates only for T=1
      // ==> Dl=1
        if (abPTSRequest[1] == 0x10) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s! overwriting PTS1 for T=0\n",DRIVER_NAME));
            SmartcardExtension->CardCapabilities.PtsData.Dl = 0x01;
        }

      // set pts1 which codes Fl and Dl
        bTemp = (BYTE) (SmartcardExtension->CardCapabilities.PtsData.Fl << 4 |
                        SmartcardExtension->CardCapabilities.PtsData.Dl);

        switch (bTemp) {
        case 0x11:
        case 0x12:
        case 0x13:
        case 0x14:
        case 0x18:
        case 0x91:
        case 0x92:
        case 0x93:
        case 0x94:
        case 0x98:
            // do nothing
            // we support these Fl/Dl parameters
            break ;

        default:
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s! overwriting PTS1(0x%x)\n",DRIVER_NAME,bTemp));
            // we must correct Fl/Dl
            SmartcardExtension->CardCapabilities.PtsData.Dl = 0x01;
            SmartcardExtension->CardCapabilities.PtsData.Fl = 0x01;
            bTemp = (BYTE) (SmartcardExtension->CardCapabilities.PtsData.Fl << 4 |
                            SmartcardExtension->CardCapabilities.PtsData.Dl);
            break;


        }

        abPTSRequest[2] = bTemp;

      // set pck (check character)
        abPTSRequest[3] = (BYTE)(abPTSRequest[0] ^ abPTSRequest[1] ^ abPTSRequest[2]);

        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s! writing PTS request\n",DRIVER_NAME));

        RtlCopyBytes((PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                     (PVOID)abPTSRequest,
                     4);
        SmartcardExtension->SmartcardRequest.BufferLength = 4;
        NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                                 0x01,         //we can use T=1 setting for direct communication
                                 0x00,         //bValueLo,
                                 0x00,         //bValueHi,
                                 0x00,         //bIndexLo,
                                 0x00);        //bIndexHi,
        if (NTStatus != STATUS_SUCCESS) {
            SmartcardDebug(DEBUG_ERROR,
                           ("%s! writing PTS request failed\n",DRIVER_NAME));
            goto ExitSetProtocol;
        }


      // read back pts data
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s! reading PTS reply\n",DRIVER_NAME));
      // maximim initial waiting time is 9600 * etu
      // => 1 sec is sufficient
        ulWaitTime = 1000;
        liWaitTime = RtlConvertLongToLargeInteger(ulWaitTime * -10000);
        KeSetTimer(&SmartcardExtension->ReaderExtension->WaitTimer,
                   liWaitTime,
                   NULL);
      // timer is now in the queue
        fCancelTimer = TRUE;

        do {
            SmartcardExtension->ReaderExtension->ulTimeoutP1 = ulWaitTime;
            DebugStatus = CMUSB_ReadP1(SmartcardExtension->OsData->DeviceObject);
         // -----------------------------
         // check if P1 has been stalled
         // -----------------------------
            if (SmartcardExtension->ReaderExtension->fP1Stalled == TRUE) {
                DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);

                SmartcardExtension->SmartcardReply.BufferLength = 0;
                goto ExitSetProtocol;
            }

            fStateTimer = KeReadStateTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
            if (fStateTimer == TRUE) {
            // timer has timed out and has been removed from the queue
                fCancelTimer = FALSE;
                SmartcardDebug(DEBUG_PROTOCOL,
                               ("%s! Timeout while PTS reply\n",DRIVER_NAME));
                NTStatus = STATUS_IO_TIMEOUT;
                break;
            }



        } while (SmartcardExtension->SmartcardReply.Buffer[0] < 4 );


        if (fCancelTimer == TRUE) {
            fCancelTimer = FALSE;
         // timer is still in the queue, remove it
            KeCancelTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
        }

        if (NTStatus == STATUS_IO_TIMEOUT) {
            if (SmartcardExtension->SmartcardReply.Buffer[0] == 3) {
                SmartcardExtension->SmartcardReply.BufferLength = 3;
            } else {
                if (SmartcardExtension->CardCapabilities.PtsData.Type !=
                    PTS_TYPE_DEFAULT) {
                    SmartcardDebug(DEBUG_PROTOCOL,
                                   ("%s! PTS failed : Trying default parameters\n",DRIVER_NAME));

               // the card did either not reply or it replied incorrectly
               // so try default values
                    SmartcardExtension->CardCapabilities.PtsData.Type = PTS_TYPE_DEFAULT;

                    SmartcardExtension->MinorIoControlCode = SCARD_COLD_RESET;
                    NTStatus = CMUSB_CardPower(SmartcardExtension);
                    continue;
                }
                goto ExitSetProtocol;
            }
        } else {
            SmartcardExtension->SmartcardReply.BufferLength = 4;
        }

        NTStatus = CMUSB_ReadP0(SmartcardExtension->OsData->DeviceObject);
        ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;
        if (NTStatus != STATUS_SUCCESS ||
            !(ulBytesRead == 4 || ulBytesRead == 3)) {
            SmartcardDebug(DEBUG_ERROR,
                           ("%s! reading PTS reply failed\n",DRIVER_NAME));
            goto ExitSetProtocol;
        }

        RtlCopyBytes((PVOID)abPTSReply,
                     (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                     ulBytesRead);


        if (ulBytesRead == 4 &&
            abPTSReply[0] == abPTSRequest[0] &&
            abPTSReply[1] == abPTSRequest[1] &&
            abPTSReply[2] == abPTSRequest[2] &&
            abPTSReply[3] == abPTSRequest[3] ) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s! PTS request and reply match\n",DRIVER_NAME));

            NTStatus = STATUS_SUCCESS;

            switch (abPTSRequest[2]) {
            // Fl/Dl
            case 0x11:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_9600;
                break ;

            case 0x12:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_19200;
                break ;


            case 0x13:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_38400;
                break ;

            case 0x14:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_76800;
                break ;

            case 0x18:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_115200;
                break ;


            case 0x91:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_9600;
                break ;

            case 0x92:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_19200;
                break ;

            case 0x93:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_38400;
                break ;

            case 0x94:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_76800;
                break ;

            case 0x98:
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_115200;
                break ;
            }

            break;
        }

        if (ulBytesRead == 3 &&
            abPTSReply[0] == abPTSRequest[0] &&
            (abPTSReply[1] & 0x7F) == (abPTSRequest[1] & 0x0F) &&
            abPTSReply[2] == (BYTE)(abPTSReply[0] ^ abPTSReply[1] )) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s! short PTS reply received\n",DRIVER_NAME));

            NTStatus = STATUS_SUCCESS;

            if ((abPTSRequest[2] & 0x90) == 0x90) {
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_5_12MHZ + CMUSB_BAUDRATE_9600;
            } else {
                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate =
                CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_9600;
            }

            break ;
        }


        if (SmartcardExtension->CardCapabilities.PtsData.Type !=
            PTS_TYPE_DEFAULT) {
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s! PTS failed : Trying default parameters\n",DRIVER_NAME));

         // the card did either not reply or it replied incorrectly
         // so try default values
            SmartcardExtension->CardCapabilities.PtsData.Type = PTS_TYPE_DEFAULT;

            SmartcardExtension->MinorIoControlCode = SCARD_COLD_RESET;
            NTStatus = CMUSB_CardPower(SmartcardExtension);
            continue;
        }

      // the card failed the pts request
        NTStatus = STATUS_DEVICE_PROTOCOL_ERROR;
        goto ExitSetProtocol;
    }


    ExitSetProtocol:
    switch (NTStatus) {
    case STATUS_IO_TIMEOUT:
        SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
        *SmartcardExtension->IoRequest.Information = 0;
        break;


    case STATUS_SUCCESS:

         // now indicate that we're in specific mode
        KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                          &irql);
        SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);

         // return the selected protocol to the caller
        *(PULONG) SmartcardExtension->IoRequest.ReplyBuffer =
        SmartcardExtension->CardCapabilities.Protocol.Selected;

        *SmartcardExtension->IoRequest.Information =
        sizeof(SmartcardExtension->CardCapabilities.Protocol.Selected);
        SmartcardDebug(DEBUG_PROTOCOL,
                       ("%s! Selected protocol: T=%ld\n",DRIVER_NAME,
                        SmartcardExtension->CardCapabilities.Protocol.Selected-1));

         // -----------------------
         // set parameters
         // -----------------------
        if (SmartcardExtension->CardCapabilities.N != 0xff) {
            SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 2 + SmartcardExtension->CardCapabilities.N;

        } else {
            // N = 255
            if (SmartcardExtension->CardCapabilities.Protocol.Selected & SCARD_PROTOCOL_T0) {
               // 12 etu for T=0;
                SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 2;
            } else {
               // 11 etu for T=1
                SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 1;
            }
        }


        NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                            SmartcardExtension->ReaderExtension->CardParameters.bCardType,
                                            SmartcardExtension->ReaderExtension->CardParameters.bBaudRate,
                                            SmartcardExtension->ReaderExtension->CardParameters.bStopBits);



        break;

    default :
        SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
        *SmartcardExtension->IoRequest.Information = 0;
        break;
    }



    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetProtocol : Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;

}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS
CMUSB_CardPower(IN PSMARTCARD_EXTENSION SmartcardExtension)
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    NTSTATUS DebugStatus = STATUS_SUCCESS;
    UCHAR  pbAtrBuffer[MAXIMUM_ATR_LENGTH];
    ULONG  ulAtrLength;
    KIRQL  irql;
#if DBG
    ULONG i;
#endif;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CardPower: Enter\n",DRIVER_NAME));

#if DBG
    switch (SmartcardExtension->MinorIoControlCode) {
    case SCARD_WARM_RESET:
        SmartcardDebug(DEBUG_ATR,
                       ("%s!CardPower: SCARD_WARM_RESTART\n",DRIVER_NAME));
        break;
    case SCARD_COLD_RESET:
        SmartcardDebug(DEBUG_ATR,
                       ("%s!CardPower: SCARD_COLD_RESTART\n",DRIVER_NAME));
        break;
    case SCARD_POWER_DOWN:
        SmartcardDebug(DEBUG_ATR,
                       ("%s!CardPower: SCARD_POWER_DOWN\n",DRIVER_NAME));
        break;
    }
#endif

   //DbgBreakPoint();

    switch (SmartcardExtension->MinorIoControlCode) {
    case SCARD_WARM_RESET:
    case SCARD_COLD_RESET:

         // try asynchronous cards first
         // because some asynchronous cards
         // do not return 0xFF in the first byte
        NTStatus = CMUSB_PowerOnCard(SmartcardExtension,
                                     pbAtrBuffer,
                                     &ulAtrLength);

        if (NTStatus != STATUS_SUCCESS && NTStatus!= STATUS_NO_MEDIA) {
            NTStatus = CMUSB_PowerOnSynchronousCard(SmartcardExtension,
                                                    pbAtrBuffer,
                                                    &ulAtrLength);
        }

        if (NTStatus != STATUS_SUCCESS) {
            goto ExitCardPower;
        }

        if (SmartcardExtension->ReaderExtension->fRawModeNecessary == FALSE) {
            // copy ATR to smart card structure
            // the lib needs the ATR for evaluation of the card parameters

            RtlCopyBytes((PVOID)SmartcardExtension->CardCapabilities.ATR.Buffer,
                         (PVOID)pbAtrBuffer,
                         ulAtrLength);

            SmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)ulAtrLength;

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

            SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_NEGOTIABLE;

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


            SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;

            NTStatus = SmartcardUpdateCardCapabilities(SmartcardExtension);
            if (NTStatus != STATUS_SUCCESS) {
                goto ExitCardPower;
            }

            // -----------------------
            // set parameters
            // -----------------------
            if (SmartcardExtension->CardCapabilities.N != 0xff) {
               // 0 <= N <= 254
                SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 2 + SmartcardExtension->CardCapabilities.N;
            } else {
               // N = 255
                if (SmartcardExtension->CardCapabilities.Protocol.Selected & SCARD_PROTOCOL_T0) {
                  // 12 etu for T=0;
                    SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 2;
                } else {
                  // 11 etu for T=1
                    SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 1;
                }
            }


            NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                                SmartcardExtension->ReaderExtension->CardParameters.bCardType,
                                                SmartcardExtension->ReaderExtension->CardParameters.bBaudRate,
                                                SmartcardExtension->ReaderExtension->CardParameters.bStopBits);


#if DBG
            SmartcardDebug(DEBUG_ATR,("%s!CardPower: ATR : ",DRIVER_NAME));
            for (i = 0;i < ulAtrLength;i++)
                SmartcardDebug(DEBUG_ATR,("%2.2x ",SmartcardExtension->CardCapabilities.ATR.Buffer[i]));
            SmartcardDebug(DEBUG_ATR,("\n"));

#endif

        } else {
            SmartcardExtension->CardCapabilities.ATR.Buffer[0] = 0x3B;
            SmartcardExtension->CardCapabilities.ATR.Buffer[1] = 0x04;

            if (ulAtrLength > 62) {
                NTStatus = STATUS_DEVICE_PROTOCOL_ERROR;
                goto ExitCardPower;
            }
            RtlCopyBytes((PVOID)&SmartcardExtension->CardCapabilities.ATR.Buffer[2],
                         (PVOID)pbAtrBuffer,
                         ulAtrLength);

            ulAtrLength += 2;
            SmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)ulAtrLength;

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

            SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;

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

            SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_T0;

            NTStatus = SmartcardUpdateCardCapabilities(SmartcardExtension);
            if (NTStatus != STATUS_SUCCESS) {
                goto ExitCardPower;
            }

            SmartcardDebug(DEBUG_ATR,("CardPower: ATR of synchronous smart card : %2.2x %2.2x %2.2x %2.2x\n",
                                      pbAtrBuffer[0],pbAtrBuffer[1],pbAtrBuffer[2],pbAtrBuffer[3]));

            // copied from serial CardMan
            //SmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested = TRUE;

        }

         // copy ATR to user space

        if (SmartcardExtension->IoRequest.ReplyBufferLength >= SmartcardExtension->CardCapabilities.ATR.Length) {
        
            RtlCopyBytes((PVOID)SmartcardExtension->IoRequest.ReplyBuffer,
                         (PVOID)SmartcardExtension->CardCapabilities.ATR.Buffer,
                         SmartcardExtension->CardCapabilities.ATR.Length);

            *SmartcardExtension->IoRequest.Information = ulAtrLength;

        } else {
            // Called from SET_PROTOCOL, so we don't want to copy the ATR.
        }
        break;

    case SCARD_POWER_DOWN:
        NTStatus = CMUSB_PowerOffCard(SmartcardExtension);
        if (NTStatus != STATUS_SUCCESS) {
            goto ExitCardPower;
        }


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

        SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
        SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);

        break;
    }



    ExitCardPower:

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CardPower: Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;

}




/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_PowerOffCard (
                            IN PSMARTCARD_EXTENSION SmartcardExtension
                            )
{
    NTSTATUS NTStatus;
    NTSTATUS DebugStatus;
    PDEVICE_OBJECT DeviceObject;
    ULONG ulBytesRead;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!PowerOffCard: Enter\n",DRIVER_NAME));

    DeviceObject = SmartcardExtension->OsData->DeviceObject;

    SmartcardExtension->SmartcardRequest.BufferLength = 0;
    NTStatus = CMUSB_WriteP0(DeviceObject,
                             0x11,         //bRequest,
                             0x00,         //bValueLo,
                             0x00,         //bValueHi,
                             0x00,         //bIndexLo,
                             0x00          //bIndexHi,
                            );


   // now read the NTStatus
    SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
    NTStatus = CMUSB_ReadP1(DeviceObject);
    if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
        DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
        goto ExitPowerOff;
    }



    ExitPowerOff:

   // set card state for update thread
   // otherwise a card removal/insertion would be recognized
    if (SmartcardExtension->ReaderExtension->ulOldCardState == POWERED)
        SmartcardExtension->ReaderExtension->ulOldCardState = INSERTED;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!PowerOffCard: Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}

/*****************************************************************************
Routine Description:


Arguments:


Return Value:


*****************************************************************************/
NTSTATUS CMUSB_ReadStateAfterP1Stalled(
                                      IN PDEVICE_OBJECT DeviceObject
                                      )
{
    NTSTATUS NTStatus;
    PSMARTCARD_EXTENSION SmartcardExtension;
    PDEVICE_EXTENSION DeviceExtension;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadStateAfterP1Stalled: Enter\n",DRIVER_NAME));

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

    SmartcardExtension->SmartcardRequest.BufferLength = 0;
    NTStatus = CMUSB_WriteP0(DeviceObject,
                             0x20,         //bRequest,
                             0x00,         //bValueLo,
                             0x00,         //bValueHi,
                             0x00,         //bIndexLo,
                             0x00          //bIndexHi,
                            );

    if (NTStatus != STATUS_SUCCESS) {
      // if we can't read the NTStatus there must be a serious error
        goto ExitReadState;
    }
    SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
    SmartcardExtension->SmartcardReply.BufferLength = 1;
    NTStatus = CMUSB_ReadP1(DeviceObject);
    if (NTStatus != STATUS_SUCCESS) {
      // if we can't read the NTStatus there must be a serious error
        goto ExitReadState;
    }

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadStateAfterP1Stalled: Exit %lx\n",DRIVER_NAME,NTStatus));

    ExitReadState:
    return NTStatus;

}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_PowerOnCard  (
                            IN  PSMARTCARD_EXTENSION SmartcardExtension,
                            IN  PUCHAR pbATR,
                            OUT PULONG pulATRLength
                            )
{
    UCHAR  abMaxAtrBuffer[SCARD_ATR_LENGTH];
    ULONG  ulCurrentLengthOfAtr;
    ULONG  ulPtrToCurrentAtrByte;
    ULONG  ulExpectedLengthOfAtr;
    BOOLEAN fTryNextCard;
    BOOLEAN fValidAtrReceived = FALSE;
    ULONG  ulBytesRead;
    NTSTATUS NTStatus;
    PDEVICE_OBJECT DeviceObject;
    NTSTATUS DebugStatus;
    BOOLEAN   fInverseAtr = FALSE;
    ULONG  ulHistoricalBytes;
    ULONG  i;
    BOOLEAN   fTDxSent;
    BOOLEAN   fOnlyT0;
    UCHAR  bResetMode;
    UCHAR  abFrequency[2] = {CMUSB_FREQUENCY_3_72MHZ,
        CMUSB_FREQUENCY_5_12MHZ};
    ULONG ulCardType;
    UCHAR bCardType;
    UCHAR bStopBits;
    UCHAR bBaudRate;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!PowerOnCard: Enter\n",DRIVER_NAME));

    DeviceObject = SmartcardExtension->OsData->DeviceObject;
    if (SmartcardExtension->MinorIoControlCode == SCARD_COLD_RESET)
        bResetMode = SMARTCARD_COLD_RESET;
    else
        bResetMode = SMARTCARD_WARM_RESET;


   // clear card parameters
    SmartcardExtension->ReaderExtension->CardParameters.bBaudRate = 0;
    SmartcardExtension->ReaderExtension->CardParameters.bCardType = 0;
    SmartcardExtension->ReaderExtension->CardParameters.bStopBits = 0;



   // set default card parameters
   // asnyc, 9600 baud, even parity
    bStopBits = 2;
    bBaudRate = CMUSB_BAUDRATE_9600;
    bCardType = CMUSB_SMARTCARD_ASYNCHRONOUS;



    for (ulCardType = 0;ulCardType < 2;ulCardType++) {
#if DBG
        switch (ulCardType) {
        case 0:
            SmartcardDebug(DEBUG_ATR,
                           ("%s!PowerOnCard: trying 3.72 Mhz smart card\n",DRIVER_NAME));
            break;

        case 1:
            SmartcardDebug(DEBUG_ATR,
                           ("%s!PowerOnCard: trying 5.12 Mhz smart card\n",DRIVER_NAME));
            break;

        }
#endif
        bBaudRate |= abFrequency[ulCardType];

        NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                            bCardType,
                                            bBaudRate,
                                            bStopBits);
        if (NTStatus != STATUS_SUCCESS) {
         // if we can't set the card parameters there must be a serious error
            goto ExitPowerOnCard;
        }

        ulCurrentLengthOfAtr  = 0L;
        ulPtrToCurrentAtrByte = 0L;
        fOnlyT0 = TRUE;
        fTryNextCard = FALSE;
        fValidAtrReceived = FALSE;
        RtlFillMemory((PVOID)abMaxAtrBuffer,
                      sizeof(abMaxAtrBuffer),
                      0x00);


      // resync CardManUSB by reading the NTStatus byte
        SmartcardExtension->SmartcardRequest.BufferLength = 0;
        NTStatus = CMUSB_WriteP0(DeviceObject,
                                 0x20,         //bRequest,
                                 0x00,         //bValueLo,
                                 0x00,         //bValueHi,
                                 0x00,         //bIndexLo,
                                 0x00          //bIndexHi,
                                );

        if (NTStatus != STATUS_SUCCESS) {
         // if we can't read the NTStatus there must be a serious error
            goto ExitPowerOnCard;
        }

        SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
        SmartcardExtension->SmartcardReply.BufferLength = 1;
        NTStatus = CMUSB_ReadP1(DeviceObject);
        if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
            DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
            goto ExitPowerOnCard;
        } else if (NTStatus != STATUS_SUCCESS) {
         // if we can't read the NTStatus there must be a serious error
            goto ExitPowerOnCard;
        }


      // check if card is really inserted
        if (SmartcardExtension->SmartcardReply.Buffer[0] == 0x00) {
            NTStatus = STATUS_NO_MEDIA;
            goto ExitPowerOnCard;
        }



      // issue power on command
        NTStatus = CMUSB_WriteP0(DeviceObject,
                                 0x10,         //bRequest,
                                 bResetMode,   //bValueLo,
                                 0x00,         //bValueHi,
                                 0x00,         //bIndexLo,
                                 0x00          //bIndexHi,
                                );
        if (NTStatus != STATUS_SUCCESS) {
         // if we can't issue the power on command there must be a serious error
            goto ExitPowerOnCard;
        }


        SmartcardExtension->ReaderExtension->ulTimeoutP1 = DEFAULT_TIMEOUT_P1;
        NTStatus = CMUSB_ReadP1(DeviceObject);
        if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
            DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
            goto ExitPowerOnCard;
        } else if (NTStatus != STATUS_SUCCESS) {
            continue;
        }


        ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;

        RtlCopyBytes((PVOID)(abMaxAtrBuffer+ulCurrentLengthOfAtr),
                     (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                     ulBytesRead);

      // check if inverse convention used
        if (abMaxAtrBuffer[0] == 0x03) {
            fInverseAtr = TRUE;
        }

        if (fInverseAtr) {
            CMUSB_InverseBuffer(abMaxAtrBuffer+ulCurrentLengthOfAtr,
                                ulBytesRead);
        }

        if (abMaxAtrBuffer[0] != 0x3B &&
            abMaxAtrBuffer[0] != 0x3F    ) {
            continue; // try next card
        }


        ulCurrentLengthOfAtr += ulBytesRead;


      // ---------------------
      // TS character
      // ---------------------
        SmartcardDebug(DEBUG_ATR,("PowerOnCard: TS = %2.2x\n",abMaxAtrBuffer[0]));
        if (abMaxAtrBuffer[ulPtrToCurrentAtrByte] != 0x3B &&
            abMaxAtrBuffer[ulPtrToCurrentAtrByte] != 0x3F    ) {
            continue;
        }


      // ---------------------
      // T0 character
      // ---------------------
        ulExpectedLengthOfAtr = 2;
        if (ulCurrentLengthOfAtr < ulExpectedLengthOfAtr) {
            NTStatus = CMUSB_ReadP1(DeviceObject);
            if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
                DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
                goto ExitPowerOnCard;
            } else if (NTStatus != STATUS_SUCCESS) {
                continue;
            }
            ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;

            RtlCopyBytes((PVOID)(abMaxAtrBuffer+ulCurrentLengthOfAtr),
                         (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                         ulBytesRead);
            if (fInverseAtr) {
                CMUSB_InverseBuffer(abMaxAtrBuffer+ulCurrentLengthOfAtr,
                                    ulBytesRead);
            }
            ulCurrentLengthOfAtr += ulBytesRead;
        }

        SmartcardDebug(DEBUG_ATR,("PowerOnCard: T0 = %2.2x\n",abMaxAtrBuffer[1]));
        ulHistoricalBytes = abMaxAtrBuffer[1] & 0x0F;

        do {
            ulPtrToCurrentAtrByte = ulExpectedLengthOfAtr - 1;
            fTDxSent = FALSE;

            if (abMaxAtrBuffer[ulPtrToCurrentAtrByte] & 0x10)
                ulExpectedLengthOfAtr++;
            if (abMaxAtrBuffer[ulPtrToCurrentAtrByte] & 0x20)
                ulExpectedLengthOfAtr++;
            if (abMaxAtrBuffer[ulPtrToCurrentAtrByte] & 0x40)
                ulExpectedLengthOfAtr++;
            if (abMaxAtrBuffer[ulPtrToCurrentAtrByte] & 0x80) {
                ulExpectedLengthOfAtr++;
                fTDxSent = TRUE;
            }

            if (fOnlyT0 == TRUE                                &&
                ulPtrToCurrentAtrByte != 1                     &&   // check if not T0
                (abMaxAtrBuffer[ulPtrToCurrentAtrByte ] & 0x0f)  ) {
                fOnlyT0 = FALSE;
            }

         // TA1, TB1, TC1 , TD1
            while (ulCurrentLengthOfAtr < ulExpectedLengthOfAtr) {
                NTStatus = CMUSB_ReadP1(DeviceObject);
                if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
                    DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
                    goto ExitPowerOnCard;
                } else if (NTStatus != STATUS_SUCCESS) {
                    fTryNextCard = TRUE;
                    break;
                }
                ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;

                RtlCopyBytes((PVOID)(abMaxAtrBuffer+ulCurrentLengthOfAtr),
                             (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                             ulBytesRead);
                if (fInverseAtr) {
                    CMUSB_InverseBuffer(abMaxAtrBuffer+ulCurrentLengthOfAtr,
                                        ulBytesRead);
                }

                ulCurrentLengthOfAtr += ulBytesRead;
            } // end of while


            if (fTryNextCard == TRUE) {
                break;
            }


#ifdef DBG
            SmartcardDebug(DEBUG_ATR,("PowerOnCard: ATR read bytes: "));
            for (i = 0;i < ulExpectedLengthOfAtr;i++)
                SmartcardDebug(DEBUG_ATR,("%2.2x ",abMaxAtrBuffer[i]));
            SmartcardDebug(DEBUG_ATR,("\n"));
#endif

        } while (fTDxSent == TRUE);

        if (fTryNextCard == TRUE) {
            continue;
        }


      // read historical bytes

      // bug fix : old SAMOS cards have a damaged ATR
        if (abMaxAtrBuffer[0] == 0x3b   &&
            abMaxAtrBuffer[1] == 0xbf   &&
            abMaxAtrBuffer[2] == 0x11   &&
            abMaxAtrBuffer[3] == 0x00   &&
            abMaxAtrBuffer[4] == 0x81   &&
            abMaxAtrBuffer[5] == 0x31   &&
            abMaxAtrBuffer[6] == 0x90   &&
            abMaxAtrBuffer[7] == 0x73      ) {
            ulHistoricalBytes = 4;
        }




        ulExpectedLengthOfAtr += ulHistoricalBytes;
        if (fOnlyT0 == FALSE) {
            ulExpectedLengthOfAtr ++;
        }

        while (ulCurrentLengthOfAtr < ulExpectedLengthOfAtr) {
            NTStatus = CMUSB_ReadP1(DeviceObject);
            if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
                DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
                goto ExitPowerOnCard;
            } else if (NTStatus != STATUS_SUCCESS) {
                fTryNextCard = TRUE;
                break;
            }
            ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;

            RtlCopyBytes((PVOID)(abMaxAtrBuffer+ulCurrentLengthOfAtr),
                         (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                         ulBytesRead);
            if (fInverseAtr) {
                CMUSB_InverseBuffer(abMaxAtrBuffer+ulCurrentLengthOfAtr,
                                    ulBytesRead);
            }
            ulCurrentLengthOfAtr += ulBytesRead;
        }
        if (fTryNextCard == TRUE) {
            continue;
        }


      // check ATR
        if (ulCurrentLengthOfAtr < 3                ||
            ulCurrentLengthOfAtr > SCARD_ATR_LENGTH   ) {
            goto ExitPowerOnCard;
        }


      // check if the ATR of a SAMOS card with damaged ATR msut be corrected
        CMUSB_CheckAtrModified(abMaxAtrBuffer,ulCurrentLengthOfAtr);

        NTStatus = STATUS_SUCCESS;
        fValidAtrReceived = TRUE;
        RtlCopyBytes((PVOID)pbATR,
                     (PVOID)abMaxAtrBuffer,
                     ulCurrentLengthOfAtr);
        *pulATRLength = ulCurrentLengthOfAtr;

        if (fInverseAtr) {
            SmartcardExtension->ReaderExtension->fInverseAtr = TRUE;
        } else {
            SmartcardExtension->ReaderExtension->fInverseAtr = FALSE;
        }
        SmartcardExtension->ReaderExtension->fRawModeNecessary = FALSE;

      // -------------------
      // set card parameters
      // -------------------
        if (SmartcardExtension->ReaderExtension->fInverseAtr) {
            SmartcardExtension->ReaderExtension->CardParameters.bBaudRate |= CMUSB_ODD_PARITY;
        }
        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate |= abFrequency[ulCardType];
        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate |= CMUSB_BAUDRATE_9600;
        SmartcardExtension->ReaderExtension->CardParameters.bCardType = CMUSB_SMARTCARD_ASYNCHRONOUS;
        break;
    }



    ExitPowerOnCard:
   // return correct error code
    if (NTStatus != STATUS_NO_MEDIA && fValidAtrReceived == FALSE) {
        SmartcardDebug(DEBUG_ATR,
                       ("%s!PowerOnCard: no valid ATR received\n",DRIVER_NAME));
        NTStatus = STATUS_UNRECOGNIZED_MEDIA;
    }

    if (NTStatus!=STATUS_SUCCESS) {
      // turn off VCC again
        CMUSB_PowerOffCard (SmartcardExtension );
      // ignor NTStatus
    }

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!PowerOnCard: Exit %lx\n",DRIVER_NAME,NTStatus));

    return NTStatus;
}






/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_CardTracking(
                           PSMARTCARD_EXTENSION pSmartcardExtension
                           )
{
    KIRQL oldIrql;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CardTracking: Enter\n",DRIVER_NAME ));

   //
   // Set cancel routine for the notification irp
   //
    IoAcquireCancelSpinLock(&oldIrql);
    IoSetCancelRoutine(pSmartcardExtension->OsData->NotificationIrp,
                       CMUSB_CancelCardTracking);
    IoReleaseCancelSpinLock(oldIrql);

   //
   // Mark notification irp pending
   //
    IoMarkIrpPending(pSmartcardExtension->OsData->NotificationIrp);

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CardTracking: Exit\n",DRIVER_NAME ));

    return STATUS_PENDING;
}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_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
      //
        CMUSB_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;
}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_CancelCardTracking(
                                 IN PDEVICE_OBJECT DeviceObject,
                                 IN PIRP Irp)
{
    PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension = &DeviceExtension->SmartcardExtension;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CancelCardTracking: Enter\n",DRIVER_NAME));

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

    IoReleaseCancelSpinLock(Irp->CancelIrql);

    CMUSB_CompleteCardTracking(SmartcardExtension);

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!CancelCardTracking: Exit\n",DRIVER_NAME));

    return STATUS_CANCELLED;
}



/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_IoCtlVendor(
                          PSMARTCARD_EXTENSION SmartcardExtension
                          )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    NTSTATUS DebugStatus;
    UCHAR  pbAtrBuffer[MAXIMUM_ATR_LENGTH];
    ULONG  ulAtrLength;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!IoCtlVendor : Enter\n",DRIVER_NAME));

    switch (SmartcardExtension->MajorIoControlCode) {
    case CM_IOCTL_CR80S_SAMOS_SET_HIGH_SPEED:
        NTStatus = CMUSB_SetHighSpeed_CR80S_SAMOS(SmartcardExtension);
        break;

    case CM_IOCTL_GET_FW_VERSION:
        NTStatus = CMUSB_GetFWVersion(SmartcardExtension);
        break;

    case CM_IOCTL_READ_DEVICE_DESCRIPTION:
        NTStatus = CMUSB_ReadDeviceDescription(SmartcardExtension);
        break;

    case CM_IOCTL_SET_READER_9600_BAUD:
        NTStatus = CMUSB_SetReader_9600Baud(SmartcardExtension);
        break;

    case CM_IOCTL_SET_READER_38400_BAUD:
        NTStatus = CMUSB_SetReader_38400Baud(SmartcardExtension);
        break;

    case CM_IOCTL_SET_SYNC_PARAMETERS:
         // in case of CardManUSB do nothing
        NTStatus = STATUS_SUCCESS;
        break;

    case CM_IOCTL_SYNC_CARD_POWERON:
        NTStatus = CMUSB_PowerOnSynchronousCard(SmartcardExtension,
                                                pbAtrBuffer,
                                                &ulAtrLength);
        break;

    case CM_IOCTL_2WBP_RESET_CARD:
        SmartcardExtension->MinorIoControlCode = SMARTCARD_WARM_RESET;
        NTStatus = CMUSB_PowerOnSynchronousCard(SmartcardExtension,
                                                pbAtrBuffer,
                                                &ulAtrLength);
        break;

    case CM_IOCTL_2WBP_TRANSFER:
        NTStatus = CMUSB_Transmit2WBP(SmartcardExtension);
        break;

    case CM_IOCTL_3WBP_TRANSFER:
        NTStatus = CMUSB_Transmit3WBP(SmartcardExtension);
        break;


    default:
        NTStatus = STATUS_INVALID_DEVICE_REQUEST;
        break;
    }





    SmartcardDebug(DEBUG_TRACE,
                   ("%s!IoCtlVendor : Exit %lx\n",DRIVER_NAME,NTStatus));

    return NTStatus;

}

/*****************************************************************************
Routine Description:



Arguments:



Return Value: STATUS_UNSUCCESSFUL
              STATUS_SUCCESS

*****************************************************************************/
NTSTATUS CMUSB_SetHighSpeed_CR80S_SAMOS (
                                        IN PSMARTCARD_EXTENSION SmartcardExtension
                                        )
{
    NTSTATUS NTStatus;
    NTSTATUS DebugStatus;
    UCHAR abReadBuffer[16];
    ULONG ulBytesRead;
    BYTE abCR80S_SAMOS_SET_HIGH_SPEED[4] = {0xFF,0x11,0x94,0x7A};
    ULONG ulAtrLength;
    BYTE abAtr[MAXIMUM_ATR_LENGTH];
    LARGE_INTEGER   liWaitTime;
    BOOLEAN         fStateTimer;
    ULONG           ulWaitTime;
    BOOLEAN         fCancelTimer = FALSE;


    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetHighSpeed_CR80S_SAMOS: Enter\n",DRIVER_NAME));

    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!SetHighSpeed_CR80S_SAMOS: writing high speed command\n",DRIVER_NAME));


    RtlCopyBytes((PVOID)SmartcardExtension->SmartcardRequest.Buffer,
                 (PVOID)abCR80S_SAMOS_SET_HIGH_SPEED,
                 sizeof(abCR80S_SAMOS_SET_HIGH_SPEED));
    SmartcardExtension->SmartcardRequest.BufferLength = 4;
    NTStatus = CMUSB_WriteP0(SmartcardExtension->OsData->DeviceObject,
                             0x01,         //we can use T=1 setting for direct communication
                             0x00,         //bValueLo,
                             0x00,         //bValueHi,
                             0x00,         //bIndexLo,
                             0x00);        //bIndexHi,
    if (NTStatus != STATUS_SUCCESS) {
        SmartcardDebug(DEBUG_ERROR,
                       ("%s!SetHighSpeed_CR80S_SAMOS: writing high speed command failed\n",DRIVER_NAME));
        goto ExitSetHighSpeed;
    }

   // read back pts data
    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!SetHighSpeed_CR80S_SAMOS: reading echo\n",DRIVER_NAME));

   // maximim initial waiting time is 9600 * etu
   // => 1 sec is sufficient
    ulWaitTime = 1000;
    liWaitTime = RtlConvertLongToLargeInteger(ulWaitTime * -10000);
    KeSetTimer(&SmartcardExtension->ReaderExtension->WaitTimer,
               liWaitTime,
               NULL);

    fCancelTimer = TRUE;


    do {
        SmartcardExtension->ReaderExtension->ulTimeoutP1 = ulWaitTime;
        NTStatus = CMUSB_ReadP1(SmartcardExtension->OsData->DeviceObject);
        if (NTStatus == STATUS_DEVICE_DATA_ERROR) {
            DebugStatus = CMUSB_ReadStateAfterP1Stalled(SmartcardExtension->OsData->DeviceObject);
            break;
        }

        fStateTimer = KeReadStateTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
        if (fStateTimer == TRUE) {
            fCancelTimer =FALSE;
            SmartcardDebug(DEBUG_PROTOCOL,
                           ("%s!SetHighSpeed_CR80S_SAMOS: timeout while reading echo\n",DRIVER_NAME));
            break;
        }



    } while (SmartcardExtension->SmartcardReply.Buffer[0] < 4 );

    if (NTStatus != STATUS_SUCCESS) {
        goto ExitSetHighSpeed;
    }


    SmartcardExtension->SmartcardReply.BufferLength = 4;
    NTStatus = CMUSB_ReadP0(SmartcardExtension->OsData->DeviceObject);
    if (NTStatus != STATUS_SUCCESS) {
        SmartcardDebug(DEBUG_ERROR,
                       ("%s!SetHighSpeed_CR80S_SAMOS: reading echo failed\n",DRIVER_NAME));
        goto ExitSetHighSpeed;
    }
    ulBytesRead = SmartcardExtension->SmartcardReply.BufferLength;

    RtlCopyBytes((PVOID)abReadBuffer,
                 (PVOID)SmartcardExtension->SmartcardReply.Buffer,
                 ulBytesRead);



   // if the card has accepted this string , the string is echoed
    if (abReadBuffer[0] == abCR80S_SAMOS_SET_HIGH_SPEED[0]  &&
        abReadBuffer[1] == abCR80S_SAMOS_SET_HIGH_SPEED[1]  &&
        abReadBuffer[2] == abCR80S_SAMOS_SET_HIGH_SPEED[2]  &&
        abReadBuffer[3] == abCR80S_SAMOS_SET_HIGH_SPEED[3]      ) {
        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate = 0;

        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate |= CMUSB_FREQUENCY_5_12MHZ;
        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate |= CMUSB_BAUDRATE_76800;
        SmartcardExtension->ReaderExtension->CardParameters.bCardType  = CMUSB_SMARTCARD_ASYNCHRONOUS;


        NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                            SmartcardExtension->ReaderExtension->CardParameters.bCardType,
                                            SmartcardExtension->ReaderExtension->CardParameters.bBaudRate,
                                            SmartcardExtension->ReaderExtension->CardParameters.bStopBits);


    } else {
        DebugStatus = CMUSB_PowerOffCard(SmartcardExtension);

      // a cold reset is necessary now
        SmartcardExtension->MinorIoControlCode = SCARD_COLD_RESET;
        DebugStatus = CMUSB_PowerOnCard(SmartcardExtension,abAtr,&ulAtrLength);
        NTStatus = STATUS_UNSUCCESSFUL;
    }




    ExitSetHighSpeed:
    if (fCancelTimer == TRUE) {
        KeCancelTimer(&SmartcardExtension->ReaderExtension->WaitTimer);
    }

    *SmartcardExtension->IoRequest.Information = 0L;
    if (NTStatus != STATUS_SUCCESS)
        NTStatus = STATUS_UNSUCCESSFUL;
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetHighSpeed_CR80S_SAMOS: Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_GetFWVersion (
                            IN PSMARTCARD_EXTENSION SmartcardExtension
                            )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!GetFWVersion : Enter\n",DRIVER_NAME));


    if (SmartcardExtension->IoRequest.ReplyBufferLength  < sizeof (ULONG)) {
        NTStatus = STATUS_BUFFER_OVERFLOW;
        goto ExitGetFWVersion;
    } else {
        *(PULONG)(SmartcardExtension->IoRequest.ReplyBuffer) =
        SmartcardExtension->ReaderExtension->ulFWVersion;
    }


    ExitGetFWVersion:
    *SmartcardExtension->IoRequest.Information = sizeof(ULONG);
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!GetFWVersion : Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}

/*****************************************************************************
Routine Description:


Arguments:


Return Value: STATUS_UNSUCCESSFUL
              STATUS_SUCCESS

*****************************************************************************/
NTSTATUS CMUSB_SetReader_9600Baud (
                                  IN PSMARTCARD_EXTENSION SmartcardExtension
                                  )
{
    NTSTATUS    NTStatus = STATUS_SUCCESS;
    KIRQL       irql;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetReader_9600Baud: Enter\n",DRIVER_NAME));

   // check if card is already in specific mode
    KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                      &irql);
    if (SmartcardExtension->ReaderCapabilities.CurrentState != SCARD_SPECIFIC) {
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);
        NTStatus = STATUS_INVALID_DEVICE_REQUEST;
        goto ExitSetReader9600;
    } else {
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);
    }

   // set 9600 Baud for 3.58 MHz
    SmartcardExtension->ReaderExtension->CardParameters.bBaudRate = CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_9600;
    SmartcardExtension->ReaderExtension->CardParameters.bCardType  = CMUSB_SMARTCARD_ASYNCHRONOUS;
    NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                        SmartcardExtension->ReaderExtension->CardParameters.bCardType,
                                        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate,
                                        SmartcardExtension->ReaderExtension->CardParameters.bStopBits);

    ExitSetReader9600:
    *SmartcardExtension->IoRequest.Information = 0L;
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetReader_9600Baud: Exit %lx\n",DRIVER_NAME,NTStatus));

    return(NTStatus);
}


/*****************************************************************************
Routine Description:


Arguments:


Return Value: STATUS_UNSUCCESSFUL
              STATUS_SUCCESS

*****************************************************************************/
NTSTATUS CMUSB_SetReader_38400Baud (
                                   IN PSMARTCARD_EXTENSION SmartcardExtension
                                   )
{
    NTSTATUS    NTStatus = STATUS_SUCCESS;
    KIRQL       irql;
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetReader_38400Baud: Enter\n",DRIVER_NAME));

   // check if card is already in specific mode
    
    KeAcquireSpinLock(&SmartcardExtension->OsData->SpinLock,
                      &irql);
    if (SmartcardExtension->ReaderCapabilities.CurrentState != SCARD_SPECIFIC) {
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);
        NTStatus = STATUS_INVALID_DEVICE_REQUEST;
        goto ExitSetReader38400;
    } else {
        KeReleaseSpinLock(&SmartcardExtension->OsData->SpinLock,
                          irql);
    }



   // set 384000 Baud for 3.58 MHz card
    SmartcardExtension->ReaderExtension->CardParameters.bBaudRate = CMUSB_FREQUENCY_3_72MHZ + CMUSB_BAUDRATE_38400;
    SmartcardExtension->ReaderExtension->CardParameters.bCardType  = CMUSB_SMARTCARD_ASYNCHRONOUS;
    NTStatus = CMUSB_SetCardParameters (SmartcardExtension->OsData->DeviceObject,
                                        SmartcardExtension->ReaderExtension->CardParameters.bCardType,
                                        SmartcardExtension->ReaderExtension->CardParameters.bBaudRate,
                                        SmartcardExtension->ReaderExtension->CardParameters.bStopBits);

    ExitSetReader38400:
    *SmartcardExtension->IoRequest.Information = 0L;
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetReader_38400Baud: Exit %lx\n",DRIVER_NAME,NTStatus));

    return(NTStatus);
}

/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
VOID
CMUSB_InitializeSmartcardExtension(
                                  IN PSMARTCARD_EXTENSION SmartcardExtension
                                  )
{
   // ==================================
   // Fill the Vendor_Attr structure
   // ==================================
    RtlCopyBytes((PVOID)SmartcardExtension->VendorAttr.VendorName.Buffer,
                 (PVOID)CM2020_VENDOR_NAME,
                 sizeof(CM2020_VENDOR_NAME)
                );

   //
   // Length of vendor name
   //
    SmartcardExtension->VendorAttr.VendorName.Length = sizeof(CM2020_VENDOR_NAME);


   //
   // Reader name
   //
    RtlCopyBytes((PVOID)SmartcardExtension->VendorAttr.IfdType.Buffer,
                 (PVOID)CM2020_PRODUCT_NAME,
                 sizeof(CM2020_PRODUCT_NAME));

   //
   // Length of reader name
   //
    SmartcardExtension->VendorAttr.IfdType.Length = sizeof(CM2020_PRODUCT_NAME);



   //
   // Version number
   //
    SmartcardExtension->VendorAttr.IfdVersion.BuildNumber  = BUILDNUMBER_CARDMAN_USB;
    SmartcardExtension->VendorAttr.IfdVersion.VersionMinor = VERSIONMINOR_CARDMAN_USB;
    SmartcardExtension->VendorAttr.IfdVersion.VersionMajor = VERSIONMAJOR_CARDMAN_USB;


   //
   // Unit number which is zero based
   //
    SmartcardExtension->VendorAttr.UnitNo = SmartcardExtension->ReaderExtension->ulDeviceInstance;



   // ================================================
   // Fill the SCARD_READER_CAPABILITIES structure
   // ===============================================
   //
   // Supported protoclols by the reader
   //

    SmartcardExtension->ReaderCapabilities.SupportedProtocols = SCARD_PROTOCOL_T1 | SCARD_PROTOCOL_T0;




   //
   // Reader type serial, keyboard, ....
   //
    SmartcardExtension->ReaderCapabilities.ReaderType = SCARD_READER_TYPE_USB;

   //
   // Mechanical characteristics like swallows etc.
   //
    SmartcardExtension->ReaderCapabilities.MechProperties = 0;


   //
   // Current state of the reader
   //
    SmartcardExtension->ReaderExtension->ulOldCardState = UNKNOWN;
    SmartcardExtension->ReaderExtension->ulNewCardState = UNKNOWN;
    SmartcardExtension->ReaderCapabilities.CurrentState  = SCARD_UNKNOWN;



   //
   // Data Rate
   //
    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]);


   //
   // CLK Frequency
   //


    SmartcardExtension->ReaderCapabilities.CLKFrequency.Default =
    SmartcardExtension->ReaderCapabilities.CLKFrequency.Max =
    CLKFrequenciesSupported[0];

   // reader could support higher frequencies
    SmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.List =
    CLKFrequenciesSupported;
    SmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.Entries =
    sizeof(CLKFrequenciesSupported) / sizeof(CLKFrequenciesSupported[0]);


   //
   // MaxIFSD
   //
    SmartcardExtension->ReaderCapabilities.MaxIFSD = ATTR_MAX_IFSD_CARDMAN_USB;





}


/*****************************************************************************
Routine Description:
This function always returns 'CardManUSB'.


Arguments:     pointer to SMARTCARD_EXTENSION



Return Value:  NT NTStatus

*****************************************************************************/
NTSTATUS
CMUSB_ReadDeviceDescription(IN PSMARTCARD_EXTENSION SmartcardExtension )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;
    BYTE abDeviceDescription[] = "CardManUSB";

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadDeviceDescription : Enter\n",DRIVER_NAME));

    if (SmartcardExtension->IoRequest.ReplyBufferLength  < sizeof(abDeviceDescription)) {
        NTStatus = STATUS_BUFFER_OVERFLOW;
        *SmartcardExtension->IoRequest.Information = 0L;
        goto ExitReadDeviceDescription;
    } else {
        RtlCopyBytes((PVOID)SmartcardExtension->IoRequest.ReplyBuffer,
                     (PVOID)abDeviceDescription,
                     sizeof(abDeviceDescription));
        *SmartcardExtension->IoRequest.Information = sizeof(abDeviceDescription);
    }



    ExitReadDeviceDescription:
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!ReadDeviceDescription : Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}



/*****************************************************************************
Routine Description:

This routine always returns FALSE.

Arguments:    pointer to SMARDCARD_EXTENSION


Return Value: NT NTStatus


*****************************************************************************/
NTSTATUS
CMUSB_IsSPESupported (IN PSMARTCARD_EXTENSION SmartcardExtension )
{
    NTSTATUS NTStatus = STATUS_SUCCESS;

    SmartcardDebug(DEBUG_TRACE,
                   ("%s!IsSPESupported: Enter\n",DRIVER_NAME));

    if (SmartcardExtension->IoRequest.ReplyBufferLength  < sizeof (ULONG)) {
        NTStatus = STATUS_BUFFER_OVERFLOW;
        *SmartcardExtension->IoRequest.Information = 0;
        goto ExitIsSPESupported;
    } else {
        *(PULONG)(SmartcardExtension->IoRequest.ReplyBuffer) = FALSE;
        *SmartcardExtension->IoRequest.Information = sizeof(ULONG);
    }



    ExitIsSPESupported:
    SmartcardDebug(DEBUG_TRACE,
                   ("%s!IsSPESupported: Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}





/*****************************************************************************
Routine Description:



Arguments:



Return Value:

*****************************************************************************/
NTSTATUS CMUSB_SetCardParameters (
                                 IN PDEVICE_OBJECT DeviceObject,
                                 IN UCHAR bCardType,
                                 IN UCHAR bBaudRate,
                                 IN UCHAR bStopBits
                                 )
{
    NTSTATUS NTStatus;
    PDEVICE_EXTENSION    DeviceExtension;
    PSMARTCARD_EXTENSION SmartcardExtension;




    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetCardParameters: Enter\n",DRIVER_NAME));

    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!SetCardParameters: ##################################################\n",DRIVER_NAME));
    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!SetCardParameters: bCardType = %x bBaudRate = %x bStopBits = %x\n",DRIVER_NAME,
                    bCardType,bBaudRate,bStopBits));
    SmartcardDebug(DEBUG_PROTOCOL,
                   ("%s!SetCardParameters: ##################################################\n",DRIVER_NAME));

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

    SmartcardExtension->SmartcardRequest.BufferLength = 0;
    NTStatus = CMUSB_WriteP0(DeviceObject,
                             0x30,         //bRequest,
                             bCardType,    //bValueLo,
                             bBaudRate,    //bValueHi,
                             bStopBits,    //bIndexLo,
                             0x00          //bIndexHi,
                            );



    SmartcardDebug(DEBUG_TRACE,
                   ("%s!SetCardParameters: Exit %lx\n",DRIVER_NAME,NTStatus));
    return NTStatus;
}

/*****************************************************************************
Routine Description:

 Bit0 -> Bit 7
 Bit1 -> Bit 6
 Bit2 -> Bit 5
 Bit3 -> Bit 4
 Bit4 -> Bit 3
 Bit5 -> Bit 2
 Bit6 -> Bit 1
 Bit7 -> Bit 0

Arguments:



Return Value:

*****************************************************************************/
VOID CMUSB_InverseBuffer (
                         PUCHAR pbBuffer,
                         ULONG  ulBufferSize
                         )
{
    ULONG i;
    ULONG j;
    ULONG m;
    ULONG n;

    for (i=0; i<ulBufferSize; i++) {
        n = 0;
        for (j=1; j<=8; j++) {
            m  = (pbBuffer[i] << j);
            m &= 0x00000100;
            n  |= (m >> (9-j));
        }
        pbBuffer[i] = (UCHAR)~n;
    }

    return;
}

/*****************************************************************************
Routine Description:

 This function checks if an incorrect ATR has been received.
 It corrects the number of historical bytes and the checksum byte

Arguments:  pointer to current ATR
            length of ATR


Return Value: none

*****************************************************************************/
VOID CMUSB_CheckAtrModified (
                            PUCHAR pbBuffer,
                            ULONG  ulBufferSize
                            )
{
    UCHAR bNumberHistoricalBytes;
    UCHAR bXorChecksum;
    ULONG i;

    if (ulBufferSize < 0x09)  // mininmum length of a modified ATR
        return ;               // ATR is ok


   // variant 2
    if (pbBuffer[0] == 0x3b   &&
        pbBuffer[1] == 0xbf   &&
        pbBuffer[2] == 0x11   &&
        pbBuffer[3] == 0x00   &&
        pbBuffer[4] == 0x81   &&
        pbBuffer[5] == 0x31   &&
        pbBuffer[6] == 0x90   &&
        pbBuffer[7] == 0x73   &&
        ulBufferSize == 13   ) {
      // correct number of historical bytes
        bNumberHistoricalBytes = 4;

        pbBuffer[1] &= 0xf0;
        pbBuffer[1] |= bNumberHistoricalBytes;

      // correct checksum byte
        bXorChecksum = pbBuffer[1];
        for (i=2;i<ulBufferSize-1;i++)
            bXorChecksum ^= pbBuffer[i];

        pbBuffer[ulBufferSize -1 ] = bXorChecksum;
        SmartcardDebug(DEBUG_ATR,
                       ("%s!CheckAtrModified: correcting SAMOS ATR (variant 2)\n",
                        DRIVER_NAME));
    }




   // variant 1
    if (pbBuffer[0] == 0x3b   &&
        pbBuffer[1] == 0xb4   &&
        pbBuffer[2] == 0x11   &&
        pbBuffer[3] == 0x00   &&
        pbBuffer[4] == 0x81   &&
        pbBuffer[5] == 0x31   &&
        pbBuffer[6] == 0x90   &&
        pbBuffer[7] == 0x73   &&
        ulBufferSize == 13      ) {
      // correct checksum byte
        bXorChecksum = pbBuffer[1];
        for (i=2;i<ulBufferSize-1;i++)
            bXorChecksum ^= pbBuffer[i];


        if (pbBuffer[ulBufferSize -1 ] != bXorChecksum ) {
            pbBuffer[ulBufferSize -1 ] = bXorChecksum;
            SmartcardDebug(DEBUG_ATR,
                           ("%s!CheckAtrModified: correcting SAMOS ATR (variant 1)\n",
                            DRIVER_NAME));

        }
    }



   // variant 3
    if (pbBuffer[0] == 0x3b   &&
        pbBuffer[1] == 0xbf   &&
        pbBuffer[2] == 0x11   &&
        pbBuffer[3] == 0x00   &&
        pbBuffer[4] == 0x81   &&
        pbBuffer[5] == 0x31   &&
        pbBuffer[6] == 0x90   &&
        pbBuffer[7] == 0x73   &&
        ulBufferSize ==  9      ) {
      // correct number of historical bytes
        bNumberHistoricalBytes = 0;

        pbBuffer[1] &= 0xf0;
        pbBuffer[1] |= bNumberHistoricalBytes;

      // correct checksum byte
        bXorChecksum = pbBuffer[1];
        for (i=2;i<ulBufferSize-1;i++)
            bXorChecksum ^= pbBuffer[i];

        pbBuffer[ulBufferSize -1 ] = bXorChecksum;
        SmartcardDebug(DEBUG_ATR,
                       ("%s!CheckAtrModified: correcting SAMOS ATR (variant 3)\n",
                        DRIVER_NAME));
    }



}

/*****************************************************************************
* History:
* $Log: scusbcb.c $
* Revision 1.9  2001/01/17 12:36:04  WFrischauf
* No comment given
*
* Revision 1.8  2000/09/25 13:38:21  WFrischauf
* No comment given
*
* Revision 1.7  2000/08/24 09:04:38  TBruendl
* No comment given
*
* Revision 1.6  2000/08/16 14:35:03  WFrischauf
* No comment given
*
* Revision 1.5  2000/08/16 08:25:06  TBruendl
* warning :uninitialized memory removed
*
* Revision 1.4  2000/07/24 11:34:59  WFrischauf
* No comment given
*
* Revision 1.1  2000/07/20 11:50:14  WFrischauf
* No comment given
*
*
*****************************************************************************/