729 lines
20 KiB
C++
729 lines
20 KiB
C++
//-------------------------------------------------------------------
|
|
// This is abstract class for generic device
|
|
// Specific devices should use it as a parent device
|
|
// Author: Sergey Ivanov
|
|
// Log:
|
|
// 01.11.99 - implemented
|
|
//-------------------------------------------------------------------
|
|
#ifdef USBREADER_PROJECT
|
|
#pragma message("COMPILING USB READER...")
|
|
|
|
#ifndef __USB_READER__
|
|
#define __USB_READER__
|
|
|
|
#include "generic.h"
|
|
#include "usbreader.h"
|
|
|
|
#include "smartcard.h"
|
|
#include "usbdev.h"
|
|
#include "reader.h"
|
|
|
|
#include "gemcore.h"
|
|
|
|
#pragma PAGEDCODE
|
|
CUSBReader::CUSBReader()
|
|
{
|
|
ULONG DevID;
|
|
|
|
m_Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
m_Type = USBREADER_DEVICE;
|
|
interface = NULL;
|
|
DevID = incrementDeviceNumber();
|
|
TRACE("########### Creating USBReader with index %d\n",DevID);
|
|
// Each reader creates own smartcard object...
|
|
scard_Initialized = FALSE;
|
|
smartCard = new (NonPagedPool) CSmartCard;
|
|
|
|
TRACE("**** Creating pooling thread... ****\n");
|
|
// We can not use default device function because it was already used by
|
|
// our Io thread (unless we extend it?)
|
|
// Lets define new thread function and xfer control to it...
|
|
PoolingThread = new (NonPagedPool) CThread((PCLIENT_THREAD_ROUTINE)PoolingThreadFunction,this,
|
|
getDevicePoolingInterval());
|
|
if(!ALLOCATED_OK(PoolingThread))
|
|
{
|
|
DISPOSE_OBJECT(PoolingThread);
|
|
TRACE("****** FAILED TO CREATE POOLING THREAD!\n");
|
|
}
|
|
else
|
|
{
|
|
// Thread which controls asynchronous driver communications
|
|
IoThread = new (NonPagedPool) CThread((PCLIENT_THREAD_ROUTINE)ThreadFunction,this,0);
|
|
if(!ALLOCATED_OK(IoThread))
|
|
{
|
|
DISPOSE_OBJECT(IoThread);
|
|
TRACE("****** FAILED TO CREATE IO THREAD!\n");
|
|
}
|
|
else
|
|
{
|
|
IoThread->start();
|
|
setDeviceState(WORKING);
|
|
m_Status = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
TRACE("********* USB Reader %8.8lX was created with status %8.8lX...\n",this,m_Status);
|
|
}
|
|
|
|
#pragma PAGEDCODE
|
|
CUSBReader::~CUSBReader()
|
|
{
|
|
TRACE("Destroing USB reader pooling thread...\n");
|
|
|
|
if(PoolingThread) PoolingThread->dispose();
|
|
|
|
|
|
if(smartCard)
|
|
{
|
|
TRACE("Disconnecting from smartcard system...\n");
|
|
smartCard->smartCardDisconnect();
|
|
smartCard->dispose();
|
|
}
|
|
if(interface) interface->dispose();
|
|
|
|
if(IoThread) IoThread->stop();
|
|
cancelAllPendingRequests();
|
|
if(IoThread) IoThread->dispose();
|
|
|
|
remove();
|
|
TRACE("********* USB Reader %8.8lX was destroied...\n",this);
|
|
}
|
|
|
|
//Handle IRP_MJ_DEVICE_READ request
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::open(IN PIRP Irp)
|
|
{
|
|
NTSTATUS status;
|
|
TRACE("\n------- USB READER OPEN DEVICE --------\n");
|
|
if(getDeviceState()!=WORKING)
|
|
{
|
|
TRACE(" READER IS NOT AT WORKING STATE... State %x\n",getDeviceState());
|
|
status = STATUS_DEVICE_NOT_CONNECTED;
|
|
return completeDeviceRequest(Irp,status,0);
|
|
}
|
|
if(IoThread)
|
|
{
|
|
status = makeRequestPending(Irp,m_DeviceObject,OPEN_REQUEST);
|
|
// Tell thread to start processing
|
|
if(NT_SUCCESS(status))
|
|
{
|
|
TRACE("CALL THREAD FUNCTION...\n");
|
|
IoThread->callThreadFunction();
|
|
}
|
|
else return completeDeviceRequest(Irp,status,0);
|
|
}
|
|
else
|
|
{
|
|
// IoThread is not ready... Process synchronously!
|
|
status = thread_open(Irp);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::thread_open(PIRP Irp)
|
|
{
|
|
TRACE("\n------- PROCESSING USB READER OPEN DEVICE --------\n");
|
|
TRACE("DEVICE NUMBER %x\n", this);
|
|
if (!NT_SUCCESS(acquireRemoveLock()))
|
|
{
|
|
TRACE("------- FAILED TO LOCK USB READER --------\n");
|
|
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
}
|
|
|
|
// Check if device is already active and reports
|
|
// device busy...
|
|
if(isOpenned())
|
|
{
|
|
TRACE("------- USB READER ALREADY OPENNED --------\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_DEVICE_BUSY, 0);
|
|
}
|
|
|
|
if(!NT_SUCCESS(synchronizeDevicePowerState()))
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("******* FAILED TO SYNCHRONIZE DEVICE POWER...\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_INVALID_DEVICE_STATE, 0);
|
|
}
|
|
|
|
if(PoolingThread) PoolingThread->start();
|
|
|
|
markAsOpenned();
|
|
|
|
TRACE("\n------- USB READER OPENNED! --------\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_SUCCESS, 0);
|
|
};//Create
|
|
|
|
#pragma PAGEDCODE
|
|
VOID CUSBReader::onDeviceStart()
|
|
{
|
|
TRACE("============= PNP START INITIALIZATION ===============\n");
|
|
if(interface)
|
|
{
|
|
if(!interface->isInitialized())
|
|
{
|
|
interface->initialize();
|
|
}
|
|
}
|
|
|
|
reader_UpdateCardState();
|
|
setNotificationState(SCARD_SWALLOWED);
|
|
TRACE("============= PNP START INITIALIZATION FINISHED ===============\n");
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::close(PIRP Irp)
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("\n------- USB READER CLOSE DEVICE -------\n");
|
|
if(!isOpenned())
|
|
{
|
|
return completeDeviceRequest(Irp, STATUS_SUCCESS, 0);
|
|
}
|
|
// Check lock count to know if some pending calls exist...
|
|
// Finish all pending calls...
|
|
// Stop Card pooling...
|
|
if(PoolingThread) PoolingThread->stop();
|
|
|
|
// Power down card if inserted...
|
|
if(getCardState()== SCARD_SWALLOWED)
|
|
{
|
|
ULONG ResponseBufferLength = 0;
|
|
reader_WaitForIdleAndBlock();
|
|
reader_Power(SCARD_POWER_DOWN,NULL,&ResponseBufferLength, FALSE);
|
|
reader_set_Idle();
|
|
}
|
|
|
|
setNotificationState(getCardState());
|
|
completeCardTracking();
|
|
|
|
markAsClosed();
|
|
return completeDeviceRequest(Irp, STATUS_SUCCESS, 0);
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::deviceControl(IN PIRP Irp)
|
|
{
|
|
NTSTATUS status;
|
|
TRACE("\n----- IRP_MJ_DEVICE_CONTROL ------\n");
|
|
if(getDeviceState()!=WORKING)
|
|
{
|
|
TRACE(" READER IS NOT AT WORKING STATE... State %x\n",getDeviceState());
|
|
status = STATUS_DEVICE_NOT_CONNECTED;
|
|
return completeDeviceRequest(Irp,status,0);
|
|
}
|
|
|
|
status = thread_deviceControl(Irp);
|
|
return status;
|
|
}
|
|
|
|
// Redefine base class system interface function...
|
|
//Handle IRP_MJ_DEVICE_CONTROL request
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::thread_deviceControl(IN PIRP Irp)
|
|
{ // RequestControl
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG info = 0;
|
|
|
|
if (!NT_SUCCESS(acquireRemoveLock()))
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("******* DIOC: FAILED TO AQUIRE REMOVE LOCK...\n");
|
|
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
}
|
|
|
|
TRACE("----- thread_deviceControl() ------\n");
|
|
|
|
if(isSurprizeRemoved())
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("******* DIOC: FAILED! DEVICE WAS SURPRIZE REMOVED...\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
}
|
|
|
|
// This was fix for "device SET_POWER without system SET_POWER"
|
|
// It was seen first on ia64 machine
|
|
// If device was powered off tell system to restore power on this device,
|
|
// wait till device will be at proper state...
|
|
/*if(!NT_SUCCESS(synchronizeDevicePowerState()))
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("******* FAILED TO SYNCHRONIZE DEVICE POWER...\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_INVALID_DEVICE_STATE, 0);
|
|
}
|
|
*/
|
|
|
|
// If we've got request but device was not enable yet -> wait for the device!
|
|
// (One of the reasons to disable device - power state change)
|
|
if(!synchronizeDeviceExecution())
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("******* DIOC: FAILED TO SYNCHRONIZE EXECUTION ...\n");
|
|
releaseRemoveLock();
|
|
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
}
|
|
|
|
// SmartCard system will complete the request,
|
|
// So... We do not need to do it here.
|
|
status = SmartcardDeviceControl(getCardExtention(),Irp);
|
|
TRACE("===== USB reader: SmartcardDeviceControl() returns %8.8lX\n", status);
|
|
releaseRemoveLock();
|
|
|
|
if(!NT_SUCCESS(status))
|
|
{// In case of errors force to update card status...
|
|
if(PoolingThread) PoolingThread->callThreadFunction();
|
|
}
|
|
return status;
|
|
}
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::cleanup(PIRP Irp)
|
|
{
|
|
DEBUG_START();//Force to debug even if thread disable it...
|
|
TRACE("\n----- IRP_MJ_CLEANUP ------\n");
|
|
|
|
if(PoolingThread) PoolingThread->stop();
|
|
cancelAllPendingRequests();
|
|
|
|
|
|
setNotificationState(getCardState());
|
|
completeCardTracking();
|
|
|
|
reader_set_Idle();
|
|
TRACE("----- IRP_MJ_CLEANUP FINISHED... ------\n");
|
|
return completeDeviceRequest(Irp, STATUS_SUCCESS, 0);
|
|
}
|
|
|
|
|
|
#pragma LOCKEDCODE
|
|
// This is callback function for the attached threads
|
|
VOID CUSBReader::PoolingThreadFunction(CUSBReader* device)
|
|
{
|
|
if(device) device->PoolingThreadRoutine();
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::PoolingThreadRoutine()
|
|
{
|
|
NTSTATUS status;
|
|
ULONG State;
|
|
LONG TimeOut;
|
|
if(!NT_SUCCESS(status = reader_WaitForIdle())) return status;
|
|
reader_set_busy();
|
|
|
|
TimeOut = getCommandTimeout();
|
|
setCommandTimeout(10000);//Change get status command timeout!
|
|
|
|
DEBUG_STOP();
|
|
State = reader_UpdateCardState();
|
|
TRACE("======>> Card state %x\n",CardState);
|
|
DEBUG_START();
|
|
|
|
setCommandTimeout(TimeOut);
|
|
|
|
reader_set_Idle();
|
|
return STATUS_SUCCESS;
|
|
};
|
|
|
|
#pragma LOCKEDCODE
|
|
VOID CUSBReader::reader_set_busy()
|
|
{
|
|
setBusy();
|
|
};
|
|
|
|
#pragma LOCKEDCODE
|
|
VOID CUSBReader::reader_set_Idle()
|
|
{
|
|
setIdle();
|
|
};
|
|
|
|
#pragma LOCKEDCODE
|
|
NTSTATUS CUSBReader::reader_WaitForIdle()
|
|
{
|
|
return waitForIdle();
|
|
};
|
|
|
|
#pragma LOCKEDCODE
|
|
NTSTATUS CUSBReader::reader_WaitForIdleAndBlock()
|
|
{
|
|
return waitForIdleAndBlock();
|
|
};
|
|
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
// Overwrite device functions...
|
|
NTSTATUS CUSBReader::read(IN PIRP Irp)
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG info = 0;
|
|
TRACE("USB reader: IRP_MJ_DEVICE_READ\n");
|
|
if (!NT_SUCCESS(acquireRemoveLock())) return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
|
|
status = reader_Read(Irp);
|
|
releaseRemoveLock();
|
|
status = completeDeviceRequest(Irp, status, info);
|
|
return status;
|
|
}
|
|
NTSTATUS CUSBReader::write(IN PIRP Irp)
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG info = 0;
|
|
TRACE("USB reader: IRP_MJ_DEVICE_WRITE\n");
|
|
if (!NT_SUCCESS(acquireRemoveLock())) return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
|
|
status = reader_Write(Irp);
|
|
releaseRemoveLock();
|
|
status = completeDeviceRequest(Irp, status, info);
|
|
return status;
|
|
}
|
|
*/
|
|
#endif
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
BOOL CUSBReader::createInterface(LONG interfaceType, LONG protocolType,CUSBReader* device)
|
|
{
|
|
interface = kernel->createReaderInterface(interfaceType,protocolType,device);
|
|
if(interface) return TRUE;
|
|
else return FALSE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
VOID CUSBReader::initializeSmartCardSystem()
|
|
{
|
|
if(smartCard)
|
|
{
|
|
CardState = SCARD_UNKNOWN;
|
|
StateToNotify = SCARD_UNKNOWN;
|
|
smartCard->smartCardConnect(this);
|
|
}
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
VOID CUSBReader::onSystemPowerDown()
|
|
{
|
|
// Stop pooling thread
|
|
TRACE("Stop polling thread going to PowerDeviceD3 (OFF)\n");
|
|
disableDevice();
|
|
|
|
if(PoolingThread) {if(PoolingThread->isThreadActive()) setThreadRestart();};
|
|
if(PoolingThread) PoolingThread->stop();
|
|
return;
|
|
}
|
|
|
|
#pragma PAGEDCODE
|
|
VOID CUSBReader::onSystemPowerUp()
|
|
{
|
|
// Stop pooling thread
|
|
TRACE("Restore reader state going to PowerDeviceD0 (ON)\n");
|
|
if(interface)
|
|
{
|
|
if(interface->isInitialized())
|
|
{
|
|
// Restore reader mode after power down
|
|
NTSTATUS status = interface->setReaderMode(READER_MODE_NATIVE);
|
|
if(!NT_SUCCESS(status))
|
|
{
|
|
TRACE("Failed to set Gemcore reader mode %x\n",READER_MODE_NATIVE);
|
|
}
|
|
}
|
|
}
|
|
if(getCardState() >= SCARD_SWALLOWED) setCardState(SCARD_ABSENT);
|
|
completeCardTracking();
|
|
|
|
if(isRequiredThreadRestart())
|
|
{
|
|
TRACE("Starting pooling thread going to PowerDeviceD0 (ON)\n");
|
|
if(PoolingThread) PoolingThread->start();
|
|
}
|
|
|
|
enableDevice();
|
|
return;
|
|
}
|
|
|
|
#pragma PAGEDCODE
|
|
BOOLEAN CUSBReader::setDevicePowerState(IN DEVICE_POWER_STATE DeviceState)
|
|
{
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
BOOLEAN fRes = FALSE;
|
|
|
|
DEBUG_START();
|
|
switch (DeviceState)
|
|
{
|
|
case PowerDeviceD3:
|
|
// Device will be going OFF,
|
|
// TODO: add any needed device-dependent code to save state here.
|
|
// ( We have nothing to do in this sample )
|
|
TRACE("Set Device Power State to PowerDeviceD3 (OFF)\n");
|
|
setCurrentDevicePowerState(DeviceState);
|
|
break;
|
|
case PowerDeviceD1:
|
|
case PowerDeviceD2:
|
|
// power states D1,D2 translate to USB suspend
|
|
#ifdef DEBUG
|
|
TRACE("Set Device Power State to %s\n",Powerdevstate[DeviceState]);
|
|
#endif
|
|
setCurrentDevicePowerState(DeviceState);
|
|
break;
|
|
case PowerDeviceD0:
|
|
TRACE("Set Device Power State to PowerDeviceD0(ON)\n");
|
|
// We'll need to finish the rest in the completion routine;
|
|
// signal caller we're going to D0 and will need to set a completion routine
|
|
fRes = TRUE;
|
|
// Caller will pass on to PDO ( Physical Device object )
|
|
break;
|
|
default:
|
|
TRACE(" Bogus DeviceState = %x\n", DeviceState);
|
|
}
|
|
return fRes;
|
|
}
|
|
|
|
#pragma PAGEDCODE
|
|
ULONG CUSBReader::reader_UpdateCardState()
|
|
{
|
|
if(interface)
|
|
{
|
|
CardState = interface->getReaderState();
|
|
completeCardTracking();
|
|
}
|
|
else CardState = 0;
|
|
return CardState;
|
|
};
|
|
|
|
#pragma LOCKEDCODE
|
|
VOID CUSBReader::completeCardTracking()
|
|
{
|
|
if(smartCard)
|
|
{
|
|
smartCard->completeCardTracking();
|
|
}
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_getVersion(PUCHAR pVersion, PULONG pLength)
|
|
{
|
|
if(interface) return interface->getReaderVersion(pVersion,pLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_setMode(ULONG mode)
|
|
{
|
|
if(interface) return interface->setReaderMode(mode);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#ifdef DEBUG
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Read(IN PIRP Irp)
|
|
{
|
|
CIoPacket* request = new (NonPagedPool) CIoPacket(Irp);
|
|
if(!ALLOCATED_OK(request) || !ALLOCATED_OK(interface))
|
|
{
|
|
DISPOSE_OBJECT(request);
|
|
return completeDeviceRequest(Irp,STATUS_INSUFFICIENT_RESOURCES,0);
|
|
}
|
|
|
|
NTSTATUS status = interface->read(request);
|
|
DISPOSE_OBJECT(request);
|
|
return status;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Write(IN PIRP Irp)
|
|
{
|
|
CIoPacket* request = new (NonPagedPool) CIoPacket(Irp);
|
|
if(!ALLOCATED_OK(request) || !ALLOCATED_OK(interface))
|
|
{
|
|
DISPOSE_OBJECT(request);
|
|
return completeDeviceRequest(Irp,STATUS_INSUFFICIENT_RESOURCES,0);
|
|
}
|
|
|
|
NTSTATUS status = interface->write(request);
|
|
DISPOSE_OBJECT(request);
|
|
return status;
|
|
};
|
|
#endif
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Read(BYTE * pRequest,ULONG RequestLength,BYTE * pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->readAndWait(pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Write(BYTE* pRequest,ULONG RequestLength,BYTE * pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->writeAndWait(pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Ioctl(ULONG ControlCode,BYTE* pRequest,ULONG RequestLength,BYTE* pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->ioctl(ControlCode,pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_SwitchSpeed(ULONG ControlCode,BYTE* pRequest,ULONG RequestLength,BYTE* pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->SwitchSpeed(ControlCode,pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_VendorAttribute(ULONG ControlCode,BYTE* pRequest,ULONG RequestLength,BYTE* pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->VendorAttribute(ControlCode,pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_Power(ULONG ControlCode,BYTE* pReply,ULONG* pReplyLength, BOOLEAN Specific)
|
|
{
|
|
if(interface) return interface->power(ControlCode,pReply,pReplyLength, Specific);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_SetProtocol(ULONG ProtocolRequested, UCHAR ProtocolNegociation)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if(interface)
|
|
{
|
|
ReaderConfig config = interface->getConfiguration();
|
|
// Update all required configuration fields to set specific protocol
|
|
|
|
switch(ProtocolNegociation)
|
|
{
|
|
case PROTOCOL_MODE_DEFAULT:
|
|
config.PTSMode = PTS_MODE_DISABLED;
|
|
break;
|
|
case PROTOCOL_MODE_MANUALLY:
|
|
default:
|
|
config.PTSMode = PTS_MODE_MANUALLY;
|
|
break;
|
|
}
|
|
|
|
config.PTS1 = smartCardExtention.CardCapabilities.PtsData.Fl << 4 |
|
|
smartCardExtention.CardCapabilities.PtsData.Dl;
|
|
|
|
interface->setConfiguration(config);
|
|
|
|
status = interface->setProtocol(ProtocolRequested);
|
|
return status;
|
|
}
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::setTransparentConfig(PSCARD_CARD_CAPABILITIES cardCapabilities, BYTE NewWtx)
|
|
{
|
|
if(interface) return interface->setTransparentConfig(cardCapabilities,NewWtx);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_translate_request(BYTE * pRequest,ULONG RequestLength,BYTE * pReply,ULONG* pReplyLength, PSCARD_CARD_CAPABILITIES cardCapabilities, BYTE NewWtx)
|
|
{
|
|
if(interface) return interface->translate_request(pRequest,RequestLength,pReply,pReplyLength, cardCapabilities, NewWtx);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::reader_translate_response(BYTE * pRequest,ULONG RequestLength,BYTE * pReply,ULONG* pReplyLength)
|
|
{
|
|
if(interface) return interface->translate_response(pRequest,RequestLength,pReply,pReplyLength);
|
|
else return STATUS_INVALID_DEVICE_STATE;
|
|
};
|
|
|
|
#pragma PAGEDCODE
|
|
NTSTATUS CUSBReader::PnP_HandleSurprizeRemoval(IN PIRP Irp)
|
|
{ // It is PnP internal function.
|
|
// So, device will be locked at PnP entry and
|
|
// we do not need to do it here.
|
|
TRACE("******** USB READER SURPRIZE REMOVAL ********\n");
|
|
|
|
// Just stop thread and remove all pending IOs
|
|
if(PoolingThread) PoolingThread->stop();
|
|
|
|
setSurprizeRemoved();
|
|
cancelAllPendingRequests();
|
|
|
|
return PnP_Default(Irp);
|
|
};
|
|
|
|
|
|
VOID CUSBReader::onDeviceStop()
|
|
{
|
|
TRACE("******** ON USB READER STOP ********\n");
|
|
// Just stop thread and remove all pending IOs
|
|
if(PoolingThread) PoolingThread->stop();
|
|
//if(IoThread) IoThread->stop();
|
|
return;
|
|
};
|
|
|
|
// Reader startIoRequest function
|
|
// It will dispatch all pending Io requests
|
|
NTSTATUS CUSBReader::startIoRequest(CPendingIRP* IrpReq)
|
|
{
|
|
NTSTATUS status;
|
|
TRACE(" CUSBReader::::startIoRequest() was called...\n");
|
|
// Our child's functions run under protection of child BUSY/IDLE breaks.
|
|
// So, we do not need to check idle state here...
|
|
if(getDeviceState()!=WORKING)
|
|
{
|
|
TRACE(" READER IS NOT AT WORKING STATE... State %x\n",getDeviceState());
|
|
TRACE(" <<<<<< READER IO REQUEST FINISHED WITH STATUS %8.8lX>>>>>>\n",STATUS_DEVICE_NOT_CONNECTED);
|
|
NTSTATUS status = completeDeviceRequest(IrpReq->Irp, STATUS_DEVICE_NOT_CONNECTED, 0);
|
|
IrpReq->dispose();
|
|
return status;
|
|
}
|
|
|
|
// Our reader will support asynchronous communications only for these functions...
|
|
switch(IrpReq->Type)
|
|
{
|
|
case OPEN_REQUEST:
|
|
TRACE("OPEN_REQUEST RECIEVED FROM THREAD...\n");
|
|
status = thread_open(IrpReq->Irp);
|
|
break;
|
|
case IOCTL_REQUEST:
|
|
TRACE("IOCTL_REQUEST RECIEVED FROM THREAD...\n");
|
|
status = thread_deviceControl(IrpReq->Irp);
|
|
break;
|
|
default:
|
|
status = STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
IrpReq->dispose();
|
|
TRACE(" <<<<<< READER IO REQUEST FINISHED WITH STATUS %8.8lX>>>>>>\n",status);
|
|
return status;
|
|
};
|
|
|
|
NTSTATUS CUSBReader::ThreadRoutine()
|
|
{
|
|
// If somebody inserted pending request - dispatch it...
|
|
// It will call specific child device startIoRequest().
|
|
// It is up to that device how to handle it.
|
|
// If child device is busy - it can insert this request into
|
|
// child device request queue again and process it later...
|
|
startNextPendingRequest();
|
|
return STATUS_SUCCESS;
|
|
};
|
|
|
|
#endif
|
|
#endif //USBREADER_PROJECT
|