mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4238 lines
114 KiB
4238 lines
114 KiB
/*++
|
|
|
|
Copyright (c) 1997 Rainbow Technologies Inc.
|
|
|
|
Module Name:
|
|
|
|
RNBO3531.c
|
|
|
|
Abstract:
|
|
|
|
Author:
|
|
Mehdi Sotoodeh [email protected]
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History :
|
|
|
|
Jan 98 - Started from the DDK sources from Klaus Schutz
|
|
Mar 98 - PnP support added
|
|
Apr 98 - Changes on card timings and PnP
|
|
- Added power management
|
|
May 98 - RemoveLock changes
|
|
- RBSCT1Transmit timeout bug fixed
|
|
- Sent to MicroSoft
|
|
May 98 - Added variable baudrate support
|
|
- Reduced ATR response time
|
|
- Sent to MicroSoft
|
|
- Data transmission size of 256 bug fixed.
|
|
Jun 98 - Power management update
|
|
- RBSCReaderPower and RBSCCardTracking moved to non-paged
|
|
code (use of KeAcquireSpinLock/IoAcquireCancelSpinLock)
|
|
- fixed: completeion function when IoSkipCurrentIrpStackLocation
|
|
is called.
|
|
- turned off PowerRequest flag on exit from RBSCReaderPower.
|
|
- Sent to MicroSoft
|
|
Sep 98 - Power management update
|
|
- Sent to MicroSoft
|
|
Oct 98 - warning fixes for win64 compatibility.
|
|
Nov 98 - Set to default when PTS fails.
|
|
- Mondex fix
|
|
- Sent to MicroSoft
|
|
Dec 98 - Reties removed from the reset operations
|
|
- Sent to MicroSoft
|
|
Apr 99 - Misc. changes
|
|
|
|
--*/
|
|
|
|
#include <stdio.h>
|
|
#include "RNBO3531.h"
|
|
|
|
//
|
|
// We do not need these functions after init anymore
|
|
//
|
|
#pragma alloc_text(INIT, DriverEntry)
|
|
#pragma alloc_text(PAGEABLE, RBSCAddDevice)
|
|
#pragma alloc_text(PAGEABLE, RBSCUnloadDriver)
|
|
#pragma alloc_text(PAGEABLE, RBSCRemoveDevice)
|
|
#pragma alloc_text(PAGEABLE, RBSCTransmit)
|
|
#pragma alloc_text(PAGEABLE, RBSCSetProtocol)
|
|
#pragma alloc_text(PAGEABLE, RBSCT0Transmit)
|
|
#pragma alloc_text(PAGEABLE, RBSCT1Transmit)
|
|
|
|
#if DBG
|
|
#pragma optimize ("", off)
|
|
#endif
|
|
|
|
UCHAR GetReaderType[] = {IFDCMD_HEADER1,IFDCMD_HEADER2,IFDCMD_GET_TYPE};
|
|
UCHAR CardPowerDown[] = {IFDCMD_HEADER1,IFDCMD_HEADER2,IFDCMD_PWR_OFF};
|
|
UCHAR CardPowerUp[] = {IFDCMD_HEADER1,IFDCMD_HEADER2,IFDCMD_PWR_ON};
|
|
|
|
#ifdef NT4
|
|
#define SmartcardAcquireRemoveLockWithTag(x,y) SmartcardAcquireRemoveLock(x)
|
|
#define SmartcardReleaseRemoveLockWithTag(x,y) SmartcardReleaseRemoveLock(x)
|
|
#endif
|
|
|
|
#ifndef NT5
|
|
DWORD UsedPortsMask = 0; // Bit mask for used ports
|
|
#endif
|
|
|
|
//
|
|
// Table to convert inverse convention data
|
|
//
|
|
static UCHAR InverseCharTable[256] =
|
|
{
|
|
0xFF,0x7F,0xBF,0x3F,0xDF,0x5F,0x9F,0x1F,
|
|
0xEF,0x6F,0xAF,0x2F,0xCF,0x4F,0x8F,0x0F,
|
|
0xF7,0x77,0xB7,0x37,0xD7,0x57,0x97,0x17,
|
|
0xE7,0x67,0xA7,0x27,0xC7,0x47,0x87,0x07,
|
|
0xFB,0x7B,0xBB,0x3B,0xDB,0x5B,0x9B,0x1B,
|
|
0xEB,0x6B,0xAB,0x2B,0xCB,0x4B,0x8B,0x0B,
|
|
0xF3,0x73,0xB3,0x33,0xD3,0x53,0x93,0x13,
|
|
0xE3,0x63,0xA3,0x23,0xC3,0x43,0x83,0x03,
|
|
0xFD,0x7D,0xBD,0x3D,0xDD,0x5D,0x9D,0x1D,
|
|
0xED,0x6D,0xAD,0x2D,0xCD,0x4D,0x8D,0x0D,
|
|
0xF5,0x75,0xB5,0x35,0xD5,0x55,0x95,0x15,
|
|
0xE5,0x65,0xA5,0x25,0xC5,0x45,0x85,0x05,
|
|
0xF9,0x79,0xB9,0x39,0xD9,0x59,0x99,0x19,
|
|
0xE9,0x69,0xA9,0x29,0xC9,0x49,0x89,0x09,
|
|
0xF1,0x71,0xB1,0x31,0xD1,0x51,0x91,0x11,
|
|
0xE1,0x61,0xA1,0x21,0xC1,0x41,0x81,0x01,
|
|
0xFE,0x7E,0xBE,0x3E,0xDE,0x5E,0x9E,0x1E,
|
|
0xEE,0x6E,0xAE,0x2E,0xCE,0x4E,0x8E,0x0E,
|
|
0xF6,0x76,0xB6,0x36,0xD6,0x56,0x96,0x16,
|
|
0xE6,0x66,0xA6,0x26,0xC6,0x46,0x86,0x06,
|
|
0xFA,0x7A,0xBA,0x3A,0xDA,0x5A,0x9A,0x1A,
|
|
0xEA,0x6A,0xAA,0x2A,0xCA,0x4A,0x8A,0x0A,
|
|
0xF2,0x72,0xB2,0x32,0xD2,0x52,0x92,0x12,
|
|
0xE2,0x62,0xA2,0x22,0xC2,0x42,0x82,0x02,
|
|
0xFC,0x7C,0xBC,0x3C,0xDC,0x5C,0x9C,0x1C,
|
|
0xEC,0x6C,0xAC,0x2C,0xCC,0x4C,0x8C,0x0C,
|
|
0xF4,0x74,0xB4,0x34,0xD4,0x54,0x94,0x14,
|
|
0xE4,0x64,0xA4,0x24,0xC4,0x44,0x84,0x04,
|
|
0xF8,0x78,0xB8,0x38,0xD8,0x58,0x98,0x18,
|
|
0xE8,0x68,0xA8,0x28,0xC8,0x48,0x88,0x08,
|
|
0xF0,0x70,0xB0,0x30,0xD0,0x50,0x90,0x10,
|
|
0xE0,0x60,0xA0,0x20,0xC0,0x40,0x80,0x00
|
|
};
|
|
|
|
#if DBG
|
|
void
|
|
_stdcall
|
|
DumpData(
|
|
PUCHAR Msg,
|
|
PUCHAR Buffer,
|
|
ULONG Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function formats the debug output and
|
|
shows it on the debug screen
|
|
|
|
Arguments:
|
|
|
|
Buffer - pointer to the buffer which contains the
|
|
debug data
|
|
|
|
Length - length of the datablock
|
|
|
|
Return Value:
|
|
|
|
Note:
|
|
Output Format:
|
|
|
|
0000 : FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
|
|
0010 : FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
|
|
0020 : .....
|
|
|
|
--*/
|
|
{
|
|
ULONG i, n;
|
|
char buff[80];
|
|
|
|
n = sprintf( buff, "RNBO3531!%s = %ld", Msg, Length );
|
|
|
|
for( i = 0; i < Length; i++ )
|
|
{
|
|
if( (i & 15) == 0 )
|
|
{
|
|
SmartcardDebug( DEBUG_PROTOCOL, ("%s\n", buff) );
|
|
n = sprintf( buff, "%04X :", i );
|
|
}
|
|
|
|
n += sprintf( buff+n, " %02X", Buffer[i] );
|
|
if( ((i + 1) & 7) == 0 )
|
|
{
|
|
n += sprintf( buff+n, " " );
|
|
}
|
|
|
|
}
|
|
SmartcardDebug( DEBUG_PROTOCOL, ("%s\n", buff) );
|
|
}
|
|
#else
|
|
#define DumpData(Msg,Buffer,Length)
|
|
#endif
|
|
|
|
VOID
|
|
RBSCDelay(
|
|
ULONG waitTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Delay function.
|
|
|
|
Arguments:
|
|
|
|
waitTime - Waiting time in micro-seconds
|
|
|
|
Return Value:
|
|
None
|
|
|
|
--*/
|
|
{
|
|
if( waitTime )
|
|
{
|
|
LARGE_INTEGER delayPeriod;
|
|
|
|
delayPeriod.HighPart = -1;
|
|
delayPeriod.LowPart = waitTime * (-10); // units of 100nsec
|
|
|
|
KeDelayExecutionThread( KernelMode,
|
|
FALSE,
|
|
&delayPeriod );
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
DriverEntry(
|
|
PDRIVER_OBJECT DriverObject,
|
|
PUNICODE_STRING RegistryPath
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called at system initialization time to initialize
|
|
this driver.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - Supplies the driver object.
|
|
RegistryPath - Supplies the registry path for this driver.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS - We could initialize at least one device.
|
|
STATUS_NO_SUCH_DEVICE - We could not initialize even one device.
|
|
|
|
--*/
|
|
{
|
|
#ifndef NT5
|
|
RTL_QUERY_REGISTRY_TABLE paramTable[2];
|
|
ULONG i, noOfDevices = 0;
|
|
DWORD UsedPorts = 1; // COM1 as default
|
|
NTSTATUS status;
|
|
#endif
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!DriverEntry: Enter - %s %s\n",
|
|
__DATE__,
|
|
__TIME__)
|
|
);
|
|
|
|
//
|
|
// Initialize the Driver Object with driver's entry points
|
|
//
|
|
DriverObject->DriverUnload = RBSCUnloadDriver;
|
|
DriverObject->MajorFunction[IRP_MJ_CREATE] = RBSCCreateClose;
|
|
DriverObject->MajorFunction[IRP_MJ_CLOSE] = RBSCCreateClose;
|
|
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = RBSCCleanup;
|
|
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = RBSCDeviceControl;
|
|
|
|
#ifdef NT5
|
|
DriverObject->DriverExtension->AddDevice = RBSCAddDevice;
|
|
DriverObject->MajorFunction[IRP_MJ_POWER] = RBSCPower;
|
|
DriverObject->MajorFunction[IRP_MJ_PNP] = RBSCPnPDeviceControl;
|
|
#else
|
|
RtlZeroMemory( paramTable, sizeof(paramTable) );
|
|
|
|
paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
|
paramTable[0].Name = L"ComPorts";
|
|
paramTable[0].EntryContext = &UsedPorts;
|
|
paramTable[0].DefaultType = REG_DWORD;
|
|
paramTable[0].DefaultData = &UsedPorts;
|
|
paramTable[0].DefaultLength = 0;
|
|
|
|
//
|
|
// now try to find the entry in the registry
|
|
//
|
|
RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE,
|
|
RegistryPath->Buffer,
|
|
¶mTable[0],
|
|
NULL,
|
|
NULL );
|
|
|
|
//
|
|
// We now search the registry for DeviceN value
|
|
//
|
|
for( i = 0;
|
|
noOfDevices < MAXIMUM_SERIAL_READERS && UsedPorts != 0;
|
|
i++, UsedPorts >>= 1 )
|
|
{
|
|
PFILE_OBJECT SerialFileObject;
|
|
PDEVICE_OBJECT SerialDeviceObject;
|
|
UNICODE_STRING SerialDeviceName;
|
|
|
|
while( (UsedPorts & 1) == 0 )
|
|
{
|
|
UsedPorts >>= 1;
|
|
i++;
|
|
}
|
|
|
|
RtlInitUnicodeString( &SerialDeviceName, L"\\Device\\Serial0" );
|
|
|
|
//
|
|
// create string like \Device\SerialN
|
|
//
|
|
SerialDeviceName.Buffer[14] = L'0' + (WCHAR) i;
|
|
|
|
//
|
|
// Try to create a device with the just created device name
|
|
// It is possible that a smart card device with this name
|
|
// already exists from a previous call.
|
|
// It is possible to have up to 4 devices in a system
|
|
//
|
|
status = IoGetDeviceObjectPointer( &SerialDeviceName,
|
|
FILE_ALL_ACCESS,
|
|
&SerialFileObject,
|
|
&SerialDeviceObject );
|
|
if( !NT_SUCCESS(status) )
|
|
{
|
|
UNICODE_STRING comPortNumber;
|
|
WCHAR buffer[2];
|
|
|
|
//
|
|
// Extract the com-port-number
|
|
//
|
|
comPortNumber.Buffer = buffer;
|
|
comPortNumber.Length = sizeof(WCHAR);
|
|
comPortNumber.MaximumLength = sizeof(buffer);
|
|
|
|
comPortNumber.Buffer[0] = SerialDeviceName.Buffer[14] + (WCHAR)1;
|
|
|
|
//
|
|
// Write an event-log msg that this com port is not available
|
|
//
|
|
SmartcardLogError( DriverObject,
|
|
RBSC_CANT_CONNECT_TO_SERIAL_PORT,
|
|
&comPortNumber,
|
|
status );
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Now try to create a device and connect to the serial port
|
|
//
|
|
status = RBSCAddDevice( DriverObject, SerialDeviceObject );
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// We have successfully created a device
|
|
//
|
|
PREADER_EXTENSION ReaderExtension =
|
|
DriverObject->DeviceObject->DeviceExtension;
|
|
|
|
//
|
|
// Save the serial port number this device is connected to
|
|
//
|
|
ReaderExtension->SmartcardExtension.ReaderCapabilities.Channel =
|
|
i + 1;
|
|
|
|
//
|
|
// The fileObject is used in the unload function for
|
|
// dereferencing
|
|
//
|
|
ReaderExtension->SerialFileObject = SerialFileObject;
|
|
|
|
noOfDevices++;
|
|
|
|
} else {
|
|
|
|
//
|
|
// We were unable to get the reader type.
|
|
// So remove the device.
|
|
//
|
|
ObDereferenceObject( SerialFileObject );
|
|
|
|
SmartcardLogError( DriverObject,
|
|
RBSC_CANNOT_OPEN_DEVICE,
|
|
&SerialDeviceName,
|
|
status );
|
|
}
|
|
}
|
|
|
|
if( noOfDevices == 0 )
|
|
{
|
|
SmartcardLogError( DriverObject,
|
|
RBSC_NO_SUCH_DEVICE,
|
|
NULL,
|
|
status );
|
|
return STATUS_NO_SUCH_DEVICE;
|
|
}
|
|
#endif
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
RBSCUnloadDriver(
|
|
PDRIVER_OBJECT DriverObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The driver unload routine. This is called by the I/O system
|
|
when the device is unloaded from memory.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - Pointer to driver object created by system.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS.
|
|
|
|
--*/
|
|
{
|
|
#ifdef NT5
|
|
//
|
|
// We do not need to do anything since all the cleanups are done by
|
|
// RBSCRemoveDevice().
|
|
//
|
|
#else
|
|
while( DriverObject->DeviceObject )
|
|
{
|
|
RBSCRemoveDevice( DriverObject->DeviceObject );
|
|
}
|
|
#endif
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!UnloadDriver\n")
|
|
);
|
|
}
|
|
|
|
#ifdef NT5
|
|
NTSTATUS
|
|
RBSCIoCompletion(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PKEVENT Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Completion routine for an Irp sent to the serial driver. The event will
|
|
be set to notify that the serial driver is done. The routine will not
|
|
'complete' the Irp, so the caller of RBSCCallSerialDriver can continue.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to device object
|
|
Irp - Irp to complete
|
|
Event - Used for process synchronization
|
|
|
|
Return Value:
|
|
STATUS_CANCELLED Irp was cancelled by the IO manager
|
|
STATUS_MORE_PROCESSING_REQUIRED Irp will be finished by caller of
|
|
RBSCCallSerialDriver
|
|
--*/
|
|
{
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
Irp->IoStatus.Status =
|
|
Irp->Cancel ? STATUS_CANCELLED : STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
KeSetEvent( Event, 0, FALSE );
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCCallSerialDriver(
|
|
PDEVICE_OBJECT AttachedSerialPort,
|
|
PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Send an Irp to the serial driver and wait until the serial driver has
|
|
finished the request.
|
|
|
|
To make sure that the serial driver will not complete the Irp we first
|
|
initialize an event and set our own completion routine for the Irp.
|
|
|
|
When the serial driver has processed the Irp the completion routine will
|
|
set the event and tell the IO manager that more processing is required.
|
|
|
|
By waiting for the event we make sure that we continue only if the serial
|
|
driver has processed the Irp completely.
|
|
|
|
Arguments:
|
|
AttachedSerialPort - The PDO
|
|
Irp - Irp to send to the serial driver
|
|
|
|
Return Value:
|
|
|
|
status returned by the serial driver
|
|
|
|
Note:
|
|
Since this function can be called after our device is removed, do not
|
|
use any of the reader extension data here.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
KEVENT Event;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!CallSerialDriver: Enter\n")
|
|
);
|
|
|
|
//
|
|
// Prepare everything to call the underlying driver
|
|
//
|
|
|
|
//
|
|
// Copy our stack to the next stack location.
|
|
//
|
|
IoCopyCurrentIrpStackLocationToNext( Irp);
|
|
|
|
//
|
|
// initialize an event for process synchronization. the event is passed
|
|
// to our completion routine and will be set if the serial driver is done
|
|
//
|
|
KeInitializeEvent( &Event,
|
|
NotificationEvent,
|
|
FALSE );
|
|
|
|
//
|
|
// Our IoCompletionRoutine sets only our event
|
|
//
|
|
IoSetCompletionRoutine( Irp,
|
|
RBSCIoCompletion,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
//
|
|
// Call the serial driver
|
|
//
|
|
status = (IoGetCurrentIrpStackLocation( Irp )->MajorFunction ==
|
|
IRP_MJ_POWER) ?
|
|
PoCallDriver( AttachedSerialPort, Irp ) :
|
|
IoCallDriver( AttachedSerialPort, Irp );
|
|
|
|
//
|
|
// Wait until the serial driver has processed the Irp
|
|
//
|
|
if( status == STATUS_PENDING )
|
|
{
|
|
status = KeWaitForSingleObject( &Event,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE, // No alert
|
|
NULL ); // No timeout
|
|
ASSERT( STATUS_SUCCESS == status );
|
|
status = Irp->IoStatus.Status;
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!CallSerialDriver: Exit %x\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
NTSTATUS
|
|
RBSCStartDevice(
|
|
PDEVICE_OBJECT DeviceObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Open the underlying serial driver and initialize it.
|
|
Then initialize the reader hardware.
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_NO_MEMORY
|
|
status returned by LowLevel routines
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
PDEVICE_OBJECT AttachedSerialPort = ReaderExtension->AttachedSerialPort;
|
|
NTSTATUS status;
|
|
#ifdef NT5
|
|
PIO_STACK_LOCATION irpSp;
|
|
PIRP irp = IoAllocateIrp( (CCHAR)(DeviceObject->StackSize + 1), FALSE );
|
|
ASSERT( irp != NULL );
|
|
|
|
if( irp == NULL )
|
|
{
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
#endif
|
|
|
|
_try {
|
|
|
|
#ifdef NT5
|
|
PIO_STACK_LOCATION irpStack;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
//
|
|
// Open the underlying serial driver.
|
|
// This is necessary for two reasons:
|
|
// a) The serial driver can't be used without opening it
|
|
// b) The call will go through serenum first which informs
|
|
// it to stop looking/polling for new devices.
|
|
//
|
|
irp->UserIosb = &ioStatusBlock;
|
|
IoSetNextIrpStackLocation(irp);
|
|
irpStack = IoGetCurrentIrpStackLocation( irp );
|
|
|
|
irpStack->MajorFunction = IRP_MJ_CREATE;
|
|
irpStack->Parameters.Create.Options = 0;
|
|
irpStack->Parameters.Create.ShareAccess = 0;
|
|
irpStack->Parameters.Create.FileAttributes = 0;
|
|
irpStack->Parameters.Create.EaLength = 0;
|
|
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, irp );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
if( status == STATUS_SHARED_IRQ_BUSY )
|
|
{
|
|
// Port is in use by another device
|
|
SmartcardLogError( DeviceObject,
|
|
RBSC_CANT_SHARE_IRQ,
|
|
NULL,
|
|
0 );
|
|
}
|
|
leave;
|
|
}
|
|
#endif
|
|
KeClearEvent( &ReaderExtension->SerialCloseDone );
|
|
|
|
ReaderExtension->SmartcardExtension.ReaderCapabilities.CurrentState =
|
|
(ULONG) SCARD_UNKNOWN;
|
|
|
|
status = RBSCConfigureSerialPort( ReaderExtension );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// Send a wait mask to the serial driver.
|
|
// This call only sets the wait mask.
|
|
// We want to be informed when CTS or DSR changes its state
|
|
//
|
|
#ifdef NT5
|
|
ReaderExtension->WaitMask = SERIAL_EV_CTS | SERIAL_EV_DSR;
|
|
#else
|
|
ReaderExtension->WaitMask = SERIAL_EV_CTS;
|
|
#endif
|
|
|
|
status = RBSCSerialIo( &ReaderExtension->SmartcardExtension,
|
|
IOCTL_SERIAL_SET_WAIT_MASK,
|
|
(PUCHAR) &ReaderExtension->WaitMask,
|
|
sizeof(ReaderExtension->WaitMask),
|
|
0 );
|
|
if( status != STATUS_SUCCESS)
|
|
{
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// Now tell the serial driver that we want to be informed
|
|
// when CTS or DSR changes its state.
|
|
// Changing the lowest two bits tells IoBuildDeviceIoControlRequest
|
|
// NOT to allocate a system buffer for the I/O operation.
|
|
// We don't need a system buffer since we use our own buffers.
|
|
//
|
|
ReaderExtension->SerialStatusIrp = IoAllocateIrp(
|
|
(CCHAR) (DeviceObject->StackSize + 1),
|
|
FALSE
|
|
);
|
|
|
|
if (ReaderExtension->SerialStatusIrp == NULL) {
|
|
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
leave;
|
|
}
|
|
|
|
irpSp = IoGetNextIrpStackLocation( ReaderExtension->SerialStatusIrp );
|
|
irpSp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
|
|
|
|
irpSp->Parameters.DeviceIoControl.InputBufferLength = 0;
|
|
irpSp->Parameters.DeviceIoControl.OutputBufferLength =
|
|
sizeof(ReaderExtension->WaitMask);
|
|
irpSp->Parameters.DeviceIoControl.IoControlCode =
|
|
IOCTL_SERIAL_WAIT_ON_MASK;
|
|
|
|
ReaderExtension->SerialStatusIrp->AssociatedIrp.SystemBuffer =
|
|
&ReaderExtension->WaitMask;
|
|
|
|
//
|
|
// this artificial delay is necessary to make this driver work
|
|
// with digi board cards
|
|
//
|
|
RBSCDelay( 100000 );
|
|
|
|
//
|
|
// We simulate a callback now that triggers the card supervision
|
|
//
|
|
RBSCSerialEvents(
|
|
ReaderExtension->SmartcardExtension.OsData->DeviceObject,
|
|
ReaderExtension->SerialStatusIrp,
|
|
ReaderExtension
|
|
);
|
|
|
|
#ifdef NT5
|
|
status = IoSetDeviceInterfaceState(
|
|
&ReaderExtension->PnPDeviceName,
|
|
TRUE
|
|
);
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
leave;
|
|
}
|
|
#endif
|
|
KeSetEvent( &ReaderExtension->ReaderStarted, 0, FALSE );
|
|
|
|
} _finally {
|
|
|
|
if (status == STATUS_SHARED_IRQ_BUSY)
|
|
{
|
|
SmartcardLogError( DeviceObject,
|
|
RBSC_IRQ_BUSY,
|
|
NULL,
|
|
status );
|
|
}
|
|
|
|
#ifdef NT5
|
|
IoFreeIrp( irp );
|
|
#endif
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!StartDevice: Exit (%x)\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
RBSCStopDevice(
|
|
PREADER_EXTENSION ReaderExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Waits for the device to be closed
|
|
|
|
Arguments:
|
|
ReaderExtension - Pointer to our device data
|
|
|
|
Return Value:
|
|
void
|
|
|
|
--*/
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!StopDevice: Enter\n")
|
|
);
|
|
|
|
if( !KeReadStateEvent( &ReaderExtension->SerialCloseDone ) )
|
|
{
|
|
NTSTATUS status;
|
|
|
|
// test if we ever started event tracking
|
|
if( ReaderExtension->WaitMask == 0 )
|
|
{
|
|
// no, we did not
|
|
// We 'only' need to close the serial port
|
|
RBSCCloseSerialPort(
|
|
ReaderExtension->SmartcardExtension.OsData->DeviceObject,
|
|
NULL );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We now inform the serial driver that we're no longer
|
|
// interested in serial events. This will also free the irp
|
|
// we use for those io-completions
|
|
//
|
|
ReaderExtension->WaitMask = 0;
|
|
|
|
status = RBSCSerialIo(
|
|
&ReaderExtension->SmartcardExtension,
|
|
IOCTL_SERIAL_SET_WAIT_MASK,
|
|
(PUCHAR)&ReaderExtension->WaitMask,
|
|
sizeof(ULONG),
|
|
0
|
|
);
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
// now wait until the connetion to serial is closed
|
|
status = KeWaitForSingleObject(
|
|
&ReaderExtension->SerialCloseDone,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL
|
|
);
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
}
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!StopDevice\n")
|
|
);
|
|
}
|
|
|
|
VOID
|
|
RBSCRemoveDevice(
|
|
PDEVICE_OBJECT DeviceObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Stops the device then releases all the resources used.
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
|
|
Return Value:
|
|
void
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PREADER_EXTENSION ReaderExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension;
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!RemoveDevice: Enter\n")
|
|
);
|
|
|
|
ReaderExtension = DeviceObject->DeviceExtension;
|
|
SmartcardExtension = &ReaderExtension->SmartcardExtension;
|
|
|
|
if( SmartcardExtension->OsData )
|
|
{
|
|
// complete pending card tracking requests (if any)
|
|
RBSCCompleteCardTracking( SmartcardExtension );
|
|
ASSERT( SmartcardExtension->OsData->NotificationIrp == NULL );
|
|
#ifdef NT5
|
|
SmartcardReleaseRemoveLockAndWait( SmartcardExtension );
|
|
#endif
|
|
}
|
|
|
|
#ifndef NT5
|
|
//
|
|
// Free the device slot (if in use)
|
|
//
|
|
UsedPortsMask &= ~(1<<SmartcardExtension->VendorAttr.UnitNo);
|
|
#endif
|
|
|
|
RBSCStopDevice( ReaderExtension );
|
|
|
|
#ifdef NT5
|
|
if( ReaderExtension->AttachedSerialPort )
|
|
{
|
|
IoDetachDevice( ReaderExtension->AttachedSerialPort );
|
|
}
|
|
|
|
if( ReaderExtension->PnPDeviceName.Buffer != NULL )
|
|
{
|
|
RtlFreeUnicodeString( &ReaderExtension->PnPDeviceName );
|
|
}
|
|
|
|
if( ReaderExtension->CloseSerial != NULL )
|
|
{
|
|
IoFreeWorkItem(ReaderExtension->CloseSerial);
|
|
}
|
|
#else
|
|
if( ReaderExtension->SerialFileObject )
|
|
{
|
|
ObDereferenceObject( ReaderExtension->SerialFileObject );
|
|
}
|
|
|
|
if( ReaderExtension->DosDeviceName.Buffer != NULL )
|
|
{
|
|
//
|
|
// Delete the symbolic link of the smart card reader
|
|
//
|
|
IoDeleteSymbolicLink( &ReaderExtension->DosDeviceName );
|
|
RtlFreeUnicodeString( &ReaderExtension->DosDeviceName );
|
|
}
|
|
#endif
|
|
|
|
if( SmartcardExtension->OsData != NULL )
|
|
{
|
|
SmartcardExit( SmartcardExtension );
|
|
}
|
|
|
|
IoDeleteDevice( DeviceObject );
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!RemoveDevice: Exit\n")
|
|
);
|
|
}
|
|
|
|
#ifdef NT5
|
|
NTSTATUS
|
|
RBSCPnPDeviceControl(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
driver callback for pnp manager
|
|
|
|
Request: Action:
|
|
|
|
IRP_MN_START_DEVICE Notify the driver about the new device
|
|
and start the device
|
|
|
|
IRP_MN_STOP_DEVICE Free all resources used by the device and
|
|
tell the driver that the device was stopped
|
|
|
|
IRP_MN_QUERY_REMOVE_DEVICE If the device is opened (i.e. in use) an
|
|
error will be returned to prevent the PnP
|
|
manager to stop the driver
|
|
|
|
IRP_MN_CANCEL_REMOVE_DEVICE just notify that we can continue without any
|
|
restrictions
|
|
|
|
IRP_MN_REMOVE_DEVICE notify the driver that the device was
|
|
removed, stop & unload the device
|
|
|
|
All other requests will be passed to the driver to ensure correct
|
|
processing.
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
Irp - Irp from the PnP manager
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_UNSUCCESSFUL
|
|
status returned by serial driver
|
|
|
|
--*/
|
|
{
|
|
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
PDEVICE_OBJECT AttachedSerialPort = ReaderExtension->AttachedSerialPort;
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION stack;
|
|
BOOLEAN deviceRemoved = FALSE, irpSkipped = FALSE;
|
|
KEVENT Event;
|
|
KIRQL irql;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!PnPDeviceControl: Enter (%08x)\n",
|
|
IoGetCurrentIrpStackLocation( Irp )->MinorFunction)
|
|
);
|
|
|
|
status = SmartcardAcquireRemoveLockWithTag(
|
|
&ReaderExtension->SmartcardExtension, ' PnP' );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
Irp->IoStatus.Status = status;
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
return status;
|
|
}
|
|
|
|
stack = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Now look what the PnP manager wants...
|
|
//
|
|
switch( stack->MinorFunction )
|
|
{
|
|
case IRP_MN_START_DEVICE:
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_START_DEVICE\n")
|
|
);
|
|
|
|
// We have to call the underlying driver first
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
if( status == STATUS_SUCCESS)
|
|
{
|
|
status = RBSCStartDevice( DeviceObject );
|
|
}
|
|
break;
|
|
|
|
case IRP_MN_QUERY_STOP_DEVICE:
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_QUERY_STOP_DEVICE\n")
|
|
);
|
|
|
|
KeAcquireSpinLock( &ReaderExtension->SpinLock, &irql );
|
|
if( ReaderExtension->IoCount > 0 )
|
|
{
|
|
// we refuse to stop if we have pending io
|
|
KeReleaseSpinLock( &ReaderExtension->SpinLock, irql );
|
|
status = STATUS_DEVICE_BUSY;
|
|
break;
|
|
}
|
|
|
|
// stop processing requests
|
|
KeClearEvent( &ReaderExtension->ReaderStarted );
|
|
KeReleaseSpinLock( &ReaderExtension->SpinLock, irql );
|
|
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
break;
|
|
|
|
case IRP_MN_CANCEL_STOP_DEVICE:
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_CANCEL_STOP_DEVICE\n")
|
|
);
|
|
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
// we can continue to process requests
|
|
KeSetEvent( &ReaderExtension->ReaderStarted, 0, FALSE );
|
|
}
|
|
break;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_STOP_DEVICE\n")
|
|
);
|
|
|
|
RBSCStopDevice( ReaderExtension );
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
break;
|
|
|
|
case IRP_MN_QUERY_REMOVE_DEVICE:
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_QUERY_REMOVE_DEVICE\n")
|
|
);
|
|
|
|
// disable the interface (and ignore possible errors)
|
|
IoSetDeviceInterfaceState(
|
|
&ReaderExtension->PnPDeviceName,
|
|
FALSE
|
|
);
|
|
|
|
// now look if someone is currently connected to us
|
|
if (ReaderExtension->ReaderOpen)
|
|
{
|
|
//
|
|
// someone is connected, fail the call
|
|
// we will enable the device interface in
|
|
// IRP_MN_CANCEL_REMOVE_DEVICE again
|
|
//
|
|
status = STATUS_UNSUCCESSFUL;
|
|
break;
|
|
}
|
|
|
|
// pass the call to the next driver in the stack
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
|
|
break;
|
|
|
|
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_CANCEL_REMOVE_DEVICE\n")
|
|
);
|
|
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
|
|
//
|
|
// reenable the interface only in case that the reader is
|
|
// still connected. This covers the following case:
|
|
// hibernate machine, disconnect reader, wake up, stop device
|
|
// (from task bar) and stop fails since an app. holds the device open
|
|
//
|
|
if( status == STATUS_SUCCESS &&
|
|
ReaderExtension->WaitMask != 0 )
|
|
{
|
|
status = IoSetDeviceInterfaceState(
|
|
&ReaderExtension->PnPDeviceName,
|
|
TRUE
|
|
);
|
|
|
|
ASSERT(status == STATUS_SUCCESS);
|
|
}
|
|
break;
|
|
|
|
case IRP_MN_REMOVE_DEVICE:
|
|
// Remove our device
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!PnPDeviceControl: IRP_MN_REMOVE_DEVICE\n")
|
|
);
|
|
|
|
RBSCRemoveDevice( DeviceObject );
|
|
// DeviceObject is freed, do not reference it again.
|
|
status = RBSCCallSerialDriver( AttachedSerialPort, Irp );
|
|
deviceRemoved = TRUE;
|
|
break;
|
|
|
|
default:
|
|
// This is an Irp that is only useful for underlying drivers
|
|
IoSkipCurrentIrpStackLocation(Irp);
|
|
status = IoCallDriver( AttachedSerialPort, Irp );
|
|
irpSkipped = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( !irpSkipped )
|
|
{
|
|
Irp->IoStatus.Status = status;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
if( !deviceRemoved )
|
|
{
|
|
SmartcardReleaseRemoveLockWithTag(
|
|
&ReaderExtension->SmartcardExtension, ' PnP' );
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!PnPDeviceControl: Exit %x\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
NTSTATUS
|
|
RBSCAddDevice(
|
|
PDRIVER_OBJECT DriverObject,
|
|
PDEVICE_OBJECT PhysicalDeviceObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the add-device routine for the miniport.
|
|
Find a device slot then, create device object and attach it to the
|
|
given PhysicalDeviceObject.
|
|
Initialize the device extension and its smart card data.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - a pointer to the driver object for this device
|
|
PhysicalDeviceObject- The device object of the serial port to attach to
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PDEVICE_OBJECT DeviceObject = NULL;
|
|
PSMARTCARD_EXTENSION SmartcardExtension = NULL;
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!AddDevice: Enter\n")
|
|
);
|
|
|
|
try {
|
|
|
|
ULONG DeviceNo;
|
|
PREADER_EXTENSION ReaderExtension;
|
|
#ifndef NT5
|
|
UNICODE_STRING SmartcardDeviceName;
|
|
|
|
for( DeviceNo = 0;
|
|
DeviceNo < MAXIMUM_SERIAL_READERS;
|
|
DeviceNo++ )
|
|
{
|
|
if( (UsedPortsMask & (1<<DeviceNo)) == 0 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( DeviceNo == MAXIMUM_SERIAL_READERS )
|
|
{
|
|
SmartcardLogError(
|
|
DriverObject,
|
|
RBSC_CANT_CREATE_MORE_DEVICES,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// construct the device name
|
|
//
|
|
RtlInitUnicodeString( &SmartcardDeviceName, L"\\Device\\RNBO3531?" );
|
|
SmartcardDeviceName.Buffer[16] = L'0' + (WCHAR) DeviceNo;
|
|
#endif
|
|
//
|
|
// Create the functional device object
|
|
//
|
|
status = IoCreateDevice(
|
|
DriverObject,
|
|
sizeof(READER_EXTENSION),
|
|
#ifdef NT5
|
|
NULL, // No name
|
|
#else
|
|
&SmartcardDeviceName,
|
|
#endif
|
|
FILE_DEVICE_SMARTCARD,
|
|
0,
|
|
TRUE, // Exclusive
|
|
&DeviceObject
|
|
);
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
SmartcardLogError( DriverObject,
|
|
RBSC_CANT_CREATE_DEVICE,
|
|
NULL,
|
|
0 );
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// set up the device extension and initialize it.
|
|
//
|
|
ReaderExtension = DeviceObject->DeviceExtension;
|
|
SmartcardExtension = &ReaderExtension->SmartcardExtension;
|
|
SmartcardExtension->ReaderExtension = ReaderExtension;
|
|
|
|
#ifdef NT5
|
|
ReaderExtension->CloseSerial = IoAllocateWorkItem(
|
|
DeviceObject
|
|
);
|
|
|
|
if (ReaderExtension->CloseSerial == NULL) {
|
|
|
|
SmartcardLogError(
|
|
DriverObject,
|
|
RBSC_NO_MEMORY,
|
|
NULL,
|
|
0
|
|
);
|
|
leave;
|
|
}
|
|
#endif
|
|
// Used for stop / start notification
|
|
KeInitializeEvent( &ReaderExtension->ReaderStarted,
|
|
NotificationEvent,
|
|
FALSE );
|
|
|
|
KeInitializeEvent( &ReaderExtension->SerialCloseDone,
|
|
NotificationEvent,
|
|
TRUE );
|
|
|
|
// Used to keep track of open close calls
|
|
ReaderExtension->ReaderOpen = FALSE;
|
|
|
|
KeInitializeSpinLock( &ReaderExtension->SpinLock );
|
|
|
|
//
|
|
// enter correct version of the lib
|
|
//
|
|
SmartcardExtension->Version = SMCLIB_VERSION;
|
|
SmartcardExtension->SmartcardRequest.BufferSize =
|
|
SmartcardExtension->SmartcardReply.BufferSize = MIN_BUFFER_SIZE;
|
|
|
|
status = SmartcardInitialize( SmartcardExtension );
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
SmartcardLogError(
|
|
DriverObject,
|
|
(SmartcardExtension->OsData ?
|
|
RBSC_WRONG_LIB_VESION : RBSC_NO_MEMORY),
|
|
NULL,
|
|
0
|
|
);
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// Set up call back functions
|
|
//
|
|
SmartcardExtension->ReaderFunction[ RDF_TRANSMIT ] =
|
|
RBSCTransmit;
|
|
SmartcardExtension->ReaderFunction[ RDF_SET_PROTOCOL ] =
|
|
RBSCSetProtocol;
|
|
SmartcardExtension->ReaderFunction[ RDF_CARD_POWER ] =
|
|
RBSCReaderPower;
|
|
SmartcardExtension->ReaderFunction[ RDF_CARD_TRACKING ] =
|
|
RBSCCardTracking;
|
|
|
|
//
|
|
// setup smartcard extension
|
|
//
|
|
//
|
|
// Initialize the vendor information
|
|
//
|
|
strcpy( SmartcardExtension->VendorAttr.VendorName.Buffer,
|
|
VENDOR_NAME );
|
|
|
|
SmartcardExtension->VendorAttr.VendorName.Length =
|
|
sizeof(VENDOR_NAME);
|
|
|
|
strcpy( SmartcardExtension->VendorAttr.IfdType.Buffer,
|
|
READER_NAME );
|
|
|
|
SmartcardExtension->VendorAttr.IfdType.Length =
|
|
sizeof(READER_NAME);
|
|
|
|
SmartcardExtension->VendorAttr.UnitNo = MAXULONG;
|
|
|
|
for (DeviceNo = 0; DeviceNo < MAXULONG; DeviceNo++)
|
|
{
|
|
PDEVICE_OBJECT devObj;
|
|
|
|
for (devObj = DeviceObject;
|
|
devObj != NULL;
|
|
devObj = devObj->NextDevice)
|
|
{
|
|
PREADER_EXTENSION devExt = devObj->DeviceExtension;
|
|
|
|
if (DeviceNo ==
|
|
devExt->SmartcardExtension.VendorAttr.UnitNo)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (devObj == NULL)
|
|
{
|
|
SmartcardExtension->VendorAttr.UnitNo = DeviceNo;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// tell the lib our device object
|
|
//
|
|
SmartcardExtension->OsData->DeviceObject = DeviceObject;
|
|
|
|
#ifdef NT5
|
|
ReaderExtension->AttachedSerialPort = IoAttachDeviceToDeviceStack(
|
|
DeviceObject,
|
|
PhysicalDeviceObject
|
|
);
|
|
|
|
if( ReaderExtension->AttachedSerialPort == NULL )
|
|
{
|
|
SmartcardLogError( DriverObject,
|
|
RBSC_CANT_ATTACH_TO_SERIAL_PORT,
|
|
&DriverObject->DriverName,
|
|
0 );
|
|
status = STATUS_UNSUCCESSFUL;
|
|
leave;
|
|
}
|
|
|
|
// register our new device
|
|
status = IoRegisterDeviceInterface( PhysicalDeviceObject,
|
|
&SmartCardReaderGuid,
|
|
NULL,
|
|
&ReaderExtension->PnPDeviceName );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
ReaderExtension->ReaderPowerState = PowerReaderWorking;
|
|
#else
|
|
//
|
|
// Save the deviceObject for the connected serial port
|
|
//
|
|
ReaderExtension->AttachedSerialPort = PhysicalDeviceObject;
|
|
|
|
status = RBSCStartDevice( DeviceObject );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// Create a symbolic link
|
|
//
|
|
status = SmartcardCreateLink( &ReaderExtension->DosDeviceName,
|
|
&SmartcardDeviceName );
|
|
#endif
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// tell the OS that we supposed to do buffered io
|
|
//
|
|
#ifdef NT5
|
|
DeviceObject->Flags |= (DO_BUFFERED_IO | DO_POWER_PAGABLE);
|
|
#else
|
|
DeviceObject->Flags |= DO_BUFFERED_IO;
|
|
UsedPortsMask |= (1<<DeviceNo);
|
|
#endif
|
|
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!AddDevice: Device #%d created Ext=%08x.\n",
|
|
DeviceNo,ReaderExtension)
|
|
);
|
|
}
|
|
finally
|
|
{
|
|
if( status != STATUS_SUCCESS && DeviceObject != NULL )
|
|
{
|
|
RBSCRemoveDevice( DeviceObject );
|
|
}
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!AddDevice: Exit %x\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCConfigureSerialPort(
|
|
PREADER_EXTENSION ReaderExtension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine reads the default configuraton values for this device.
|
|
|
|
Arguments:
|
|
|
|
ReaderExtension - Pointer to our device data
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
PSMARTCARD_EXTENSION SmartcardExtension =
|
|
&ReaderExtension->SmartcardExtension;
|
|
PUCHAR RxBuffer = SmartcardExtension->SmartcardReply.Buffer;
|
|
NTSTATUS status;
|
|
|
|
{
|
|
//
|
|
// Set up baudrate
|
|
//
|
|
SERIAL_BAUD_RATE BaudRate;
|
|
|
|
BaudRate.BaudRate = DATARATE_DEFAULT;
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_BAUD_RATE,
|
|
(PUCHAR) &BaudRate,
|
|
sizeof(SERIAL_BAUD_RATE),
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Set up line control parameters
|
|
//
|
|
ReaderExtension->LineControl.Parity = ODD_PARITY;
|
|
ReaderExtension->LineControl.StopBits = STOP_BIT_1;
|
|
ReaderExtension->LineControl.WordLength = SERIAL_DATABITS_8;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_LINE_CONTROL,
|
|
(PUCHAR)&ReaderExtension->LineControl,
|
|
sizeof(SERIAL_LINE_CONTROL),
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Set serial special characters
|
|
//
|
|
SERIAL_CHARS SerialChars;
|
|
|
|
SerialChars.ErrorChar = 0;
|
|
SerialChars.EofChar = 0;
|
|
SerialChars.EventChar = 0;
|
|
SerialChars.XonChar = 0;
|
|
SerialChars.XoffChar = 0;
|
|
SerialChars.BreakChar = 0xFF;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_CHARS,
|
|
(PUCHAR) &SerialChars,
|
|
sizeof(SERIAL_CHARS),
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Set up timeouts (all in msec)
|
|
//
|
|
ReaderExtension->SerialTimeouts.ReadTotalTimeoutMultiplier = 1;
|
|
ReaderExtension->SerialTimeouts.ReadIntervalTimeout = 2*
|
|
ATR_CHAR_TIMEOUT/1000;
|
|
ReaderExtension->SerialTimeouts.ReadTotalTimeoutConstant = 2*
|
|
ATR_BLOCK_TIMEOUT/1000;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_TIMEOUTS,
|
|
(PUCHAR)&ReaderExtension->SerialTimeouts,
|
|
sizeof(SERIAL_TIMEOUTS),
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Set flowcontrol and handshaking
|
|
//
|
|
SERIAL_HANDFLOW HandFlow;
|
|
|
|
HandFlow.XonLimit = 0;
|
|
HandFlow.XoffLimit = 0;
|
|
HandFlow.FlowReplace = SERIAL_XOFF_CONTINUE ;
|
|
HandFlow.ControlHandShake = 0;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_HANDFLOW,
|
|
(PUCHAR) &HandFlow,
|
|
sizeof(SERIAL_HANDFLOW),
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Set break off
|
|
//
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_BREAK_OFF,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_RTS,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_DTR,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Toggle DTR line to wake-up the reader if it is
|
|
// in SLEEP mode
|
|
//
|
|
RBSCDelay( 10000 );
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_CLR_DTR,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_DTR,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
RBSCDelay( 10000 );
|
|
status = RBSCPacketExchange( SmartcardExtension,
|
|
GetReaderType,
|
|
sizeof(GetReaderType),
|
|
WAIT_TIME_READER_TYPE,
|
|
TRUE );
|
|
}
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
return status;
|
|
}
|
|
|
|
if( SmartcardExtension->SmartcardReply.BufferLength <
|
|
SIZE_READER_TYPE ||
|
|
RxBuffer[0] != 'R' || RxBuffer[1] != 'N' ||
|
|
RxBuffer[2] != 'B' || RxBuffer[3] != 'O' ||
|
|
RxBuffer[15] != READER_TYPE_1 )
|
|
{
|
|
return STATUS_DEVICE_DATA_ERROR;
|
|
}
|
|
|
|
//
|
|
// Set reader info
|
|
//
|
|
SmartcardExtension->VendorAttr.IfdVersion.VersionMajor =
|
|
(UCHAR)RxBuffer[6];
|
|
SmartcardExtension->VendorAttr.IfdVersion.VersionMinor =
|
|
(UCHAR)RxBuffer[7];
|
|
SmartcardExtension->VendorAttr.IfdVersion.BuildNumber =
|
|
((USHORT)RxBuffer[8]<<8) + ((USHORT)RxBuffer[9]);
|
|
|
|
//
|
|
// Clk frequency in KHz encoded as little endian integer
|
|
//
|
|
SmartcardExtension->ReaderCapabilities.CLKFrequency.Default =
|
|
SmartcardExtension->ReaderCapabilities.CLKFrequency.Max =
|
|
((USHORT)RxBuffer[10]<<8) + ((USHORT)RxBuffer[11]);
|
|
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Default =
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max = DATARATE_DEFAULT;
|
|
|
|
if( RxBuffer[13] != 0 )
|
|
{
|
|
// reader is supposed to support higher data rates
|
|
ULONG NumRates = 1;
|
|
|
|
if( RxBuffer[13] & DATARATE_14400 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 14400;
|
|
}
|
|
|
|
if( RxBuffer[13] & DATARATE_19200 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 19200;
|
|
}
|
|
|
|
if( RxBuffer[13] & DATARATE_28800 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 28800;
|
|
}
|
|
|
|
if( RxBuffer[13] & DATARATE_38400 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 38400;
|
|
}
|
|
|
|
if( RxBuffer[13] & DATARATE_57600 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 57600;
|
|
}
|
|
|
|
if( RxBuffer[13] & DATARATE_115200 )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max =
|
|
ReaderExtension->DataRatesSupported[ NumRates++ ] = 115200;
|
|
}
|
|
|
|
if( NumRates > 1 )
|
|
{
|
|
ReaderExtension->DataRatesSupported[0] = 9600; // always supported
|
|
SmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries =
|
|
(UCHAR) NumRates;
|
|
SmartcardExtension->ReaderCapabilities.DataRatesSupported.List =
|
|
ReaderExtension->DataRatesSupported;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!ConfigureSerialPort: %ld DataRates, Max=%ld\n",
|
|
NumRates,
|
|
SmartcardExtension->ReaderCapabilities.DataRate.Max)
|
|
);
|
|
}
|
|
}
|
|
|
|
SmartcardExtension->ReaderCapabilities.MaxIFSD = MAX_IFSD;
|
|
|
|
//
|
|
// setup smartcard extension - reader capabilities
|
|
//
|
|
SmartcardExtension->ReaderCapabilities.SupportedProtocols =
|
|
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
|
|
|
|
SmartcardExtension->ReaderCapabilities.ReaderType =
|
|
SCARD_READER_TYPE_SERIAL;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_GET_MODEMSTATUS,
|
|
NULL,
|
|
0,
|
|
sizeof(ReaderExtension->ModemStatus) );
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
ReaderExtension->ModemStatus =
|
|
*(PULONG)SmartcardExtension->SmartcardReply.Buffer;
|
|
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
(ReaderExtension->ModemStatus & SERIAL_CTS_STATE) ?
|
|
SCARD_SWALLOWED : SCARD_ABSENT;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCCreateClose(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the I/O system when the device is opened
|
|
or closed.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to device object
|
|
Irp - IRP involved.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension =
|
|
&ReaderExtension->SmartcardExtension;
|
|
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
__try
|
|
{
|
|
if( irpStack->MajorFunction == IRP_MJ_CREATE )
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Create\n")
|
|
);
|
|
|
|
#ifdef NT5
|
|
if( SmartcardAcquireRemoveLockWithTag(
|
|
SmartcardExtension, 'lCrC' ) != STATUS_SUCCESS )
|
|
{
|
|
status = STATUS_DEVICE_REMOVED;
|
|
__leave;
|
|
}
|
|
|
|
// test if the device has been opened already
|
|
if (InterlockedCompareExchange(
|
|
&ReaderExtension->ReaderOpen,
|
|
TRUE,
|
|
FALSE) == FALSE)
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!CreateClose: Open\n")
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// the device is already in use
|
|
status = STATUS_UNSUCCESSFUL;
|
|
|
|
// release the lock
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension,
|
|
'lCrC' );
|
|
}
|
|
|
|
#endif
|
|
} else {
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Close\n")
|
|
);
|
|
|
|
#ifdef NT5
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension,
|
|
'lCrC' );
|
|
#endif
|
|
ReaderExtension->ReaderOpen = FALSE;
|
|
}
|
|
|
|
}
|
|
__finally
|
|
{
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = 0;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCCancel(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the I/O system
|
|
when the irp should be cancelled
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to device object
|
|
Irp - IRP involved.
|
|
|
|
Return Value:
|
|
|
|
STATUS_CANCELLED
|
|
|
|
--*/
|
|
|
|
{
|
|
PREADER_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension = &deviceExtension->SmartcardExtension;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("%s!RBSCCancel: Enter\n",
|
|
DRIVER_NAME)
|
|
);
|
|
|
|
ASSERT(Irp == SmartcardExtension->OsData->NotificationIrp);
|
|
|
|
IoReleaseCancelSpinLock(
|
|
Irp->CancelIrql
|
|
);
|
|
|
|
RBSCCompleteCardTracking(SmartcardExtension);
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("%s!RBSCCancel: Exit\n",
|
|
DRIVER_NAME)
|
|
);
|
|
|
|
return STATUS_CANCELLED;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCCleanup(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the I/O system when the calling thread
|
|
terminates
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to device object
|
|
Irp - IRP involved.
|
|
|
|
Return Value:
|
|
|
|
STATUS_CANCELLED
|
|
|
|
--*/
|
|
|
|
{
|
|
PREADER_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension = &deviceExtension->SmartcardExtension;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("%s!RBSCCleanup: Enter\n",
|
|
DRIVER_NAME)
|
|
);
|
|
|
|
ASSERT(Irp != SmartcardExtension->OsData->NotificationIrp);
|
|
|
|
// We need to complete the notification irp
|
|
RBSCCompleteCardTracking(SmartcardExtension);
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("%s!RBSCCleanup: 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!RBSCCleanup: Exit\n",
|
|
DRIVER_NAME)
|
|
);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCSerialIo(
|
|
PSMARTCARD_EXTENSION SmartcardExtension,
|
|
ULONG SerialIoControlCode,
|
|
PUCHAR TxBuffer,
|
|
ULONG TxSize,
|
|
ULONG RxSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sends IOCTL's to the serial driver. It waits on for their
|
|
completion, and then returns.
|
|
|
|
Arguments:
|
|
SmartcardExtension - Pointer to the smart card data
|
|
SerialIoControlCode - IOCTL code to be sent to the serial driver
|
|
TxBuffer - Ponter to the data to send
|
|
TxSize - Size of data to send
|
|
RxSize - Number of bytes expected to receive
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = SmartcardExtension->ReaderExtension;
|
|
NTSTATUS status;
|
|
IO_STATUS_BLOCK ioStatus;
|
|
KEVENT event;
|
|
PIRP irp;
|
|
|
|
if (KeReadStateEvent(&ReaderExtension->SerialCloseDone))
|
|
{
|
|
//
|
|
// we have no connection to serial, fail the call
|
|
// this could be the case if the reader was removed
|
|
// during stand by / hibernation
|
|
//
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Check if the buffers are large enough
|
|
//
|
|
ASSERT( RxSize <= SmartcardExtension->SmartcardReply.BufferSize );
|
|
|
|
if( RxSize > SmartcardExtension->SmartcardReply.BufferSize )
|
|
{
|
|
SmartcardLogError( SmartcardExtension->OsData->DeviceObject,
|
|
RBSC_BUFFER_TOO_SMALL,
|
|
NULL,
|
|
0 );
|
|
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
KeInitializeEvent( &event, NotificationEvent, FALSE );
|
|
|
|
//
|
|
// Build irp to be sent to serial driver
|
|
//
|
|
irp = IoBuildDeviceIoControlRequest(
|
|
SerialIoControlCode,
|
|
ReaderExtension->AttachedSerialPort,
|
|
(TxSize ? TxBuffer : NULL),
|
|
TxSize,
|
|
(RxSize ? SmartcardExtension->SmartcardReply.Buffer : NULL),
|
|
RxSize,
|
|
FALSE,
|
|
&event,
|
|
&ioStatus
|
|
);
|
|
|
|
ASSERT( irp != NULL );
|
|
|
|
if( irp == NULL )
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
switch( SerialIoControlCode )
|
|
{
|
|
PIO_STACK_LOCATION nextsp;
|
|
|
|
//
|
|
// The serial driver trasfers data from/to
|
|
// irp->AssociatedIrp.SystemBuffer
|
|
//
|
|
case SMARTCARD_WRITE:
|
|
nextsp = IoGetNextIrpStackLocation( irp );
|
|
nextsp->MajorFunction = IRP_MJ_WRITE;
|
|
nextsp->Parameters.Write.Length = TxSize;
|
|
nextsp->Parameters.Write.ByteOffset.QuadPart = 0;
|
|
break;
|
|
|
|
case SMARTCARD_READ:
|
|
nextsp = IoGetNextIrpStackLocation( irp );
|
|
nextsp->MajorFunction = IRP_MJ_READ;
|
|
nextsp->Parameters.Read.Length = RxSize;
|
|
nextsp->Parameters.Read.ByteOffset.QuadPart = 0;
|
|
break;
|
|
}
|
|
|
|
status = IoCallDriver( ReaderExtension->AttachedSerialPort, irp );
|
|
|
|
if( status == STATUS_PENDING )
|
|
{
|
|
KeWaitForSingleObject( &event,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
status = ioStatus.Status;
|
|
|
|
if( status == STATUS_TIMEOUT &&
|
|
ioStatus.Information != 0 &&
|
|
ioStatus.Information < RxSize )
|
|
{
|
|
// Ignore time-out if some data returned
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
|
|
// save the number of bytes received
|
|
SmartcardExtension->SmartcardReply.BufferLength =
|
|
(RxSize != 0 && status == STATUS_SUCCESS) ?
|
|
(ULONG) ioStatus.Information : 0;
|
|
|
|
} else {
|
|
SmartcardExtension->SmartcardReply.BufferLength =
|
|
(status == STATUS_SUCCESS) ? RxSize : 0;
|
|
}
|
|
|
|
#if 0
|
|
if( SerialIoControlCode == SMARTCARD_WRITE )
|
|
{
|
|
// TDB: Wait for Tx buffer empty
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// STATUS_TIMEOUT isn't correctly mapped
|
|
// to a WIN32 error, that's why we change it here
|
|
// to STATUS_IO_TIMEOUT
|
|
//
|
|
return( (status == STATUS_TIMEOUT) ? STATUS_IO_TIMEOUT : status );
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCWriteToCard(
|
|
PSMARTCARD_EXTENSION SmartcardExtension,
|
|
PUCHAR Buffer,
|
|
ULONG Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sends data to the smart card. It handles the inverse
|
|
convention and gaurd time.
|
|
|
|
Arguments:
|
|
SmartcardExtension - Pointer to our smartcard data
|
|
Buffer - Points to the data to send
|
|
Length - Length of data to send (bytes)
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
UCHAR TempBuffer[MIN_BUFFER_SIZE];
|
|
ULONG StopBits = SmartcardExtension->CardCapabilities.PtsData.StopBits;
|
|
|
|
DumpData( "Data to the card", Buffer, Length );
|
|
|
|
if( SmartcardExtension->CardCapabilities.ATR.Buffer[0] == 0x3F )
|
|
{
|
|
ULONG l;
|
|
|
|
if( Length > sizeof(TempBuffer) )
|
|
{
|
|
return STATUS_DEVICE_DATA_ERROR;
|
|
}
|
|
|
|
for( l = 0; l < Length; l++ )
|
|
{
|
|
TempBuffer[l] = InverseCharTable[ Buffer[l] ];
|
|
}
|
|
|
|
Buffer = TempBuffer;
|
|
}
|
|
|
|
|
|
if( StopBits <= 2 )
|
|
{
|
|
return RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_WRITE,
|
|
Buffer,
|
|
Length,
|
|
0 );
|
|
}
|
|
|
|
while( Length != 0 )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_WRITE,
|
|
Buffer,
|
|
1,
|
|
0 );
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
return status;
|
|
}
|
|
|
|
Buffer++;
|
|
Length--;
|
|
|
|
if( Length != 0 )
|
|
KeStallExecutionProcessor(
|
|
(StopBits-1)*SmartcardExtension->CardCapabilities.etu );
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCSetCommParams(
|
|
PSMARTCARD_EXTENSION SmartcardExtension,
|
|
ULONG DataRate
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the stop bits and read timeouts of the serial driver.
|
|
|
|
Arguments:
|
|
SmartcardExtension - Pointer to our smartcard data
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PSERIAL_LINE_CONTROL plc =
|
|
&SmartcardExtension->ReaderExtension->LineControl;
|
|
PSERIAL_TIMEOUTS timeout =
|
|
&SmartcardExtension->ReaderExtension->SerialTimeouts;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_PROTOCOL,
|
|
("RNBO3531!SetCommParams: DataRate=%ld, StopBits=%d\n",
|
|
DataRate,SmartcardExtension->CardCapabilities.PtsData.StopBits)
|
|
);
|
|
|
|
plc->StopBits =
|
|
(SmartcardExtension->CardCapabilities.PtsData.StopBits == 2) ?
|
|
STOP_BITS_2 : STOP_BIT_1;
|
|
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_LINE_CONTROL,
|
|
(PUCHAR) plc,
|
|
sizeof(SERIAL_LINE_CONTROL),
|
|
0 );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
return status;
|
|
}
|
|
|
|
if( SmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries > 1 )
|
|
{
|
|
// Setup baudrate
|
|
SERIAL_BAUD_RATE BaudRate;
|
|
|
|
BaudRate.BaudRate = DataRate;
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_BAUD_RATE,
|
|
(PUCHAR) &BaudRate,
|
|
sizeof(SERIAL_BAUD_RATE),
|
|
0 );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
return status;
|
|
}
|
|
}
|
|
|
|
if( SmartcardExtension->CardCapabilities.Protocol.Selected &
|
|
SCARD_PROTOCOL_T1 )
|
|
{
|
|
timeout->ReadTotalTimeoutConstant = 2* // for safty
|
|
(SmartcardExtension->CardCapabilities.T1.BWT +
|
|
WAIT_TIME_MINIMUM)/1000;
|
|
|
|
timeout->ReadIntervalTimeout = 2* // for safty
|
|
(SmartcardExtension->CardCapabilities.T1.CWT +
|
|
WAIT_TIME_MINIMUM)/1000;
|
|
|
|
} else {
|
|
|
|
timeout->ReadTotalTimeoutConstant =
|
|
timeout->ReadIntervalTimeout = 2* // for safty
|
|
(SmartcardExtension->CardCapabilities.T0.WT +
|
|
WAIT_TIME_MINIMUM)/1000;
|
|
}
|
|
|
|
//
|
|
// Set up timeout (in msec)
|
|
//
|
|
return RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_TIMEOUTS,
|
|
(PUCHAR) timeout,
|
|
sizeof(SERIAL_TIMEOUTS),
|
|
0 );
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCReadFromCard(
|
|
PSMARTCARD_EXTENSION SmartcardExtension,
|
|
ULONG Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads a block of data from the card.
|
|
On successful read, it converts the data if inverse conversion used.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data.
|
|
Length - Number of bytes to read.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_PROTOCOL,
|
|
("RNBO3531!ReadFromCard(%ld)\n",Length)
|
|
);
|
|
|
|
status = RBSCSerialIo(
|
|
SmartcardExtension,
|
|
SMARTCARD_READ,
|
|
NULL,
|
|
0,
|
|
Length
|
|
);
|
|
|
|
if( status == STATUS_SUCCESS &&
|
|
SmartcardExtension->SmartcardReply.BufferLength != Length )
|
|
{
|
|
status = STATUS_IO_TIMEOUT;
|
|
}
|
|
|
|
if( SmartcardExtension->CardCapabilities.ATR.Buffer[0] == 0x3F )
|
|
{
|
|
ULONG i;
|
|
for( i = 0; i < SmartcardExtension->SmartcardReply.BufferLength; i++ )
|
|
{
|
|
SmartcardExtension->SmartcardReply.Buffer[i] = InverseCharTable[
|
|
SmartcardExtension->SmartcardReply.Buffer[i] ];
|
|
}
|
|
}
|
|
|
|
|
|
#if 0
|
|
// The data dump here can time-out some cards
|
|
DumpData( "Data from card",
|
|
SmartcardExtension->SmartcardReply.Buffer,
|
|
SmartcardExtension->SmartcardReply.BufferLength );
|
|
|
|
SmartcardDebug(
|
|
DEBUG_PROTOCOL,
|
|
("RNBO3531!ReadFromCard Exit %08X\n", status)
|
|
);
|
|
#endif
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCSerialEvents(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PREADER_EXTENSION ReaderExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called in three cases:
|
|
a) CTS changed (card inserted or removed) or
|
|
b) DSR changed (reader has been removed) or
|
|
c) The serial WaitMask is set to zero
|
|
|
|
For a) we update the card status and complete outstanding
|
|
card tracking requests.
|
|
For b) and c) we start to unload the driver
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
Irp - The notofication Irp
|
|
ReaderExtension - Pointer to our device data
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PSMARTCARD_EXTENSION SmartcardExtension = &ReaderExtension->SmartcardExtension;
|
|
PIO_STACK_LOCATION nextsp;
|
|
NTSTATUS status;
|
|
KIRQL irql;
|
|
|
|
UNREFERENCED_PARAMETER(DeviceObject);
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!SerialEvents: Enter\n")
|
|
);
|
|
|
|
KeAcquireSpinLock( &SmartcardExtension->OsData->SpinLock,
|
|
&irql );
|
|
|
|
if( ReaderExtension->GetModemStatus )
|
|
{
|
|
//
|
|
// This function requested the modem status previously.
|
|
// As part of the io-completion, this function is then
|
|
// called again. When we're here we can read the actual
|
|
// modem-status to figure out if the card is in the reader
|
|
//
|
|
|
|
#ifdef NT5
|
|
if( (ReaderExtension->ModemStatus & SERIAL_DSR_STATE) == 0 )
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!SerialEvent: Reader removed\n")
|
|
);
|
|
|
|
//
|
|
// We set the mask to zero to signal that we can
|
|
// release the irp that we use for the serial events
|
|
//
|
|
ReaderExtension->WaitMask = 0;
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
SCARD_UNKNOWN;
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
if( ReaderExtension->ModemStatus & SERIAL_CTS_STATE )
|
|
{
|
|
//
|
|
// Card is inserted
|
|
//
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
SCARD_SWALLOWED;
|
|
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_UNDEFINED;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!SerialEvents: Smart card inserted\n")
|
|
);
|
|
|
|
} else {
|
|
//
|
|
// Card is removed
|
|
//
|
|
SmartcardExtension->CardCapabilities.ATR.Length = 0;
|
|
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
SCARD_ABSENT;
|
|
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_UNDEFINED;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!SerialEvents: Smart card removed\n")
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
KeReleaseSpinLock( &SmartcardExtension->OsData->SpinLock, irql );
|
|
|
|
if( SmartcardExtension->ReaderExtension->PowerRequest == FALSE )
|
|
{
|
|
// Inform the user of a card insertion/removal event
|
|
RBSCCompleteCardTracking( SmartcardExtension );
|
|
}
|
|
|
|
// The wait mask is set to 0 when the driver unloads
|
|
if( ReaderExtension->WaitMask == 0 )
|
|
{
|
|
#ifdef NT5
|
|
// schedule our remove thread
|
|
IoQueueWorkItem(
|
|
ReaderExtension->CloseSerial,
|
|
(PIO_WORKITEM_ROUTINE) RBSCCloseSerialPort,
|
|
DelayedWorkQueue,
|
|
NULL
|
|
);
|
|
#endif
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!SerialEvent: Exit (Release IRP)\n")
|
|
);
|
|
|
|
ReaderExtension->PowerRequest = FALSE;
|
|
|
|
//
|
|
// We don't need the IRP anymore, so free it and tell the
|
|
// io subsystem not to touch it anymore by returning the value below
|
|
//
|
|
IoFreeIrp(Irp);
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
nextsp = IoGetNextIrpStackLocation( ReaderExtension->SerialStatusIrp );
|
|
|
|
nextsp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
|
|
nextsp->MinorFunction = 0UL;
|
|
|
|
if( ReaderExtension->GetModemStatus )
|
|
{
|
|
nextsp->Parameters.DeviceIoControl.OutputBufferLength =
|
|
sizeof(ReaderExtension->WaitMask);
|
|
nextsp->Parameters.DeviceIoControl.IoControlCode =
|
|
IOCTL_SERIAL_WAIT_ON_MASK;
|
|
|
|
ReaderExtension->SerialStatusIrp->AssociatedIrp.SystemBuffer =
|
|
&ReaderExtension->WaitMask;
|
|
|
|
ReaderExtension->GetModemStatus = FALSE;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!SerialEvents: IOCTL_SERIAL_WAIT_ON_MASK\n")
|
|
);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Setup call for device control to get modem status.
|
|
// The CTS signal tells us if the card is inserted or removed.
|
|
// CTS is high if the card is inserted.
|
|
//
|
|
nextsp->Parameters.DeviceIoControl.OutputBufferLength =
|
|
sizeof(ReaderExtension->ModemStatus);
|
|
nextsp->Parameters.DeviceIoControl.IoControlCode =
|
|
IOCTL_SERIAL_GET_MODEMSTATUS;
|
|
|
|
ReaderExtension->SerialStatusIrp->AssociatedIrp.SystemBuffer =
|
|
&ReaderExtension->ModemStatus;
|
|
|
|
ReaderExtension->GetModemStatus = TRUE;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!SerialEvents: IOCTL_SERIAL_GET_MODEMSTATUS\n")
|
|
);
|
|
}
|
|
|
|
IoSetCompletionRoutine( ReaderExtension->SerialStatusIrp,
|
|
RBSCSerialEvents,
|
|
ReaderExtension,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
status = IoCallDriver( ReaderExtension->AttachedSerialPort,
|
|
ReaderExtension->SerialStatusIrp );
|
|
|
|
ReaderExtension->PowerRequest = FALSE;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!SerialEvents: Exit\n")
|
|
);
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
#ifdef NT5
|
|
NTSTATUS
|
|
RBSCDeviceControl(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This is our IOCTL dispatch function
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
|
|
Return Value:
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension =
|
|
&ReaderExtension->SmartcardExtension;
|
|
|
|
NTSTATUS status;
|
|
KIRQL irql;
|
|
|
|
if( ReaderExtension->WaitMask == 0 )
|
|
{
|
|
//
|
|
// the wait mask is set to 0 whenever the device was either
|
|
// surprise-removed or politely removed
|
|
//
|
|
status = STATUS_DEVICE_REMOVED;
|
|
}
|
|
else
|
|
{
|
|
KeAcquireSpinLock( &ReaderExtension->SpinLock, &irql );
|
|
if( ReaderExtension->IoCount == 0 )
|
|
{
|
|
KeReleaseSpinLock( &ReaderExtension->SpinLock, irql );
|
|
status = KeWaitForSingleObject( &ReaderExtension->ReaderStarted,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
KeAcquireSpinLock( &ReaderExtension->SpinLock, &irql );
|
|
}
|
|
ASSERT( ReaderExtension->IoCount >= 0 );
|
|
ReaderExtension->IoCount++;
|
|
KeReleaseSpinLock( &ReaderExtension->SpinLock, irql );
|
|
|
|
status = SmartcardAcquireRemoveLockWithTag( SmartcardExtension,
|
|
'tcoI' );
|
|
}
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
// the device has been removed. Fail the call
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = STATUS_DEVICE_REMOVED;
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
return STATUS_DEVICE_REMOVED;
|
|
}
|
|
|
|
ASSERT(ReaderExtension->ReaderPowerState == PowerReaderWorking);
|
|
|
|
status = SmartcardDeviceControl( SmartcardExtension, Irp );
|
|
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension,'tcoI' );
|
|
|
|
KeAcquireSpinLock( &ReaderExtension->SpinLock, &irql );
|
|
ReaderExtension->IoCount--;
|
|
ASSERT( ReaderExtension->IoCount >= 0 );
|
|
KeReleaseSpinLock( &ReaderExtension->SpinLock, irql );
|
|
|
|
return status;
|
|
}
|
|
|
|
#else
|
|
|
|
NTSTATUS
|
|
RBSCDeviceControl(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!DeviceControl: Enter (%lx)\n",
|
|
IoGetCurrentIrpStackLocation( Irp )->MinorFunction)
|
|
);
|
|
|
|
return SmartcardDeviceControl(
|
|
&((PREADER_EXTENSION)DeviceObject->DeviceExtension)->SmartcardExtension,
|
|
Irp
|
|
);
|
|
}
|
|
|
|
#endif
|
|
|
|
NTSTATUS
|
|
RBSCReaderPower(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The smart card lib requires to have this function. It is called
|
|
for certain power requests to the card.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = SmartcardExtension->ReaderExtension;
|
|
NTSTATUS status;
|
|
KIRQL oldIrql;
|
|
ULONG step;
|
|
|
|
//PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ReaderPower: Enter (%lx)\n",
|
|
SmartcardExtension->MinorIoControlCode)
|
|
);
|
|
|
|
#define STEP_POWER_DOWN 0
|
|
#define STEP_COLD_RESET (STEP_POWER_DOWN+2)
|
|
#define STEP_WARM_RESET (STEP_COLD_RESET+10)
|
|
|
|
switch( SmartcardExtension->MinorIoControlCode )
|
|
{
|
|
case SCARD_WARM_RESET:
|
|
step = STEP_WARM_RESET;
|
|
break;
|
|
|
|
case SCARD_COLD_RESET:
|
|
step = STEP_COLD_RESET;
|
|
break;
|
|
|
|
case SCARD_POWER_DOWN:
|
|
step = STEP_POWER_DOWN;
|
|
break;
|
|
|
|
default :
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
//
|
|
// Since power down triggers the UpdateSerialStatus function, we have
|
|
// to inform it that we forced the change of the status and not the user
|
|
// (who might have removed and inserted a card)
|
|
//
|
|
ReaderExtension->PowerRequest = TRUE;
|
|
|
|
do
|
|
{
|
|
switch( step++ )
|
|
{
|
|
case STEP_COLD_RESET+0:
|
|
case STEP_POWER_DOWN+0:
|
|
status = RBSCPacketExchange( SmartcardExtension,
|
|
CardPowerDown,
|
|
sizeof(CardPowerDown),
|
|
WAIT_TIME_PWR_OFF,
|
|
TRUE );
|
|
break;
|
|
|
|
case STEP_POWER_DOWN+1:
|
|
if( SmartcardExtension->ReaderCapabilities.CurrentState >
|
|
SCARD_PRESENT )
|
|
{
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
SCARD_PRESENT;
|
|
}
|
|
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_UNDEFINED;
|
|
|
|
ReaderExtension->PowerRequest = FALSE;
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ReaderPower: Exit PowerDown OK\n")
|
|
);
|
|
return STATUS_SUCCESS;
|
|
|
|
case STEP_COLD_RESET+1:
|
|
case STEP_WARM_RESET+0:
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_DTR,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
//RBSCDelay( 15000 );
|
|
break;
|
|
|
|
case STEP_COLD_RESET+2:
|
|
case STEP_WARM_RESET+1:
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_RTS,
|
|
NULL,
|
|
0,
|
|
0 );
|
|
// RBSCDelay( 15000 );
|
|
break;
|
|
|
|
case STEP_WARM_RESET+2:
|
|
case STEP_COLD_RESET+3:
|
|
//
|
|
// Set up ATR timeouts (all in msec)
|
|
//
|
|
ReaderExtension->SerialTimeouts.ReadTotalTimeoutMultiplier = 1;
|
|
ReaderExtension->SerialTimeouts.ReadIntervalTimeout = 2*
|
|
ATR_CHAR_TIMEOUT/1000;
|
|
ReaderExtension->SerialTimeouts.ReadTotalTimeoutConstant = 2*
|
|
ATR_BLOCK_TIMEOUT/1000;
|
|
|
|
status = RBSCSerialIo(
|
|
SmartcardExtension,
|
|
IOCTL_SERIAL_SET_TIMEOUTS,
|
|
(PUCHAR) &ReaderExtension->SerialTimeouts,
|
|
sizeof(SERIAL_TIMEOUTS),
|
|
0
|
|
);
|
|
break;
|
|
|
|
case STEP_WARM_RESET+3:
|
|
case STEP_COLD_RESET+4:
|
|
if( SmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries > 1 )
|
|
{
|
|
// Setup default baudrate
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ReaderPower: Set DataRate=%ld\n",DATARATE_DEFAULT)
|
|
);
|
|
{
|
|
SERIAL_BAUD_RATE BaudRate;
|
|
BaudRate.BaudRate = DATARATE_DEFAULT;
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_SET_BAUD_RATE,
|
|
(PUCHAR) &BaudRate,
|
|
sizeof(SERIAL_BAUD_RATE),
|
|
0 );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case STEP_WARM_RESET+4:
|
|
case STEP_COLD_RESET+5:
|
|
RBSCDelay(15000);
|
|
status = RBSCPacketExchange( SmartcardExtension,
|
|
CardPowerUp,
|
|
sizeof(CardPowerUp),
|
|
0, //WAIT_TIME_PWR_ON,
|
|
FALSE );
|
|
break;
|
|
|
|
case STEP_WARM_RESET+5:
|
|
case STEP_COLD_RESET+6:
|
|
//
|
|
// Now read in part or all of the ATR
|
|
//
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_READ,
|
|
NULL,
|
|
0,
|
|
MAXIMUM_ATR_LENGTH );
|
|
break;
|
|
|
|
case STEP_WARM_RESET+6:
|
|
case STEP_COLD_RESET+7:
|
|
{
|
|
ULONG i;
|
|
if( SmartcardExtension->SmartcardReply.Buffer[0] == 0x03 )
|
|
{
|
|
//
|
|
// Inverse convention (Inv(3F) = 03)
|
|
//
|
|
SmartcardExtension->CardCapabilities.ATR.Buffer[0] = 0x3F;
|
|
SmartcardExtension->CardCapabilities.ATR.Length = 1;
|
|
}
|
|
else
|
|
if( SmartcardExtension->SmartcardReply.Buffer[0] == 0x3B )
|
|
{
|
|
//
|
|
// Direct convention
|
|
//
|
|
SmartcardExtension->CardCapabilities.ATR.Buffer[0] = 0x3B;
|
|
SmartcardExtension->CardCapabilities.ATR.Length = 1;
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_UNRECOGNIZED_MEDIA;
|
|
}
|
|
|
|
for( i = 1; status == STATUS_SUCCESS; i = 0 )
|
|
{
|
|
while( i <
|
|
SmartcardExtension->SmartcardReply.BufferLength &&
|
|
SmartcardExtension->CardCapabilities.ATR.Length <
|
|
MAXIMUM_ATR_LENGTH )
|
|
{
|
|
SmartcardExtension->CardCapabilities.ATR.Buffer[
|
|
SmartcardExtension->CardCapabilities.ATR.Length++ ] =
|
|
(SmartcardExtension->CardCapabilities.ATR.Buffer[0] == 0x3F) ?
|
|
InverseCharTable[
|
|
SmartcardExtension->SmartcardReply.Buffer[i] ] :
|
|
SmartcardExtension->SmartcardReply.Buffer[i];
|
|
i++;
|
|
}
|
|
|
|
//
|
|
// Check if ATR is complete
|
|
//
|
|
status = SmartcardUpdateCardCapabilities(
|
|
SmartcardExtension
|
|
);
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Read remaining bytes of ATR
|
|
//
|
|
status = RBSCSerialIo(
|
|
SmartcardExtension,
|
|
SMARTCARD_READ,
|
|
NULL,
|
|
0,
|
|
MAXIMUM_ATR_LENGTH -
|
|
SmartcardExtension->CardCapabilities.ATR.Length
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
case STEP_WARM_RESET+7:
|
|
case STEP_COLD_RESET+8:
|
|
status = RBSCSetCommParams(
|
|
SmartcardExtension,
|
|
SmartcardExtension->CardCapabilities.PtsData.DataRate
|
|
);
|
|
break;
|
|
|
|
case STEP_WARM_RESET+8:
|
|
case STEP_COLD_RESET+9:
|
|
//RBSCDelay( 15000 );
|
|
//
|
|
// Make sure card is still in the reader.
|
|
//
|
|
if( (ReaderExtension->ModemStatus & SERIAL_CTS_STATE) == 0 )
|
|
{
|
|
status = STATUS_NO_MEDIA;
|
|
break;
|
|
}
|
|
|
|
KeAcquireSpinLock( &SmartcardExtension->OsData->SpinLock,
|
|
&oldIrql );
|
|
|
|
//
|
|
// Copy ATR to user space
|
|
//
|
|
if( SmartcardExtension->IoRequest.ReplyBuffer )
|
|
{
|
|
RtlCopyMemory(
|
|
SmartcardExtension->IoRequest.ReplyBuffer,
|
|
SmartcardExtension->CardCapabilities.ATR.Buffer,
|
|
SmartcardExtension->CardCapabilities.ATR.Length
|
|
);
|
|
|
|
//
|
|
// Tell user length of ATR
|
|
//
|
|
*SmartcardExtension->IoRequest.Information =
|
|
SmartcardExtension->CardCapabilities.ATR.Length;
|
|
}
|
|
|
|
KeReleaseSpinLock( &SmartcardExtension->OsData->SpinLock,
|
|
oldIrql );
|
|
ReaderExtension->PowerRequest = FALSE;
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ReaderPower: Exit Reset OK\n")
|
|
);
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
} while( status == STATUS_SUCCESS );
|
|
|
|
//
|
|
// Reset failed, make sure card is powered OFF
|
|
//
|
|
RBSCPacketExchange( SmartcardExtension,
|
|
CardPowerDown,
|
|
sizeof(CardPowerDown),
|
|
WAIT_TIME_PWR_OFF,
|
|
TRUE );
|
|
|
|
SmartcardExtension->CardCapabilities.ATR.Length = 0;
|
|
status = (ReaderExtension->ModemStatus & SERIAL_CTS_STATE) ?
|
|
STATUS_UNRECOGNIZED_MEDIA :
|
|
STATUS_NO_MEDIA;
|
|
|
|
ReaderExtension->PowerRequest = FALSE;
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ReaderPower: Failed %08x\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCSetProtocol(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The smart card lib requires to have this function. It is called
|
|
to set a particular protocol.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
UCHAR PtsRequest[8];
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!SetProtocol: Enter\n")
|
|
);
|
|
|
|
//
|
|
// 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->ReaderCapabilities.CurrentState ==
|
|
SCARD_SPECIFIC && (
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected &
|
|
SmartcardExtension->MinorIoControlCode) )
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
|
|
} else
|
|
while(TRUE)
|
|
{
|
|
PUCHAR reply = SmartcardExtension->SmartcardReply.Buffer;
|
|
|
|
if( SmartcardExtension->CardCapabilities.Protocol.Supported &
|
|
SmartcardExtension->MinorIoControlCode &
|
|
SCARD_PROTOCOL_T1 )
|
|
{
|
|
PtsRequest[5] = 0x11;
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_T1;
|
|
|
|
} else if(
|
|
SmartcardExtension->CardCapabilities.Protocol.Supported &
|
|
SmartcardExtension->MinorIoControlCode &
|
|
SCARD_PROTOCOL_T0 )
|
|
{
|
|
PtsRequest[5] = 0x10;
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_T0;
|
|
} else {
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
//
|
|
// pts
|
|
//
|
|
PtsRequest[0] = IFDCMD_HEADER1;
|
|
PtsRequest[1] = IFDCMD_HEADER2;
|
|
PtsRequest[2] = IFDCMD_SEND_0xx;
|
|
PtsRequest[3] = 4; // Length
|
|
PtsRequest[4] = 0xff; // PTS
|
|
PtsRequest[6] = // set pts1 which codes Fl and Dl
|
|
(SmartcardExtension->CardCapabilities.PtsData.Fl << 4) |
|
|
SmartcardExtension->CardCapabilities.PtsData.Dl;
|
|
//
|
|
// pck (check character)
|
|
//
|
|
PtsRequest[7] = PtsRequest[4] ^ PtsRequest[5] ^ PtsRequest[6];
|
|
|
|
status = RBSCPacketExchange( SmartcardExtension,
|
|
PtsRequest,
|
|
4,
|
|
0,
|
|
FALSE );
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCWriteToCard( SmartcardExtension, PtsRequest+4, 4 );
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCReadFromCard( SmartcardExtension, 4 );
|
|
}
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS &&
|
|
reply[0] == PtsRequest[4] &&
|
|
((reply[1] ^ PtsRequest[5]) & 0x0f) == 0 )
|
|
{
|
|
//
|
|
// Update the current protocol
|
|
//
|
|
SmartcardExtension->ReaderCapabilities.CurrentState =
|
|
SCARD_SPECIFIC;
|
|
|
|
status = RBSCSetCommParams(
|
|
SmartcardExtension,
|
|
SmartcardExtension->CardCapabilities.PtsData.DataRate
|
|
);
|
|
|
|
} else {
|
|
|
|
if (status == STATUS_IO_TIMEOUT &&
|
|
SmartcardExtension->CardCapabilities.PtsData.Type !=
|
|
PTS_TYPE_DEFAULT)
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!SetProtocol: PTS failed. Trying default parameters...\n")
|
|
);
|
|
//
|
|
// 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;
|
|
|
|
status = RBSCReaderPower( SmartcardExtension );
|
|
if( status == STATUS_SUCCESS )
|
|
continue;
|
|
}
|
|
|
|
status = STATUS_DEVICE_PROTOCOL_ERROR;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
SmartcardExtension->CardCapabilities.Protocol.Selected =
|
|
SCARD_PROTOCOL_UNDEFINED;
|
|
|
|
} else {
|
|
|
|
//
|
|
// 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_TRACE,
|
|
("RNBO3531!SetProtocol: Exit\n")
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCPacketExchange(
|
|
PSMARTCARD_EXTENSION SmartcardExtension,
|
|
PUCHAR Command,
|
|
ULONG Length,
|
|
ULONG WaitTime,
|
|
BOOLEAN IfdResponse
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is used to transmit a command to the reader (not card)
|
|
and return the response (if asked).
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
Command - Points to the IFD command to send
|
|
Length - Length of the command in bytes
|
|
WaitTime - Waiting time expected (in microseconds)
|
|
IfdResponse - When TRUE, IFD response is expected (vs card)
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PUCHAR reply = SmartcardExtension->SmartcardReply.Buffer;
|
|
ULONG SerialRequest = SERIAL_PURGE_RXCLEAR | SERIAL_PURGE_TXCLEAR;
|
|
ULONG ResponseSize;
|
|
NTSTATUS status;
|
|
int TrySend;
|
|
|
|
DumpData( "PacketExchange", Command, Length );
|
|
|
|
for( TrySend = 0; TrySend < 4; TrySend++ )
|
|
{
|
|
//
|
|
// start with clean buffers
|
|
//
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
IOCTL_SERIAL_PURGE,
|
|
(PUCHAR) &SerialRequest,
|
|
sizeof(ULONG),
|
|
0 );
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_WRITE,
|
|
Command,
|
|
Length,
|
|
0 );
|
|
|
|
if( status == STATUS_SUCCESS && WaitTime != 0 )
|
|
RBSCDelay( WaitTime );
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS && IfdResponse )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_READ,
|
|
NULL,
|
|
0,
|
|
IFDRSP_HEADER_SIZE );
|
|
if( status != STATUS_SUCCESS ||
|
|
SmartcardExtension->SmartcardReply.BufferLength !=
|
|
IFDRSP_HEADER_SIZE )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
DumpData( "PacketExchange: Received Header",
|
|
reply,
|
|
IFDRSP_HEADER_SIZE );
|
|
//
|
|
// We should have the marker plus the status/length byte
|
|
//
|
|
if( reply[0] != IFDRSP_MARKER )
|
|
{
|
|
status = STATUS_DEVICE_DATA_ERROR;
|
|
continue;
|
|
}
|
|
|
|
ResponseSize = (ULONG)reply[1];
|
|
|
|
if( ResponseSize > 0 && ResponseSize < IFDRSP_ACK )
|
|
{
|
|
status = RBSCSerialIo( SmartcardExtension,
|
|
SMARTCARD_READ,
|
|
NULL,
|
|
0,
|
|
ResponseSize );
|
|
if( status == STATUS_SUCCESS &&
|
|
SmartcardExtension->SmartcardReply.BufferLength !=
|
|
ResponseSize )
|
|
{
|
|
status = STATUS_DEVICE_DATA_ERROR;
|
|
}
|
|
|
|
DumpData( "PacketExchange: Received Data",
|
|
SmartcardExtension->SmartcardReply.Buffer,
|
|
SmartcardExtension->SmartcardReply.BufferLength );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Map IFD errors
|
|
//
|
|
switch( ResponseSize )
|
|
{
|
|
case IFDRSP_ACK : return STATUS_SUCCESS;
|
|
case IFDRSP_NOCARD : return STATUS_NO_MEDIA;
|
|
case IFDRSP_BADCMD : return STATUS_INVALID_DEVICE_REQUEST;
|
|
case IFDRSP_PARITY :
|
|
default :
|
|
status = STATUS_DEVICE_DATA_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( status == STATUS_SUCCESS)
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SmartcardExtension->SmartcardReply.BufferLength = 0;
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCT0Transmit(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function performs the T=0 transmission.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = SmartcardExtension->ReaderExtension;
|
|
NTSTATUS status;
|
|
PUCHAR RxBuffer = SmartcardExtension->SmartcardReply.Buffer;
|
|
PUCHAR TxBuffer = SmartcardExtension->SmartcardRequest.Buffer;
|
|
ULONG RxLength, TxLength, RequestSize;
|
|
UCHAR SendHeader[4], Ins, ProcByte;
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!T0Transmit: Enter\n")
|
|
);
|
|
|
|
//
|
|
// Tell the lib function how many bytes I need for the prologue
|
|
//
|
|
SmartcardExtension->SmartcardRequest.BufferLength = 0;
|
|
|
|
//
|
|
// Let the lib build a T=0 packet
|
|
//
|
|
status = SmartcardT0Request( SmartcardExtension );
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
return status;
|
|
|
|
TxLength = SmartcardExtension->SmartcardRequest.BufferLength;
|
|
|
|
if( TxLength < 5 || TxLength > 0x1ff )
|
|
{
|
|
return STATUS_DEVICE_DATA_ERROR;
|
|
}
|
|
|
|
//
|
|
// The number of bytes we expect from the card
|
|
// is Le + 2 status bytes
|
|
//
|
|
RxLength = SmartcardExtension->T0.Le + 2;
|
|
|
|
//
|
|
// Write command to the reader
|
|
//
|
|
Ins = TxBuffer[1]; // INS
|
|
|
|
RequestSize = 5;
|
|
|
|
for( ;; )
|
|
{
|
|
if( TxLength > 0 )
|
|
{
|
|
SendHeader[0] = IFDCMD_HEADER1;
|
|
SendHeader[1] = IFDCMD_HEADER2;
|
|
SendHeader[2] = (RequestSize > 256) ?
|
|
IFDCMD_SEND_1xx : IFDCMD_SEND_0xx;
|
|
SendHeader[3] = (UCHAR)RequestSize; // 0=256
|
|
|
|
status = RBSCPacketExchange(
|
|
SmartcardExtension,
|
|
SendHeader,
|
|
4,
|
|
0,
|
|
FALSE
|
|
);
|
|
|
|
if( status != STATUS_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
|
|
status = RBSCWriteToCard(
|
|
SmartcardExtension,
|
|
TxBuffer,
|
|
RequestSize
|
|
);
|
|
|
|
if( status != STATUS_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
|
|
TxLength -= RequestSize;
|
|
TxBuffer += RequestSize;
|
|
}
|
|
|
|
do
|
|
{
|
|
status = RBSCReadFromCard( SmartcardExtension, 1 ); // Proc. byte
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
ProcByte = SmartcardExtension->SmartcardReply.Buffer[0];
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!ProcByte=%02x Ins=%02x\n",ProcByte,Ins)
|
|
);
|
|
|
|
} while( ProcByte == 0x60);
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( ProcByte == Ins || ProcByte == (UCHAR)(Ins+1) )
|
|
{
|
|
//
|
|
// Send all remaining bytes
|
|
//
|
|
if( TxLength > 0 )
|
|
{
|
|
RequestSize = TxLength;
|
|
continue;
|
|
}
|
|
RequestSize = RxLength;
|
|
}
|
|
else if( ProcByte == (UCHAR)~Ins || ProcByte == (UCHAR)~(Ins+1) )
|
|
{
|
|
//
|
|
// Send 1 byte only
|
|
//
|
|
RequestSize = 1;
|
|
if( TxLength > 0 )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Card returned status byte
|
|
//
|
|
SmartcardExtension->SmartcardReply.Buffer++;
|
|
TxLength = 0;
|
|
RxLength = 1; // Second byte of status (SW2)
|
|
RequestSize = 1;
|
|
}
|
|
|
|
status = RBSCReadFromCard( SmartcardExtension, RequestSize );
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
SmartcardExtension->SmartcardReply.Buffer += RequestSize;
|
|
RxLength -= RequestSize;
|
|
|
|
if( RxLength == 0 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Restore reply buffer pointer
|
|
//
|
|
SmartcardExtension->SmartcardReply.BufferLength =
|
|
(ULONG) (SmartcardExtension->SmartcardReply.Buffer - RxBuffer);
|
|
|
|
SmartcardExtension->SmartcardReply.Buffer = RxBuffer;
|
|
|
|
if( status == STATUS_SUCCESS )
|
|
{
|
|
status = SmartcardT0Reply( SmartcardExtension );
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!T0Transmit: Exit (%lx)\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCT1Transmit(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function performs the T=1 transmission.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
UCHAR SendHeader[4];
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!T1Transmit: Enter\n")
|
|
);
|
|
|
|
do
|
|
{
|
|
PUCHAR TxBuffer = SmartcardExtension->SmartcardRequest.Buffer;
|
|
PUCHAR reply = SmartcardExtension->SmartcardReply.Buffer;
|
|
ULONG TxLength;
|
|
|
|
//
|
|
// Tell the lib function how many bytes I need for the prologue
|
|
//
|
|
SmartcardExtension->SmartcardRequest.BufferLength = 0;
|
|
|
|
status = SmartcardT1Request( SmartcardExtension );
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
TxLength = SmartcardExtension->SmartcardRequest.BufferLength;
|
|
//RBSCDelay( SmartcardExtension->CardCapabilities.T1.BGT );
|
|
|
|
//
|
|
// Write the command to the reader
|
|
//
|
|
SendHeader[0] = IFDCMD_HEADER1;
|
|
SendHeader[1] = IFDCMD_HEADER2;
|
|
SendHeader[2] = (UCHAR)(TxLength > 256) ?
|
|
IFDCMD_SEND_1xx : IFDCMD_SEND_0xx;
|
|
SendHeader[3] = (UCHAR)TxLength; // 0=256
|
|
|
|
status = RBSCPacketExchange( SmartcardExtension,
|
|
SendHeader,
|
|
4,
|
|
0,
|
|
FALSE );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
status = RBSCWriteToCard( SmartcardExtension, TxBuffer, TxLength );
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( SmartcardExtension->T1.Wtx > 1 )
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_PROTOCOL,
|
|
("BWT=%ld, WTX=%d\n",
|
|
SmartcardExtension->CardCapabilities.T1.BWT,
|
|
SmartcardExtension->T1.Wtx)
|
|
);
|
|
RBSCDelay(
|
|
SmartcardExtension->CardCapabilities.T1.BWT*
|
|
SmartcardExtension->T1.Wtx );
|
|
}
|
|
|
|
status = RBSCReadFromCard( SmartcardExtension, 3 );
|
|
|
|
if( status == STATUS_IO_TIMEOUT )
|
|
{
|
|
//
|
|
// Since the card did not reply we set the number of
|
|
// bytes received to 0. This will trigger a resend
|
|
// request
|
|
//
|
|
SmartcardDebug(
|
|
DEBUG_PROTOCOL,
|
|
("RNBO3531!T1Transmit: Timeout\n")
|
|
);
|
|
SmartcardExtension->SmartcardReply.BufferLength = 0;
|
|
} else {
|
|
|
|
if( status != STATUS_SUCCESS )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Calculate length of the INF part of the response
|
|
//
|
|
SmartcardExtension->SmartcardReply.BufferLength =
|
|
SmartcardExtension->SmartcardReply.Buffer[2] +
|
|
(SmartcardExtension->CardCapabilities.T1.EDC & 1) + 1;
|
|
|
|
SmartcardExtension->SmartcardReply.Buffer += 3;
|
|
|
|
status = RBSCReadFromCard(
|
|
SmartcardExtension,
|
|
SmartcardExtension->SmartcardReply.BufferLength );
|
|
|
|
SmartcardExtension->SmartcardReply.Buffer -= 3;
|
|
SmartcardExtension->SmartcardReply.BufferLength += 3;
|
|
|
|
if( status != STATUS_SUCCESS && status != STATUS_IO_TIMEOUT )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
status = SmartcardT1Reply( SmartcardExtension );
|
|
|
|
} while( status == STATUS_MORE_PROCESSING_REQUIRED );
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!T1Transmit: Exit (%lx)\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCTransmit(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is called by the smart card library whenever a transmission
|
|
is required.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - Pointer to smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE();
|
|
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!Transmit: GT=%ld, etu=%ld\n",
|
|
SmartcardExtension->CardCapabilities.GT,
|
|
SmartcardExtension->CardCapabilities.etu)
|
|
);
|
|
|
|
switch( SmartcardExtension->CardCapabilities.Protocol.Selected )
|
|
{
|
|
case SCARD_PROTOCOL_T0:
|
|
return RBSCT0Transmit( SmartcardExtension );
|
|
|
|
case SCARD_PROTOCOL_T1:
|
|
return RBSCT1Transmit( SmartcardExtension );
|
|
}
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCCardTracking(
|
|
PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The smart card lib requires to have this function. It is called
|
|
to setup event tracking for card insertion and removal events.
|
|
|
|
Arguments:
|
|
|
|
SmartcardExtension - pointer to the smart card data struct.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
KIRQL ioIrql, keIrql;
|
|
|
|
//
|
|
// Set cancel routine for the notification irp
|
|
//
|
|
KeAcquireSpinLock(
|
|
&SmartcardExtension->OsData->SpinLock,
|
|
&keIrql
|
|
);
|
|
|
|
IoAcquireCancelSpinLock( &ioIrql );
|
|
|
|
if( SmartcardExtension->OsData->NotificationIrp )
|
|
{
|
|
IoSetCancelRoutine( SmartcardExtension->OsData->NotificationIrp,
|
|
RBSCCancel );
|
|
}
|
|
|
|
IoReleaseCancelSpinLock( ioIrql );
|
|
|
|
KeReleaseSpinLock( &SmartcardExtension->OsData->SpinLock,
|
|
keIrql );
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
VOID
|
|
RBSCCompleteCardTracking(
|
|
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!RBSCCardTracking: Completing NotificationIrp %lxh\n",
|
|
DRIVER_NAME,
|
|
notificationIrp)
|
|
);
|
|
|
|
// finish the request
|
|
notificationIrp->IoStatus.Information = 0;
|
|
notificationIrp->IoStatus.Status = notificationIrp->Cancel ?
|
|
STATUS_CANCELLED : STATUS_SUCCESS;
|
|
|
|
IoCompleteRequest(
|
|
notificationIrp,
|
|
IO_NO_INCREMENT
|
|
);
|
|
}
|
|
}
|
|
|
|
#ifdef NT5
|
|
VOID
|
|
RBSCCloseSerialPort(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function closes the connection to the serial driver when the reader
|
|
has been removed (unplugged). This function runs as a system thread at
|
|
IRQL == PASSIVE_LEVEL. It waits for the remove event that is set by
|
|
the IoCompletionRoutine
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
NTSTATUS status;
|
|
PIRP irp;
|
|
PIO_STACK_LOCATION stack;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
//
|
|
// first mark this device as 'gone'.
|
|
// This will prevent that someone can re-open the device
|
|
//
|
|
status = IoSetDeviceInterfaceState( &ReaderExtension->PnPDeviceName,
|
|
FALSE );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
irp = IoAllocateIrp( (CCHAR)(DeviceObject->StackSize + 1), FALSE );
|
|
|
|
ASSERT( irp != NULL );
|
|
|
|
if( irp )
|
|
{
|
|
SmartcardDebug(
|
|
DEBUG_TRACE,
|
|
("RNBO3531!CloseSerialPort: Sending IRP_MJ_CLOSE\n")
|
|
);
|
|
|
|
IoSetNextIrpStackLocation( irp );
|
|
|
|
//
|
|
// We send down a close to the serial driver. This close goes
|
|
// through serenum first which will trigger it to start looking
|
|
// for changes on the com-port. Since our device is gone it will
|
|
// call the device removal event of our PnP dispatch.
|
|
//
|
|
irp->UserIosb = &ioStatusBlock;
|
|
stack = IoGetCurrentIrpStackLocation( irp );
|
|
stack->MajorFunction = IRP_MJ_CLOSE;
|
|
|
|
status = RBSCCallSerialDriver(
|
|
ReaderExtension->AttachedSerialPort,
|
|
irp );
|
|
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
IoFreeIrp( irp );
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_INFO,
|
|
("RNBO3531!CloseSerialPort: Serial Close Done.\n")
|
|
);
|
|
|
|
// inform the remove function that call is complete
|
|
KeSetEvent( &ReaderExtension->SerialCloseDone, 0, FALSE );
|
|
}
|
|
|
|
NTSTATUS
|
|
RBSCDevicePowerCompletion (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PSMARTCARD_EXTENSION SmartcardExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine is called after the underlying stack powered
|
|
UP the serial port, so it can be used again.
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
//
|
|
// We issue a power request in order to figure out
|
|
// what the actual card status is
|
|
//
|
|
SmartcardExtension->MinorIoControlCode = SCARD_COLD_RESET;
|
|
RBSCReaderPower( SmartcardExtension );
|
|
|
|
//
|
|
// If a card was present before power down or now there is
|
|
// a card in the reader, we complete any pending card monitor
|
|
// request, since we do not really know what card is now in the
|
|
// reader.
|
|
//
|
|
if( SmartcardExtension->ReaderExtension->CardPresent ||
|
|
SmartcardExtension->ReaderCapabilities.CurrentState > SCARD_ABSENT )
|
|
{
|
|
RBSCCompleteCardTracking( SmartcardExtension );
|
|
}
|
|
|
|
// save the current power state of the reader
|
|
SmartcardExtension->ReaderExtension->ReaderPowerState =
|
|
PowerReaderWorking;
|
|
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension, 'rwoP' );
|
|
|
|
// inform the power manager of our state.
|
|
PoSetPowerState( DeviceObject,
|
|
DevicePowerState,
|
|
irpStack->Parameters.Power.State );
|
|
|
|
PoStartNextPowerIrp( Irp );
|
|
|
|
// signal that we can process ioctls again
|
|
KeSetEvent(&deviceExtension->ReaderStarted, 0, FALSE);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
RBSCSystemPowerCompletion(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PIRP Irp,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called when the underlying stacks
|
|
completed the power transition.
|
|
|
|
--*/
|
|
{
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
|
|
UNREFERENCED_PARAMETER (MinorFunction);
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = IoStatus->Status;
|
|
|
|
SmartcardReleaseRemoveLockWithTag( &ReaderExtension->SmartcardExtension,
|
|
'rwoP' );
|
|
|
|
if (PowerState.SystemState == PowerSystemWorking)
|
|
{
|
|
PoSetPowerState( DeviceObject,
|
|
SystemPowerState,
|
|
PowerState );
|
|
}
|
|
|
|
PoStartNextPowerIrp( Irp );
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
}
|
|
|
|
typedef enum _ACTION {
|
|
|
|
Undefined = 0,
|
|
SkipRequest,
|
|
WaitForCompletion,
|
|
CompleteRequest,
|
|
MarkPending
|
|
|
|
} ACTION;
|
|
|
|
NTSTATUS
|
|
RBSCPower(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
The power dispatch routine.
|
|
All we care about is the transition from a low D state to D0.
|
|
|
|
Arguments:
|
|
DeviceObject - Pointer to device object
|
|
Irp - pointer to an I/O Request Packet.
|
|
|
|
Return Value:
|
|
NT status code
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
PREADER_EXTENSION ReaderExtension = DeviceObject->DeviceExtension;
|
|
PSMARTCARD_EXTENSION SmartcardExtension =
|
|
&ReaderExtension->SmartcardExtension;
|
|
PDEVICE_OBJECT AttachedSerialPort;
|
|
POWER_STATE powerState;
|
|
ACTION action;
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!3Power: Enter\n")
|
|
);
|
|
|
|
status = SmartcardAcquireRemoveLockWithTag( SmartcardExtension, 'rwoP' );
|
|
ASSERT( status == STATUS_SUCCESS );
|
|
|
|
if( !NT_SUCCESS( status ) )
|
|
{
|
|
PoStartNextPowerIrp( Irp );
|
|
Irp->IoStatus.Status = status;
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
return status;
|
|
}
|
|
|
|
AttachedSerialPort = ReaderExtension->AttachedSerialPort;
|
|
|
|
if (irpStack->Parameters.Power.Type == DevicePowerState &&
|
|
irpStack->MinorFunction == IRP_MN_SET_POWER )
|
|
{
|
|
switch( irpStack->Parameters.Power.State.DeviceState )
|
|
{
|
|
case PowerDeviceD0:
|
|
// Turn on the reader
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Power: PowerDevice D0\n")
|
|
);
|
|
|
|
//
|
|
// First, we send down the request to the bus, in order
|
|
// to power on the port. When the request completes,
|
|
// we turn on the reader
|
|
//
|
|
IoCopyCurrentIrpStackLocationToNext(Irp);
|
|
IoSetCompletionRoutine (
|
|
Irp,
|
|
RBSCDevicePowerCompletion,
|
|
SmartcardExtension,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE
|
|
);
|
|
|
|
action = WaitForCompletion;
|
|
break;
|
|
|
|
case PowerDeviceD3:
|
|
// Turn off the reader
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Power: PowerDevice D3\n")
|
|
);
|
|
|
|
PoSetPowerState (
|
|
DeviceObject,
|
|
DevicePowerState,
|
|
irpStack->Parameters.Power.State
|
|
);
|
|
|
|
// save the current card state
|
|
ReaderExtension->CardPresent =
|
|
SmartcardExtension->ReaderCapabilities.CurrentState > SCARD_ABSENT;
|
|
|
|
if( ReaderExtension->CardPresent )
|
|
{
|
|
SmartcardExtension->MinorIoControlCode = SCARD_POWER_DOWN;
|
|
status = RBSCReaderPower( SmartcardExtension );
|
|
ASSERT(status == STATUS_SUCCESS);
|
|
}
|
|
|
|
//
|
|
// If there is a pending card tracking request, setting
|
|
// this flag will prevent completion of the request
|
|
// when the system will be waked up again.
|
|
//
|
|
ReaderExtension->PowerRequest = TRUE;
|
|
|
|
// save the current power state of the reader
|
|
ReaderExtension->ReaderPowerState = PowerReaderOff;
|
|
|
|
action = SkipRequest;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
action = SkipRequest;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (irpStack->Parameters.Power.Type == SystemPowerState) {
|
|
|
|
//
|
|
// The system wants to change the power state.
|
|
// We need to translate the system power state to
|
|
// a corresponding device power state.
|
|
//
|
|
|
|
POWER_STATE_TYPE powerType = DevicePowerState;
|
|
|
|
ASSERT(ReaderExtension->ReaderPowerState != PowerReaderUnspecified);
|
|
|
|
switch(irpStack->MinorFunction)
|
|
{
|
|
KIRQL irql;
|
|
|
|
case IRP_MN_QUERY_POWER:
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Power: Query Power\n")
|
|
);
|
|
|
|
//
|
|
// By default we succeed and pass down
|
|
//
|
|
|
|
action = SkipRequest;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
switch (irpStack->Parameters.Power.State.SystemState)
|
|
{
|
|
case PowerSystemMaximum:
|
|
case PowerSystemWorking:
|
|
case PowerSystemSleeping1:
|
|
case PowerSystemSleeping2:
|
|
break;
|
|
|
|
case PowerSystemSleeping3:
|
|
case PowerSystemHibernate:
|
|
case PowerSystemShutdown:
|
|
KeAcquireSpinLock(&ReaderExtension->SpinLock, &irql);
|
|
if (ReaderExtension->IoCount == 0)
|
|
{
|
|
// Block any further ioctls
|
|
KeClearEvent(&ReaderExtension->ReaderStarted);
|
|
|
|
} else {
|
|
|
|
// can't go to sleep mode since the reader is busy.
|
|
status = STATUS_DEVICE_BUSY;
|
|
action = CompleteRequest;
|
|
}
|
|
KeReleaseSpinLock(&ReaderExtension->SpinLock, irql);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IRP_MN_SET_POWER:
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Power: PowerSystem S%d\n",
|
|
irpStack->Parameters.Power.State.SystemState - 1)
|
|
);
|
|
|
|
switch (irpStack->Parameters.Power.State.SystemState)
|
|
{
|
|
case PowerSystemMaximum:
|
|
case PowerSystemWorking:
|
|
case PowerSystemSleeping1:
|
|
case PowerSystemSleeping2:
|
|
|
|
if (SmartcardExtension->ReaderExtension->ReaderPowerState ==
|
|
PowerReaderWorking) {
|
|
|
|
// We're already in the right state
|
|
action = CompleteRequest;
|
|
break;
|
|
}
|
|
|
|
powerState.DeviceState = PowerDeviceD0;
|
|
|
|
// wake up the underlying stack...
|
|
action = MarkPending;
|
|
break;
|
|
|
|
case PowerSystemSleeping3:
|
|
case PowerSystemHibernate:
|
|
case PowerSystemShutdown:
|
|
|
|
if (SmartcardExtension->ReaderExtension->ReaderPowerState ==
|
|
PowerReaderOff) {
|
|
|
|
// We're already in the right state
|
|
action = CompleteRequest;
|
|
break;
|
|
}
|
|
|
|
powerState.DeviceState = PowerDeviceD3;
|
|
|
|
// first, inform the power manager of our new state.
|
|
PoSetPowerState (
|
|
DeviceObject,
|
|
SystemPowerState,
|
|
powerState
|
|
);
|
|
action = MarkPending;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
action = CompleteRequest;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch( action )
|
|
{
|
|
case CompleteRequest:
|
|
Irp->IoStatus.Status = status;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension, 'rwoP' );
|
|
PoStartNextPowerIrp( Irp );
|
|
IoCompleteRequest( Irp, IO_NO_INCREMENT );
|
|
break;
|
|
|
|
case MarkPending:
|
|
Irp->IoStatus.Status = STATUS_PENDING;
|
|
IoMarkIrpPending( Irp );
|
|
status = PoRequestPowerIrp (
|
|
DeviceObject,
|
|
IRP_MN_SET_POWER,
|
|
powerState,
|
|
RBSCSystemPowerCompletion,
|
|
Irp,
|
|
NULL
|
|
);
|
|
ASSERT(status == STATUS_PENDING);
|
|
break;
|
|
|
|
case SkipRequest:
|
|
SmartcardReleaseRemoveLockWithTag( SmartcardExtension, 'rwoP' );
|
|
PoStartNextPowerIrp( Irp );
|
|
IoSkipCurrentIrpStackLocation( Irp );
|
|
status = PoCallDriver( AttachedSerialPort, Irp );
|
|
break;
|
|
|
|
case WaitForCompletion:
|
|
status = PoCallDriver( AttachedSerialPort, Irp );
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
SmartcardDebug(
|
|
DEBUG_DRIVER,
|
|
("RNBO3531!Power: Exit %lx\n",status)
|
|
);
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|