Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

2342 lines
91 KiB

#ifdef USBREADER_PROJECT
#ifndef USBDEVICE_PROJECT
#define USBDEVICE_PROJECT
#endif
#endif
#ifdef USBDEVICE_PROJECT
#pragma message("COMPILING USB DEVICE...")
#include "usbdev.h"
// GUID should be defined outside of any block!
#include "guid.h"
#include "thread.h"
#include "usbreader.h" //TO BE REMOVED
VOID onSendDeviceSetPowerComplete(PDEVICE_OBJECT junk, UCHAR fcn, POWER_STATE state, PPOWER_CONTEXT context, PIO_STATUS_BLOCK pstatus)
{// SendDeviceSetPowerComplete
context->status = pstatus->Status;
KeSetEvent(context->powerEvent, EVENT_INCREMENT, FALSE);
}// SendDeviceSetPowerComplete
#pragma PAGEDCODE
CUSBDevice::CUSBDevice()
{
m_Status = STATUS_INSUFFICIENT_RESOURCES;
INCLUDE_PNP_FUNCTIONS_NAMES();
INCLUDE_POWER_FUNCTIONS_NAMES();
m_Type = USB_DEVICE;
m_Flags |= DEVICE_SURPRISE_REMOVAL_OK;
m_MaximumTransferSize = GUR_MAX_TRANSFER_SIZE;
CommandBufferLength = DEFAULT_COMMAND_BUFFER_SIZE;
ResponseBufferLength = DEFAULT_RESPONSE_BUFFER_SIZE;
InterruptBufferLength = DEFAULT_INTERRUPT_BUFFER_SIZE;
// Register handlers processed by this device...
activatePnPHandler(IRP_MN_START_DEVICE);
activatePnPHandler(IRP_MN_QUERY_REMOVE_DEVICE);
activatePnPHandler(IRP_MN_REMOVE_DEVICE);
activatePnPHandler(IRP_MN_SURPRISE_REMOVAL);
activatePnPHandler(IRP_MN_CANCEL_REMOVE_DEVICE);
activatePnPHandler(IRP_MN_QUERY_STOP_DEVICE);
activatePnPHandler(IRP_MN_CANCEL_STOP_DEVICE);
activatePnPHandler(IRP_MN_STOP_DEVICE);
activatePnPHandler(IRP_MN_QUERY_CAPABILITIES);
// Register Power handlers processed by driver...
activatePowerHandler(IRP_MN_SET_POWER);
activatePowerHandler(IRP_MN_QUERY_POWER);
TRACE(" *** New USB device %8.8lX was created ***\n",this);
m_Status = STATUS_SUCCESS;
}
#pragma PAGEDCODE
CUSBDevice::~CUSBDevice()
{
waitForIdle();
TRACE(" USB device %8.8lX was destroyed ***\n",this);
}
// Function redirects all PnP requests
// This is main entry point for the system (after c wrapper).
// It handles locking device for a PnP requests and redirecting
// it to specific PnP handlers.
// In case of IRP_MN_REMOVE_DEVICE it leaves device locked till
// remove message recieved.
#pragma PAGEDCODE
NTSTATUS CUSBDevice::pnpRequest(IN PIRP Irp)
{
NTSTATUS status;
if (!NT_SUCCESS(acquireRemoveLock()))
{
TRACE("Failed to lock USB device...\n");
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
}
PIO_STACK_LOCATION stack = irp->getCurrentStackLocation(Irp);
ASSERT(stack->MajorFunction == IRP_MJ_PNP);
ULONG fcn = stack->MinorFunction;
if (fcn >= arraysize(PnPfcntab))
{ // some function we don't know about
TRACE("Unknown PnP function at USB device...\n");
status = PnP_Default(Irp);
releaseRemoveLock();
return status;
}
#ifdef DEBUG
TRACE("PnP request (%s) \n", PnPfcnname[fcn]);
#endif
// Call real function to handle the request
status = PnPHandler(fcn,Irp);
// If we've got PnP request to remove->
// Keep device locked to prevent futher connections.
// Device will be unlocked and removed by driver later...
if (fcn != IRP_MN_REMOVE_DEVICE) releaseRemoveLock();
if(!NT_SUCCESS(status))
{
if(status != STATUS_NOT_SUPPORTED)
{
TRACE("\n******** PnP handler reported ERROR -> %x\n", status);
}
}
return status;
}
#pragma PAGEDCODE
// Main redirector of all PnP handlers...
NTSTATUS CUSBDevice::PnPHandler(LONG HandlerID,IN PIRP Irp)
{
// If Handler is not registered...
if (HandlerID >= arraysize(PnPfcntab)) return PnP_Default(Irp);
if(!PnPfcntab[HandlerID]) return PnP_Default(Irp);
// Call registered PnP Handler...
switch(HandlerID)
{
case IRP_MN_START_DEVICE: return PnP_HandleStartDevice(Irp);
break;
case IRP_MN_QUERY_REMOVE_DEVICE: return PnP_HandleQueryRemove(Irp);
break;
case IRP_MN_REMOVE_DEVICE: return PnP_HandleRemoveDevice(Irp);
break;
case IRP_MN_CANCEL_REMOVE_DEVICE: return PnP_HandleCancelRemove(Irp);
break;
case IRP_MN_STOP_DEVICE: return PnP_HandleStopDevice(Irp);
break;
case IRP_MN_QUERY_STOP_DEVICE: return PnP_HandleQueryStop(Irp);
break;
case IRP_MN_CANCEL_STOP_DEVICE: return PnP_HandleCancelStop(Irp);
break;
case IRP_MN_QUERY_DEVICE_RELATIONS: return PnP_HandleQueryRelations(Irp);
break;
case IRP_MN_QUERY_INTERFACE: return PnP_HandleQueryInterface(Irp);
break;
case IRP_MN_QUERY_CAPABILITIES: return PnP_HandleQueryCapabilities(Irp);
break;
case IRP_MN_QUERY_RESOURCES: return PnP_HandleQueryResources(Irp);
break;
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
return PnP_HandleQueryResRequirements(Irp);
break;
case IRP_MN_QUERY_DEVICE_TEXT: return PnP_HandleQueryText(Irp);
break;
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
return PnP_HandleFilterResRequirements(Irp);
break;
case 0x0E: return PnP_Default(Irp);
break;
case IRP_MN_READ_CONFIG: return PnP_HandleReadConfig(Irp);
break;
case IRP_MN_WRITE_CONFIG: return PnP_HandleWriteConfig(Irp);
break;
case IRP_MN_EJECT: return PnP_HandleEject(Irp);
break;
case IRP_MN_SET_LOCK: return PnP_HandleSetLock(Irp);
break;
case IRP_MN_QUERY_ID: return PnP_HandleQueryID(Irp);
break;
case IRP_MN_QUERY_PNP_DEVICE_STATE: return PnP_HandleQueryPnPState(Irp);
break;
case IRP_MN_QUERY_BUS_INFORMATION: return PnP_HandleQueryBusInfo(Irp);
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION: return PnP_HandleUsageNotification(Irp);
break;
case IRP_MN_SURPRISE_REMOVAL: return PnP_HandleSurprizeRemoval(Irp);
break;
}
return PnP_Default(Irp);
}
#pragma PAGEDCODE
// Asks object to remove device
// Object itself will be removed at wrapper function
NTSTATUS CUSBDevice::PnP_HandleRemoveDevice(IN PIRP Irp)
{
// Set device removal state
m_RemoveLock.removing = TRUE;
// Do any processing required for *us* to remove the device. This
// would include completing any outstanding requests, etc.
PnP_StopDevice();
// Do not remove actually our device here!
// It will be done automatically by PnP handler at basic class.
// Let lower-level drivers handle this request. Ignore whatever
// result eventuates.
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = PnP_Default(Irp);
// lower-level completed IoStatus already
return status;
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::PnP_HandleStartDevice(IN PIRP Irp)
{
waitForIdleAndBlock();
// First let all lower-level drivers handle this request. In this particular
// sample, the only lower-level driver should be the physical device created
// by the bus driver, but there could theoretically be any number of intervening
// bus filter devices. Those drivers may need to do some setup at this point
// in time before they'll be ready to handle non-PnP IRP's.
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = forwardAndWait(Irp);
if (!NT_SUCCESS(status))
{
TRACE(" ******* BUS DRIVER FAILED START REQUEST! %8.8lX ******",status);
CLogger* logger = kernel->getLogger();
if(logger) logger->logEvent(GRCLASS_BUS_DRIVER_FAILED_REQUEST,getSystemObject());
return completeDeviceRequest(Irp, status, Irp->IoStatus.Information);
}
status = PnP_StartDevice();
setIdle();
return completeDeviceRequest(Irp, status, Irp->IoStatus.Information);
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::PnP_HandleStopDevice(IN PIRP Irp)
{
PnP_StopDevice();
m_Started = FALSE;
// Let lower-level drivers handle this request. Ignore whatever
// result eventuates.
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = PnP_Default(Irp);
return status;
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::PnP_StartDevice()
{ // StartDevice
NTSTATUS status = STATUS_SUCCESS;
if(m_Started)
{
TRACE("##### Current device was already started!\n");
ASSERT(!m_Started);
return STATUS_DEVICE_BUSY;
}
__try
{
// Do all required processing to start USB device.
// It will include getting Device and configuration descriptors
// and selecting specific interface.
// For now our device support only interface.
// So, it will be activated at activateInterface().
m_DeviceDescriptor = getDeviceDescriptor();
if(!m_DeviceDescriptor)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
TRACE("\nDeviceDescriptor %8.8lX\n",m_DeviceDescriptor);
m_Configuration = getConfigurationDescriptor();
if(!m_Configuration)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
TRACE("Configuration %8.8lX\n",m_Configuration);
m_Interface = activateInterface(m_Configuration);
if(!m_Interface)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
TRACE("Selected interface %8.8lX\n\n",m_Interface);
// Allocate Xfer buffers
if(m_CommandPipe)
{
TRACE("Allocating command buffer (length 0x%x)...\n",CommandBufferLength);
m_CommandBuffer = memory->allocate(NonPagedPool, CommandBufferLength);
if(!m_CommandBuffer)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
}
if(m_ResponsePipe)
{
TRACE("Allocating response buffer (length 0x%x)...\n", ResponseBufferLength);
m_ResponseBuffer = memory->allocate(NonPagedPool, ResponseBufferLength);
if(!m_ResponseBuffer)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
}
if(m_InterruptPipe)
{
TRACE("Allocating interrupt buffer (length 0x%x)...\n", InterruptBufferLength);
m_InterruptBuffer = memory->allocate(NonPagedPool, InterruptBufferLength);
if(!m_InterruptBuffer)
{
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
}
}
__finally
{
// Check memory allocations!
if(!NT_SUCCESS(status))
{
if(m_DeviceDescriptor) memory->free(m_DeviceDescriptor);
if(m_Configuration) memory->free(m_Configuration);
if(m_Interface) memory->free(m_Interface);
if(m_CommandBuffer) memory->free(m_CommandBuffer);
if(m_ResponseBuffer) memory->free(m_ResponseBuffer);
if(m_InterruptBuffer) memory->free(m_InterruptBuffer);
m_DeviceDescriptor = NULL;
m_Configuration = NULL;
m_Interface = NULL;
m_CommandBuffer = NULL;
m_ResponseBuffer = NULL;
m_InterruptBuffer = NULL;
}
else
{
// Give chance inhereted devices to initialize...
onDeviceStart();
TRACE("USB device started successfully...\n\n");
// Device has been completely initialized and is ready to run.
m_Started = TRUE;
}
}
return status;
}
#pragma PAGEDCODE
// This function used for both Stop and Remove PnP events
// It will undo everything what was done at StartDevice
VOID CUSBDevice::PnP_StopDevice()
{ // StopDevice
if (!m_Started) return; // device not started, so nothing to do
TRACE("*** Stop USB Device %8.8lX requested... ***\n", this);
onDeviceStop();
// If any pipes are still open, call USBD with URB_FUNCTION_ABORT_PIPE
// This call will also close the pipes; if any user close calls get through,
// they will be noops
abortPipes();
//We basically just tell USB this device is now 'unconfigured'
if(!isSurprizeRemoved()) disactivateInterface();
// Free resources allocated at startup
m_ControlPipe = NULL;
m_InterruptPipe = NULL;
m_ResponsePipe = NULL;
m_CommandPipe = NULL;
if(m_DeviceDescriptor) memory->free(m_DeviceDescriptor);
if(m_Configuration) memory->free(m_Configuration);
if(m_Interface) memory->free(m_Interface);
if(m_CommandBuffer) memory->free(m_CommandBuffer);
if(m_ResponseBuffer) memory->free(m_ResponseBuffer);
if(m_InterruptBuffer) memory->free(m_InterruptBuffer);
TRACE("*** Device resources released ***\n");
setIdle();
m_Started = FALSE;
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::PnP_HandleQueryRemove(IN PIRP Irp)
{
TRACE("******** QUERY REMOVAL ********\n");
// Win98 doesn't check for open handles before allowing a remove to proceed,
// and it may deadlock in IoReleaseRemoveLockAndWait if handles are still
// open.
if (isWin98() && m_DeviceObject->ReferenceCount)
{
TRACE("Failing removal query due to open handles\n");
return completeDeviceRequest(Irp, STATUS_DEVICE_BUSY, 0);
}
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = forwardAndWait(Irp);
return completeDeviceRequest(Irp, Irp->IoStatus.Status,0);
}
NTSTATUS CUSBDevice::PnP_HandleCancelRemove(IN PIRP Irp)
{
NTSTATUS status;
status = forwardAndWait(Irp);
ASSERT(NT_SUCCESS(status));
Irp->IoStatus.Status = STATUS_SUCCESS;
return completeDeviceRequest(Irp, Irp->IoStatus.Status,0);
}
NTSTATUS CUSBDevice::PnP_HandleQueryStop(IN PIRP Irp)
{
TRACE("******** QUERY STOP ********\n");
if(isDeviceLocked())
{
Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
return completeDeviceRequest(Irp, Irp->IoStatus.Status,0);
}
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = forwardAndWait(Irp);
return completeDeviceRequest(Irp, Irp->IoStatus.Status,0);
}
NTSTATUS CUSBDevice::PnP_HandleCancelStop(IN PIRP Irp)
{
TRACE("******** CANCEL STOP ********\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = forwardAndWait(Irp);
return completeDeviceRequest(Irp, Irp->IoStatus.Status,0);
}
NTSTATUS CUSBDevice::PnP_HandleQueryRelations(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryInterface(IN PIRP Irp)
{
return PnP_Default(Irp);
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::PnP_HandleQueryCapabilities(PIRP Irp)
{
if(!Irp) return STATUS_INVALID_PARAMETER;
PIO_STACK_LOCATION stack = irp->getCurrentStackLocation(Irp);
PDEVICE_CAPABILITIES pdc = stack->Parameters.DeviceCapabilities.Capabilities;
// Check to be sure we know how to handle this version of the capabilities structure
if (pdc->Version < 1) return PnP_Default(Irp);
Irp->IoStatus.Status = STATUS_SUCCESS;
NTSTATUS status = forwardAndWait(Irp);
if (NT_SUCCESS(status))
{ // IRP succeeded
stack = irp->getCurrentStackLocation(Irp);
pdc = stack->Parameters.DeviceCapabilities.Capabilities;
if(!pdc) return STATUS_INVALID_PARAMETER;
//if (m_Flags & DEVICE_SURPRISE_REMOVAL_OK)
/*{ // Smartcard readers do not support it!
//if(!isWin98()) pdc->SurpriseRemovalOK = TRUE;
}*/
pdc->SurpriseRemovalOK = FALSE;
m_DeviceCapabilities = *pdc; // save capabilities for whoever needs to see them
TRACE(" Device allows surprize removal - %s\n",(m_DeviceCapabilities.SurpriseRemovalOK?"YES":"NO"));
} // IRP succeeded
return completeDeviceRequest(Irp, status,Irp->IoStatus.Information);
}// HandleQueryCapabilities
NTSTATUS CUSBDevice::PnP_HandleQueryResources(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryResRequirements(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryText(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleFilterResRequirements(IN PIRP Irp)
{
TRACE("Default action for filtering resource requirements...");
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleReadConfig(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleWriteConfig(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleEject(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleSetLock(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryID(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryPnPState(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleQueryBusInfo(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleUsageNotification(IN PIRP Irp)
{
return PnP_Default(Irp);
}
NTSTATUS CUSBDevice::PnP_HandleSurprizeRemoval(IN PIRP Irp)
{
TRACE("******** SURPRIZE REMOVAL ********\n");
return PnP_Default(Irp);
}
// Functions allocate and initialize USB request block.
// It can be used for read/write request on specific Pipe.
// Allocated URB should be free later upon completing of the request.
PURB CUSBDevice::buildBusTransferRequest(CIoPacket* Irp,UCHAR Command)
{
USHORT Size;
ULONG BufferLength;
PURB Urb = NULL;
PVOID pBuffer;
ULONG TransferFlags;
IN USBD_PIPE_HANDLE Pipe = NULL;
ULONG TransferLength;
if(!Irp) return NULL;
if(Command == COMMAND_REQUEST)
{
BufferLength = CommandBufferLength;
pBuffer = m_CommandBuffer;
TransferFlags = USBD_SHORT_TRANSFER_OK;
Pipe = m_CommandPipe;
TransferLength = Irp->getWriteLength();
if(!Pipe || !TransferLength)
{
TRACE("##### Requested Pipe or TransferLength == 0 for the requested command %d ...\n", Command);
return NULL;
}
TRACE("Command transfer requested...\n");
}
else
if(Command == RESPONSE_REQUEST)
{
BufferLength = ResponseBufferLength;
pBuffer = m_ResponseBuffer;
TransferFlags = USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK;
Pipe = m_ResponsePipe;
TransferLength = BufferLength;
if(!Pipe || !TransferLength)
{
TRACE("##### Requested Pipe or TransferLength == 0 for the requested command %d ...\n", Command);
return NULL;
}
TRACE("Response transfer requested with number of expected bytes %x\n",Irp->getReadLength());
}
else
if(Command == INTERRUPT_REQUEST)
{
BufferLength = InterruptBufferLength;
pBuffer = m_InterruptBuffer;
TransferFlags = USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK;
Pipe = m_InterruptPipe;
TransferLength = BufferLength;
if(!Pipe || !TransferLength)
{
TRACE("##### Requested Pipe or TransferLength == 0 for the requested command %d ...\n", Command);
return NULL;
}
TRACE("Interrupt transfer requested...\n");
}
else
{
TRACE("Incorrect command was requested %d", Command);
return NULL;
}
Size = sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER);
Urb = (PURB) memory->allocate(NonPagedPool, Size);
if (Urb)
{
memory->zero(Urb, Size);
memory->zero(pBuffer, BufferLength);
if(Command == COMMAND_REQUEST)
{
memory->copy(pBuffer,Irp->getBuffer(), TransferLength);
((PUCHAR)pBuffer)[TransferLength] = 0x00;
//TRACE("Command ");
//TRACE_BUFFER(pBuffer,TransferLength);
}
UsbBuildInterruptOrBulkTransferRequest(Urb,(USHORT) Size,
Pipe,
pBuffer,
NULL,
TransferLength,
TransferFlags,
NULL);
}
else
{
TRACE("##### ERROR: failed to allocate URB request...\n");
}
return Urb;
}
VOID CUSBDevice::finishBusTransferRequest(CIoPacket* Irp,UCHAR Command)
{
ULONG BufferLength;
PVOID pBuffer;
ULONG_PTR info;
if(!Irp)
{
TRACE(" **** Invalid parameter -> Irp\n");
return;
}
if(!(info = Irp->getInformation()))
{
TRACE(" **** There is no reported information\n");
return;
}
if(Command == COMMAND_REQUEST)
{
BufferLength = CommandBufferLength;
pBuffer = m_CommandBuffer;
TRACE(" Command transfer finished with length %d\n",info);
}
else
if(Command == RESPONSE_REQUEST)
{
ULONG Length = Irp->getReadLength();
BufferLength = (ULONG)(info>ResponseBufferLength?ResponseBufferLength:info);
BufferLength = BufferLength>Length?Length:BufferLength;
pBuffer = m_ResponseBuffer;
TRACE("Bus Driver replied with length %d\n",info);
memory->copy(Irp->getBuffer(),pBuffer, BufferLength);
if(BufferLength!=info)
{
TRACE("##### Response Buffer short! Buffer length %x Reply length %x \n",ResponseBufferLength,info);
}
//TRACE("Response ");
//TRACE_BUFFER(pBuffer,BufferLength);
}
else
if(Command == INTERRUPT_REQUEST)
{
ULONG Length = Irp->getReadLength();
BufferLength = (ULONG)(info>InterruptBufferLength?InterruptBufferLength:info);
BufferLength = BufferLength>Length?Length:BufferLength;
pBuffer = m_InterruptBuffer;
TRACE("Bus Driver replied with length %d\n",info);
memory->copy(Irp->getBuffer(),pBuffer, BufferLength);
if(BufferLength!=info)
{
TRACE("##### Interrupt Buffer short! Buffer length %x Reply length %x \n",InterruptBufferLength,info);
}
TRACE("Interrupt ");
TRACE_BUFFER(pBuffer,BufferLength);
}
else
{
TRACE("Incorrect command was requested %d", Command);
return;
}
}
// This function generates an internal IRP from this driver to the PDO
// to obtain information on the Physical Device Object's capabilities.
// We are most interested in learning which system power states
// are to be mapped to which device power states for honoring IRP_MJ_SET_POWER Irps.
#pragma PAGEDCODE
NTSTATUS CUSBDevice::QueryBusCapabilities(PDEVICE_CAPABILITIES Capabilities)
{
NTSTATUS status;
CIoPacket* IoPacket;
PAGED_CODE();
TRACE("Quering USB bus capabilities...\n");
// Build an IRP for us to generate an internal query request to the PDO
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
return STATUS_INSUFFICIENT_RESOURCES;
}
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_PNP, IRP_MN_QUERY_CAPABILITIES, 0,Capabilities);
status = sendRequestToDeviceAndWait(IoPacket);
DISPOSE_OBJECT(IoPacket);
return status;
}
#pragma PAGEDCODE
// Function gets device descriptor from the USB bus driver
PUSB_DEVICE_DESCRIPTOR CUSBDevice::getDeviceDescriptor()
{
PUSB_DEVICE_DESCRIPTOR Descriptor = NULL;
PURB Urb;
ULONG Size;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
CIoPacket* IoPacket = NULL;
TRACE("Getting USB device descriptor...\n");
__try
{
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
if(!Urb) __leave;
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
Size = sizeof(USB_DEVICE_DESCRIPTOR);
Descriptor = (PUSB_DEVICE_DESCRIPTOR)memory->allocate(NonPagedPool,Size);
if(!Descriptor) __leave;
UsbBuildGetDescriptorRequest(Urb,
(USHORT) sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST),
USB_DEVICE_DESCRIPTOR_TYPE,
0,
0,
Descriptor,
NULL,
Size,
NULL);
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (NT_SUCCESS(Status))
{
TRACE("Device Descriptor = %x, len %x\n",
Descriptor,
Urb->UrbControlDescriptorRequest.TransferBufferLength);
TRACE("\nGemplus USB SmartCard Device Descriptor:\n");
TRACE("-------------------------\n");
TRACE("bLength 0x%x\n", Descriptor->bLength);
TRACE("bDescriptorType 0x%x\n", Descriptor->bDescriptorType);
TRACE("bcdUSB 0x%x\n", Descriptor->bcdUSB);
TRACE("bDeviceClass 0x%x\n", Descriptor->bDeviceClass);
TRACE("bDeviceSubClass 0x%x\n", Descriptor->bDeviceSubClass);
TRACE("bDeviceProtocol 0x%x\n", Descriptor->bDeviceProtocol);
TRACE("bMaxPacketSize0 0x%x\n", Descriptor->bMaxPacketSize0);
TRACE("idVendor 0x%x\n", Descriptor->idVendor);
TRACE("idProduct 0x%x\n", Descriptor->idProduct);
TRACE("bcdDevice 0x%x\n", Descriptor->bcdDevice);
TRACE("iManufacturer 0x%x\n", Descriptor->iManufacturer);
TRACE("iProduct 0x%x\n", Descriptor->iProduct);
TRACE("iSerialNumber 0x%x\n", Descriptor->iSerialNumber);
TRACE("bNumConfigurations 0x%x\n", Descriptor->bNumConfigurations);
TRACE("-------------------------\n");
}
else
{
TRACE("#### ERROR: Failed to get device descriptor...\n");
CLogger* logger = kernel->getLogger();
if(logger) logger->logEvent(GRCLASS_BUS_DRIVER_FAILED_REQUEST,getSystemObject());
}
__leave;;
}
__finally
{
if(Urb) memory->free(Urb);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
if(Descriptor) memory->free(Descriptor);
Descriptor = NULL;
}
else
{
if(Descriptor) TRACE("*** Succeed to get device descriptor ***\n");
}
}
return Descriptor;
}
// Function gets confuguration descriptor
PUSB_CONFIGURATION_DESCRIPTOR CUSBDevice::getConfigurationDescriptor()
{
PUSB_CONFIGURATION_DESCRIPTOR Descriptor = NULL;
PURB Urb;
ULONG Size;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
CIoPacket* IoPacket = NULL;
TRACE("Getting USB configuration descriptor...\n");
__try
{
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
if(!Urb) __leave;
Size = sizeof(USB_CONFIGURATION_DESCRIPTOR);
while(TRUE)
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
Descriptor = (PUSB_CONFIGURATION_DESCRIPTOR)memory->allocate(NonPagedPool,Size);
if(!Descriptor) __leave;
UsbBuildGetDescriptorRequest(Urb,
(USHORT) sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST),
USB_CONFIGURATION_DESCRIPTOR_TYPE,
0,
0,
Descriptor,
NULL,
Size,
NULL);
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (Urb->UrbControlDescriptorRequest.TransferBufferLength>0 &&
Descriptor->wTotalLength > Size)
{
// If bus driver truncated his descriptor-> resend command with
// bus return value
Size = Descriptor->wTotalLength;
TRACE("Descriptor length retrieved - 0x%x! Getting USB device configuration... ***\n",Size);
IoPacket->dispose();
IoPacket = NULL;
memory->free(Descriptor);
Descriptor = NULL;
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else break;
}
if(NT_SUCCESS(Status))
{
TRACE("\nUSB device Configuration Descriptor = %x, len %x\n",Descriptor,
Urb->UrbControlDescriptorRequest.TransferBufferLength);
TRACE("---------\n");
TRACE("bLength 0x%x\n", Descriptor->bLength);
TRACE("bDescriptorType 0x%x\n", Descriptor->bDescriptorType);
TRACE("wTotalLength 0x%x\n", Descriptor->wTotalLength);
TRACE("bNumInterfaces 0x%x\n", Descriptor->bNumInterfaces);
TRACE("bConfigurationValue 0x%x\n", Descriptor->bConfigurationValue);
TRACE("iConfiguration 0x%x\n", Descriptor->iConfiguration);
TRACE("bmAttributes 0x%x\n", Descriptor->bmAttributes);
TRACE("MaxPower 0x%x\n", Descriptor->MaxPower);
TRACE("---------\n");
}
else
{
TRACE("*** Failed to get configuration descriptor ***\n");
CLogger* logger = kernel->getLogger();
if(logger) logger->logEvent(GRCLASS_BUS_DRIVER_FAILED_REQUEST,getSystemObject());
}
__leave;
}
__finally
{
if(Urb) memory->free(Urb);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
if(Descriptor) memory->free(Descriptor);
Descriptor = NULL;
}
else
{
if(Descriptor) TRACE("*** Succeed to get configuration descriptor ***\n");
}
}
return Descriptor;
}
#pragma PAGEDCODE
// Function gets confuguration descriptor
PUSBD_INTERFACE_INFORMATION CUSBDevice::activateInterface(PUSB_CONFIGURATION_DESCRIPTOR Configuration)
{
PURB Urb = NULL;
USHORT Size;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
USHORT j;
PUSBD_INTERFACE_LIST_ENTRY InterfaceList;
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor = NULL;
PUSBD_INTERFACE_INFORMATION Interface = NULL;
PUSBD_INTERFACE_INFORMATION UsbInterface = NULL;
ULONG NumberOfInterfaces;
CIoPacket* IoPacket = NULL;
TRACE("Activating USB device configuration %8.8lX, setting device interface...\n",Configuration);
if(!Configuration) return NULL;
// get this from the config descriptor
NumberOfInterfaces = Configuration->bNumInterfaces;
// We only support one interface!
TRACE("\nNumber of interfaces at the configuration - %d \n",NumberOfInterfaces);
// USBD_ParseConfigurationDescriptorEx searches a given configuration
// descriptor and returns a pointer to an interface that matches the
// given search criteria.
// We only support one interface on this device
if(NumberOfInterfaces==1)
{
InterfaceDescriptor =
USBD_ParseConfigurationDescriptorEx(
Configuration,
Configuration,
0, // intreface number, don't care
-1, // alt setting, don't care
-1, // class, don't care
-1, // subclass, don't care
-1);// protocol, don't care
}
else
{
if(NumberOfInterfaces>1)
{
TRACE("Trying next to get interface descriptor for KEYBOARD READER...\n");
InterfaceDescriptor =
USBD_ParseConfigurationDescriptorEx(
Configuration,
Configuration,
1, // intreface number 1 for keyboard reader
-1, // alt setting, don't care
-1, // class, don't care
-1, // subclass, don't care
-1);// protocol, don't care
}
}
if (!InterfaceDescriptor)
{
TRACE("##### ERROR: Failed to get interface description...\n");
return NULL;
}
InterfaceList = (PUSBD_INTERFACE_LIST_ENTRY)memory->allocate(NonPagedPool,sizeof(USBD_INTERFACE_LIST_ENTRY) * (NumberOfInterfaces+1));
if(!InterfaceList)
{
TRACE("Failed to alloacte memory for the interfacelist...\n");
return NULL;
}
// We support only one interface after current!
InterfaceList->InterfaceDescriptor = InterfaceDescriptor;
InterfaceList++;
InterfaceList->InterfaceDescriptor = NULL;
InterfaceList--;
__try
{
//For now our device support only one interface.
Urb = USBD_CreateConfigurationRequestEx(Configuration, InterfaceList);
if(!Urb) __leave;
Interface = &Urb->UrbSelectConfiguration.Interface;
TRACE("Pipe MaximumTransferSize set to 0x%x\n",m_MaximumTransferSize);
for (ULONG i=0; i< Interface->NumberOfPipes; i++)
{
// perform any pipe initialization here
Interface->Pipes[i].MaximumTransferSize = m_MaximumTransferSize;
Interface->Pipes[i].PipeFlags = 0;
}
TRACE("Building select configuration request...\n");
Size = sizeof(struct _URB_SELECT_CONFIGURATION);
UsbBuildSelectConfigurationRequest(Urb,Size, Configuration);
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to Select configuration, ret 0x%x...\n",Status);
CLogger* logger = kernel->getLogger();
if(logger) logger->logEvent(GRCLASS_BUS_DRIVER_FAILED_REQUEST,getSystemObject());
__leave;
}
// Save the configuration handle for this device
// Well... It is not really nice to initialize it here, but...
m_ConfigurationHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
TRACE("Device Configuration handle 0x%x\n",m_ConfigurationHandle);
UsbInterface = (PUSBD_INTERFACE_INFORMATION)memory->allocate(NonPagedPool,Interface->Length);
if (!UsbInterface)
{
TRACE(("##### ERROR: Failed to allocate memory for the UsbInterface\n"));
__leave;
}
// save a copy of the interface information returned
memory->copy(UsbInterface, Interface, Interface->Length);
TRACE("\nGemplus USB device interface:\n");
// Dump the interface to the debugger
TRACE("---------\n");
TRACE("NumberOfPipes 0x%x\n", UsbInterface->NumberOfPipes);
TRACE("Length 0x%x\n", UsbInterface->Length);
TRACE("Alt Setting 0x%x\n", UsbInterface->AlternateSetting);
TRACE("Interface Number 0x%x\n", UsbInterface->InterfaceNumber);
TRACE("Class, subclass, protocol 0x%x 0x%x 0x%x\n",
UsbInterface->Class,
UsbInterface->SubClass,
UsbInterface->Protocol);
TRACE("---------\n");
// Dump the pipe info
for (j=0; j<Interface->NumberOfPipes; j++)
{
PUSBD_PIPE_INFORMATION pipeInformation;
pipeInformation = &UsbInterface->Pipes[j];
TRACE("\nGemplus USB device pipe[%d] ",j);
if(pipeInformation->PipeType==UsbdPipeTypeBulk)
{
if(pipeInformation->EndpointAddress&0x80)
{
TRACE(("(Bulk Response Pipe):\n"));
m_ResponsePipe = pipeInformation->PipeHandle;
TRACE("m_ResponsePipe 0x%x\n", m_ResponsePipe);
}
else
{
TRACE("(Bulk Command pipe):\n");
m_CommandPipe = pipeInformation->PipeHandle;
TRACE("m_CommandPipe 0x%x\n", m_CommandPipe);
}
}
else
{
if(pipeInformation->PipeType==UsbdPipeTypeInterrupt)
{
if(pipeInformation->EndpointAddress&0x80)
{
TRACE(("(Interrupt Response Pipe):\n"));
m_InterruptPipe = pipeInformation->PipeHandle;
TRACE("m_InterruptPipe 0x%x\n", m_InterruptPipe);
}
else
{
TRACE(("(Unexpected Interrupt OUT pipe):\n"));
TRACE("Unexpected pipe 0x%x\n", pipeInformation);
}
}
else
{
TRACE("Unexpected pipe type 0x%x\n", pipeInformation);
}
}
TRACE("---------\n");
TRACE("PipeType 0x%x\n", pipeInformation->PipeType);
TRACE("EndpointAddress 0x%x\n", pipeInformation->EndpointAddress);
TRACE("MaxPacketSize 0x%x\n", pipeInformation->MaximumPacketSize);
TRACE("Interval 0x%x\n", pipeInformation->Interval);
TRACE("Handle 0x%x\n", pipeInformation->PipeHandle);
TRACE("MaximumTransferSize 0x%x\n", pipeInformation->MaximumTransferSize);
}
TRACE("---------\n");
__leave;
}
__finally
{
if(Urb) memory->free(Urb);
if(InterfaceList) memory->free(InterfaceList);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
if(UsbInterface) memory->free(UsbInterface);
UsbInterface = NULL;
}
else
{
if(UsbInterface) TRACE("*** Succeed to set UsbInterface ***\n");
}
}
return UsbInterface;
}
#pragma PAGEDCODE
// Function gets confuguration descriptor
NTSTATUS CUSBDevice::disactivateInterface()
{
PURB Urb = NULL;
USHORT Size;
NTSTATUS Status = STATUS_SUCCESS;
CIoPacket* IoPacket;
TRACE("Disactivating USB device interface...\n");
Size = sizeof(struct _URB_SELECT_CONFIGURATION);
Urb = (PURB)memory->allocate(NonPagedPool,Size);
if(!Urb)
{
TRACE("##### ERROR: Failed to create disable configuration request...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
//UsbBuildSelectConfigurationRequest(Urb,Size, NULL);
(Urb)->UrbHeader.Function = URB_FUNCTION_SELECT_CONFIGURATION;
(Urb)->UrbHeader.Length = Size;
(Urb)->UrbSelectConfiguration.ConfigurationDescriptor = NULL;
__try
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to disable device interface..., ret %x...\n",Status);
}
__leave;
}
__finally
{
if(Urb) memory->free(Urb);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("*** Failed to disactivateInterface() %8.8lX ***\n",Status);
}
else
{
TRACE("*** Succeed to disactivateInterface() ***\n");
}
}
return Status;
}
#pragma PAGEDCODE
// Function resets specified pipe
NTSTATUS CUSBDevice::resetPipe(IN USBD_PIPE_HANDLE Pipe)
{
PURB Urb = NULL;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
CIoPacket* IoPacket;
TRACE("Resetting USB device pipe %8.8lX...\n",Pipe);
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_PIPE_REQUEST));
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Pipe reset...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
Urb->UrbHeader.Length = sizeof (struct _URB_PIPE_REQUEST);
Urb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE;
Urb->UrbPipeRequest.PipeHandle = Pipe;
__try
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to reset Pipe, ret %x...\n",Status);
}
__leave;
}
__finally
{
if(Urb) memory->free(Urb);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("*** Failed to resetPipe() %8.8lX ***\n",Status);
}
else
{
TRACE("*** Succeed to resetPipe() ***\n");
}
}
return Status;
}
#pragma PAGEDCODE
// Function resets specified pipe
NTSTATUS CUSBDevice::resetDevice()
{
PURB Urb = NULL;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
CIoPacket* IoPacket;
TRACE("Resetting USB device...\n");
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_PIPE_REQUEST));
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Device reset...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
__try
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) __leave;
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_RESET_PORT,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to reset Device, ret %x...\n",Status);
}
__leave;
}
__finally
{
if(Urb) memory->free(Urb);
DISPOSE_OBJECT(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("*** Failed to resetPipe() %8.8lX ***\n",Status);
}
else
{
TRACE("*** Succeed to resetPipe() ***\n");
}
}
return Status;
}
// Called as part of sudden device removal handling.
// Cancels any pending transfers for all open pipes.
// If any pipes are still open, call USBD with URB_FUNCTION_ABORT_PIPE
// Also marks the pipe 'closed' in our saved configuration info.
NTSTATUS CUSBDevice::abortPipes()
{
PURB Urb = NULL;
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
PUSBD_PIPE_INFORMATION Pipe;
CIoPacket* IoPacket;
TRACE("Aborting all USB device pipes...\n");
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_PIPE_REQUEST));
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Pipe reset...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
for (USHORT i=0; i<m_Interface->NumberOfPipes; i++)
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) break;
IoPacket->setTimeout(getCommandTimeout());
Pipe = &m_Interface->Pipes[i]; // PUSBD_PIPE_INFORMATION PipeInfo;
if ( Pipe->PipeFlags )
{ // we set this if open, clear if closed
Urb->UrbHeader.Length = sizeof (struct _URB_PIPE_REQUEST);
Urb->UrbHeader.Function = URB_FUNCTION_ABORT_PIPE;
Urb->UrbPipeRequest.PipeHandle = Pipe->PipeHandle;
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to abort Pipe %d\n",i);
}
Pipe->PipeFlags = FALSE; // mark the pipe 'closed'
}
DISPOSE_OBJECT(IoPacket);
}
if(Urb) memory->free(Urb);
TRACE("**** Interface' pipes closed ****\n");
return STATUS_SUCCESS;;
}
NTSTATUS CUSBDevice::resetAllPipes()
{
PURB Urb = NULL;
NTSTATUS Status;
PUSBD_PIPE_INFORMATION Pipe;
CIoPacket* IoPacket;
TRACE("Resetting all USB device pipes...\n");
Urb = (PURB)memory->allocate(NonPagedPool,sizeof(struct _URB_PIPE_REQUEST));
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Pipe reset...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
for (USHORT i=0; i<m_Interface->NumberOfPipes; i++)
{
IoPacket = new (NonPagedPool) CIoPacket(m_pLowerDeviceObject->StackSize);
if(!ALLOCATED_OK(IoPacket)) break;
IoPacket->setTimeout(getCommandTimeout());
Pipe = &m_Interface->Pipes[i]; // PUSBD_PIPE_INFORMATION PipeInfo;
if ( Pipe->PipeFlags )
{ // we set this if open, clear if closed
Urb->UrbHeader.Length = sizeof (struct _URB_PIPE_REQUEST);
Urb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE;
Urb->UrbPipeRequest.PipeHandle = Pipe->PipeHandle;
IoPacket->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(IoPacket);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Failed to abort Pipe %d\n",i);
}
Pipe->PipeFlags = FALSE; // mark the pipe 'closed'
}
DISPOSE_OBJECT(IoPacket);
}
if(Urb) memory->free(Urb);
TRACE(("**** Interface pipes were resetted ****\n"));
return STATUS_SUCCESS;;
}
// Overwrite base class virtual functions
//Handle IRP_MJ_DEVICE_CONTROL request
NTSTATUS CUSBDevice::deviceControl(IN PIRP Irp)
{
if (!NT_SUCCESS(acquireRemoveLock())) return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
PIO_STACK_LOCATION stack = irp->getCurrentStackLocation(Irp);
ULONG code = stack->Parameters.DeviceIoControl.IoControlCode;
//ULONG outlength = stack->Parameters.DeviceIoControl.OutputBufferLength;
NTSTATUS status = STATUS_SUCCESS;
ULONG info = 0;
TRACE("IRP_MJ_DEVICE_CONTROL\n");
//switch (code)
{ // process control operation
//default:
TRACE("INVALID_DEVICE_REQUEST\n");
status = STATUS_INVALID_DEVICE_REQUEST;
}
releaseRemoveLock();
return completeDeviceRequest(Irp, status, info);
}
NTSTATUS CUSBDevice::read(IN PIRP Irp)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG info = 0;
CIoPacket* IoPacket;
if (!NT_SUCCESS(acquireRemoveLock())) return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
TRACE("---- Read request ----\n");
if(!m_ResponsePipe)
{
TRACE("#### ERROR: Response Pipe is not ready yet!...\n");
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_INVALID_DEVICE_REQUEST, 0);
}
if(!NT_SUCCESS(status = waitForIdleAndBlock()))
{
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
}
if(Response_ErrorNum)
{
NTSTATUS res_status = resetPipe(m_ResponsePipe);
if(NT_SUCCESS(res_status)) Response_ErrorNum = 0;
}
IoPacket = new (NonPagedPool) CIoPacket(Irp);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
setIdle();
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
}
status = readSynchronously(IoPacket,m_ResponsePipe);
TRACE("---- Read completed ----\n");
status = completeDeviceRequest(IoPacket->getIrpHandle(), status, IoPacket->getInformation());
DISPOSE_OBJECT(IoPacket);
setIdle();
releaseRemoveLock();
return status;
}
NTSTATUS CUSBDevice::write(IN PIRP Irp)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG info = 0;
CIoPacket* IoPacket;
if(!Irp) return STATUS_INVALID_PARAMETER;
if (!NT_SUCCESS(acquireRemoveLock())) return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
TRACE("---- Write request ----\n");
if(!m_CommandPipe)
{
TRACE("#### ERROR: Command Pipe is not ready yet!...\n");
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_INVALID_DEVICE_REQUEST, 0);
}
if(!NT_SUCCESS(status = waitForIdleAndBlock()))
{
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
}
if(Command_ErrorNum)
{
NTSTATUS res_status = resetPipe(m_CommandPipe);
if(NT_SUCCESS(res_status)) Command_ErrorNum = 0;
}
IoPacket = new (NonPagedPool) CIoPacket(Irp);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
releaseRemoveLock();
return completeDeviceRequest(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
}
status = writeSynchronously(IoPacket,m_CommandPipe);
releaseRemoveLock();
TRACE("---- Write completed ----\n");
status = completeDeviceRequest(IoPacket->getIrpHandle(), status, IoPacket->getInformation());
DISPOSE_OBJECT(IoPacket);
setIdle();
releaseRemoveLock();
return status;
}
NTSTATUS CUSBDevice::sendRequestToDevice(CIoPacket* IoPacket,PIO_COMPLETION_ROUTINE Routine)
{
if(!IoPacket) return STATUS_INVALID_PARAMETER;
IoPacket->copyStackToNext();
if(Routine) IoPacket->setCompletion(Routine);
else IoPacket->setDefaultCompletionFunction();
return system->callDriver(getLowerDriver(),IoPacket->getIrpHandle());
};
// Send request to low level driver and wait for reply
// Current IRP will not be completed, so we can process it and
// complete later.
// See also description of send() function.
NTSTATUS CUSBDevice::sendRequestToDeviceAndWait(CIoPacket* IoPacket)
{ // Send request to low level and wait for a reply
NTSTATUS status;
TRACE("sendAndWait...\n");
if(!IoPacket) return STATUS_INVALID_PARAMETER;
IoPacket->setStackDefaults();
status = system->callDriver(getLowerDriver(),IoPacket->getIrpHandle());
if(status == STATUS_PENDING)
{
TRACE("Waiting for the bus driver to complete...\n");
ASSERT(system->getCurrentIrql()<=DISPATCH_LEVEL);
status = IoPacket->waitForCompletion();
TRACE("Request completed with status %x\n",status);
}
return status;
};
NTSTATUS CUSBDevice::send(CIoPacket* packet)
{
NTSTATUS status;
if(!packet) return STATUS_INVALID_PARAMETER;
__try
{
if(packet->getMajorIOCtl()==IRP_MJ_READ)
{
if(!m_ResponsePipe)
{
TRACE("#### ERROR: Response Pipe is not ready yet!...\n");
status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
status = readSynchronously(packet,m_ResponsePipe);
}
else
{
if(!m_CommandPipe)
{
TRACE("#### ERROR: Command Pipe is not ready yet!...\n");
status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
status = writeSynchronously(packet,m_CommandPipe);
}
__leave;
}
__finally
{
}
return status;
};
NTSTATUS CUSBDevice::sendAndWait(CIoPacket* packet)
{
NTSTATUS status = STATUS_SUCCESS;
if(!packet) return STATUS_INVALID_PARAMETER;
__try
{
if(packet->getMajorIOCtl()==IRP_MJ_READ)
{
TRACE("---- Packet Read request ----\n");
if(!m_ResponsePipe)
{
TRACE("#### ERROR: Response Pipe is not ready yet!...\n");
status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
status = readSynchronously(packet,m_ResponsePipe);
TRACE("---- Packet Read completed ----\n");
}
else
{
TRACE("---- Packet Write request ----\n");
if(!m_CommandPipe)
{
TRACE("#### ERROR: Command Pipe is not ready yet!...\n");
status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
status = writeSynchronously(packet,m_CommandPipe);
TRACE("---- Packet Write completed ----\n");
if(!NT_SUCCESS(status))
{
TRACE("writeSynchronously reported error %x\n", status);
}
}
__leave;
}
__finally
{
}
return status;
};
NTSTATUS CUSBDevice::readSynchronously(CIoPacket* Irp,IN USBD_PIPE_HANDLE Pipe)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PURB Urb = NULL;
NTSTATUS Status;
if(!Irp) return STATUS_INVALID_PARAMETER;
if(Pipe != m_ResponsePipe && Pipe != m_InterruptPipe)
{
TRACE("##### ERROR: Invalid device Pipe requested!...\n");
return STATUS_INVALID_DEVICE_REQUEST;
}
Urb = buildBusTransferRequest(Irp,RESPONSE_REQUEST);
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Pipe read...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
Irp->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(Irp);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Bus driver reported error 0x%x\n",Status);
Response_ErrorNum++;
Irp->setInformation(0);
}
else
{
Irp->setInformation(Urb->UrbBulkOrInterruptTransfer.TransferBufferLength);
finishBusTransferRequest(Irp,RESPONSE_REQUEST);
}
USBD_STATUS urb_status = URB_STATUS(Urb);
TRACE("URB reports status %8.8lX\n",urb_status);
memory->free(Urb);
return Status;
}
NTSTATUS CUSBDevice::writeSynchronously(CIoPacket* Irp,IN USBD_PIPE_HANDLE Pipe)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PURB Urb = NULL;
NTSTATUS Status;
if(!Irp) return STATUS_INVALID_PARAMETER;
if(Pipe != m_CommandPipe)
{
TRACE("##### ERROR: Invalid device Pipe requested!...\n");
return STATUS_INVALID_DEVICE_REQUEST;
}
Urb = buildBusTransferRequest(Irp,COMMAND_REQUEST);
if (!Urb)
{
TRACE("#### ERROR: Failed to allocate Urb at Pipe read...\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
Irp->buildStack(getSystemObject(),IRP_MJ_INTERNAL_DEVICE_CONTROL, 0, IOCTL_INTERNAL_USB_SUBMIT_URB,Urb);
Status = sendRequestToDeviceAndWait(Irp);
if (!NT_SUCCESS(Status))
{
TRACE("##### ERROR: Bus driver reported error %8.8lX\n",Status);
Command_ErrorNum++;
}
else
{
finishBusTransferRequest(Irp,COMMAND_REQUEST);
}
USBD_STATUS urb_status = URB_STATUS(Urb);
TRACE(" URB reports status %8.8lX\n",urb_status);
Irp->setInformation(0);
memory->free(Urb);
return Status;
}
NTSTATUS CUSBDevice::writeAndWait(PUCHAR pRequest,ULONG RequestLength,PUCHAR pReply,ULONG* pReplyLength)
{
NTSTATUS status;
CIoPacket* IoPacket;
if(!pRequest || !RequestLength || !pReply || !pReplyLength) return STATUS_INVALID_PARAMETER;
if(Response_ErrorNum || Command_ErrorNum)
{
TRACE("======= RESETTING ERROR CONDITIONS! =========\n");
NTSTATUS res_status = resetDevice();
if(NT_SUCCESS(res_status))
{
Command_ErrorNum = 0;
Response_ErrorNum = 0;
}
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET DEVICE! =========\n");
return STATUS_INVALID_DEVICE_STATE;
}
/*
NTSTATUS res_status = resetPipe(m_ResponsePipe);
if(NT_SUCCESS(res_status)) Response_ErrorNum = 0;
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET RESPONSE PIPE! =========\n");
resetDevice();
//return STATUS_INVALID_DEVICE_STATE;
}
res_status = resetPipe(m_CommandPipe);
if(NT_SUCCESS(res_status)) Command_ErrorNum = 0;
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET COMMAND PIPE! =========\n");
//return STATUS_INVALID_DEVICE_STATE;
res_status = resetDevice();
if(NT_SUCCESS(res_status)) Command_ErrorNum = 0;
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET DEVICE! =========\n");
return STATUS_INVALID_DEVICE_STATE;
}
}
*/
}
IoPacket = new (NonPagedPool) CIoPacket(getLowerDriver()->StackSize);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
return STATUS_INSUFFICIENT_RESOURCES;
}
IoPacket->setTimeout(getCommandTimeout());
TRACE("IoPacket with device %x\n",getSystemObject());
IoPacket->buildStack(getSystemObject(),IRP_MJ_WRITE);
IoPacket->setWriteLength(RequestLength);
IoPacket->copyBuffer(pRequest,RequestLength);
TRACE(" USB sendAndWait()...\n");
status = sendAndWait(IoPacket);
TRACE(" USB writeAndWait finished: %x\n",status);
if(!NT_SUCCESS(status))
{
*pReplyLength = 0;
IoPacket->dispose();
return status;
}
// Ignore bus driver reply...
DISPOSE_OBJECT(IoPacket);
TRACE(" **** Current WTR %d\n",get_WTR_Delay());
DELAY(get_WTR_Delay());
IoPacket = new (NonPagedPool) CIoPacket(getLowerDriver()->StackSize);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
return STATUS_INSUFFICIENT_RESOURCES;
}
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_READ);
IoPacket->setReadLength(RequestLength);
IoPacket->copyBuffer(pRequest,RequestLength);
TRACE(" USB sendAndWait()...\n");
status = sendAndWait(IoPacket);
TRACE(" USB sendAndWait finished: %x\n",status);
if(!NT_SUCCESS(status))
{
*pReplyLength = 0;
IoPacket->dispose();
return status;
}
*pReplyLength = (ULONG)IoPacket->getInformation();
IoPacket->getSystemReply(pReply,*pReplyLength);
//TRACE_BUFFER(pReply,*pReplyLength);
DISPOSE_OBJECT(IoPacket);
return status;
};
NTSTATUS CUSBDevice::readAndWait(PUCHAR pRequest,ULONG RequestLength,PUCHAR pReply,ULONG* pReplyLength)
{
CIoPacket* IoPacket;
if(!pRequest || !RequestLength || !pReply || !pReplyLength) return STATUS_INVALID_PARAMETER;
if(Response_ErrorNum || Command_ErrorNum)
{
TRACE("======= RESETTING ERROR CONDITIONS! =========\n");
NTSTATUS res_status = resetDevice();
if(NT_SUCCESS(res_status))
{
Command_ErrorNum = 0;
Response_ErrorNum = 0;
}
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET DEVICE! =========\n");
return STATUS_INVALID_DEVICE_STATE;
}
/*TRACE("======= RESETTING ERROR CONDITIONS AT PIPES! =========\n");
NTSTATUS res_status = resetPipe(m_ResponsePipe);
if(NT_SUCCESS(res_status)) Response_ErrorNum = 0;
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET RESPONSE PIPE! =========\n");
return STATUS_INVALID_DEVICE_STATE;
}
res_status = resetPipe(m_CommandPipe);
if(NT_SUCCESS(res_status)) Command_ErrorNum = 0;
else
{
*pReplyLength = 0;
TRACE("======= FAILED TO RESET COMMAND PIPE! =========\n");
return STATUS_INVALID_DEVICE_STATE;
}
*/
}
IoPacket = new (NonPagedPool) CIoPacket(getLowerDriver()->StackSize);
if(!ALLOCATED_OK(IoPacket))
{
DISPOSE_OBJECT(IoPacket);
return STATUS_INSUFFICIENT_RESOURCES;
}
IoPacket->setTimeout(getCommandTimeout());
IoPacket->buildStack(getSystemObject(),IRP_MJ_READ);
IoPacket->setReadLength(RequestLength);
IoPacket->copyBuffer(pRequest,RequestLength);
TRACE("WDM sendAndWait()...\n");
NTSTATUS status = sendAndWait(IoPacket);
TRACE("WDM sendAndWait finished: %x\n",status);
if(!NT_SUCCESS(status))
{
*pReplyLength = 0;
IoPacket->dispose();
return status;
}
*pReplyLength = (ULONG)IoPacket->getInformation();
IoPacket->getSystemReply(pReply,*pReplyLength);
//TRACE_BUFFER(pReply,*pReplyLength);
DISPOSE_OBJECT(IoPacket);
return status;
};
// Handle IRP_MJ_POWER request
// This routine uses the IRP's minor function code to dispatch a handler
// function (such as HandleSetPower for IRP_MN_SET_POWER). It calls DefaultPowerHandler
// for any function we don't specifically need to handle.
NTSTATUS CUSBDevice::powerRequest(IN PIRP Irp)
{
if(!Irp) return STATUS_INVALID_PARAMETER;
if (!NT_SUCCESS(acquireRemoveLock()))
{
power->startNextPowerIrp(Irp); // must be done while we own the IRP
return completeDeviceRequest(Irp, STATUS_DELETE_PENDING, 0);
}
PIO_STACK_LOCATION stack = irp->getCurrentStackLocation(Irp);
ASSERT(stack->MajorFunction == IRP_MJ_POWER);
ULONG fcn = stack->MinorFunction;
NTSTATUS status;
if (fcn >= arraysize(Powerfcntab))
{ // unknown function
status = power_Default(Irp);
releaseRemoveLock();
return status;
}
#ifdef DEBUG
if (fcn == IRP_MN_SET_POWER || fcn == IRP_MN_QUERY_POWER)
{
ULONG context = stack->Parameters.Power.SystemContext;
POWER_STATE_TYPE type = stack->Parameters.Power.Type;
TRACE("\n(%s)\nSystemContext %X, ", Powerfcnname[fcn], context);
if (type==SystemPowerState)
{
TRACE("SYSTEM POWER STATE = %s\n", Powersysstate[stack->Parameters.Power.State.SystemState]);
}
else
{
TRACE("DEVICE POWER STATE = %s\n", Powerdevstate[stack->Parameters.Power.State.DeviceState]);
}
}
else
TRACE("Request (%s)\n", Powerfcnname[fcn]);
#endif // DEBUG
status = callPowerHandler(fcn,Irp);
releaseRemoveLock();
return status;
}
VOID CUSBDevice::activatePowerHandler(LONG HandlerID)
{
if (HandlerID >= arraysize(Powerfcntab)) return;
Powerfcntab[HandlerID] = TRUE;
}
VOID CUSBDevice::disActivatePowerHandler(LONG HandlerID)
{
if (HandlerID >= arraysize(Powerfcntab)) return;
Powerfcntab[HandlerID] = FALSE;
}
NTSTATUS CUSBDevice::callPowerHandler(LONG HandlerID,IN PIRP Irp)
{
if(!Powerfcntab[HandlerID]) // If Handler is not registered...
return power_Default(Irp);
// Call registered Power Handler...
// This is virtual function...
switch(HandlerID)
{
case IRP_MN_WAIT_WAKE: return power_HandleWaitWake(Irp);
break;
case IRP_MN_POWER_SEQUENCE: return power_HandleSequencePower(Irp);
break;
case IRP_MN_SET_POWER: return power_HandleSetPower(Irp);
break;
case IRP_MN_QUERY_POWER: return power_HandleQueryPower(Irp);
break;
}
return power_Default(Irp);
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::power_HandleSetPower(IN PIRP Irp)
{
PIO_STACK_LOCATION irpStack;
NTSTATUS status = STATUS_SUCCESS;
BOOLEAN fGoingToD0 = FALSE;
POWER_STATE sysPowerState, desiredDevicePowerState;
if(!Irp) return STATUS_INVALID_PARAMETER;
irpStack = irp->getCurrentStackLocation (Irp);
switch (irpStack->Parameters.Power.Type)
{
case SystemPowerState:
// Get input system power state
sysPowerState.SystemState = irpStack->Parameters.Power.State.SystemState;
#ifdef DEBUG
TRACE("Set Power with type SystemPowerState = %s\n",Powersysstate[sysPowerState.SystemState]);
#endif
// If system is in working state always set our device to D0
// regardless of the wait state or system-to-device state power map
if ( sysPowerState.SystemState == PowerSystemWorking)
{
desiredDevicePowerState.DeviceState = PowerDeviceD0;
TRACE("PowerSystemWorking, device will be set to D0, state map is not used\n");
}
else
{
// set to corresponding system state if IRP_MN_WAIT_WAKE pending
if (isEnabledForWakeup())
{ // got a WAIT_WAKE IRP pending?
// Find the device power state equivalent to the given system state.
// We get this info from the DEVICE_CAPABILITIES struct in our device
// extension (initialized in BulkUsb_PnPAddDevice() )
desiredDevicePowerState.DeviceState = m_DeviceCapabilities.DeviceState[sysPowerState.SystemState];
TRACE("IRP_MN_WAIT_WAKE pending, will use state map\n");
}
else
{
// if no wait pending and the system's not in working state, just turn off
desiredDevicePowerState.DeviceState = PowerDeviceD3;
TRACE("Not EnabledForWakeup and the system's not in the working state,\n settting PowerDeviceD3(off)\n");
}
}
// We've determined the desired device state; are we already in this state?
#ifdef DEBUG
TRACE("Set Power, desiredDevicePowerState = %s\n",
Powerdevstate[desiredDevicePowerState.DeviceState]);
#endif
if (desiredDevicePowerState.DeviceState != m_CurrentDevicePowerState)
{
acquireRemoveLock();// Callback will release the lock
// No, request that we be put into this state
// by requesting a new Power Irp from the Pnp manager
registerPowerIrp(Irp);
IoMarkIrpPending(Irp);
status = power->requestPowerIrp(getSystemObject(),
IRP_MN_SET_POWER,
desiredDevicePowerState,
// completion routine will pass the Irp down to the PDO
(PREQUEST_POWER_COMPLETE)onPowerRequestCompletion,
this, NULL);
}
else
{ // Yes, just pass it on to PDO (Physical Device Object)
irp->copyCurrentStackLocationToNext(Irp);
power->startNextPowerIrp(Irp);
status = power->callPowerDriver(getLowerDriver(),Irp);
}
break;
case DevicePowerState:
#ifdef DEBUG
TRACE("Set DevicePowerState %s\n",
Powerdevstate[irpStack->Parameters.Power.State.DeviceState]);
#endif
// For requests to D1, D2, or D3 ( sleep or off states ),
// sets deviceExtension->CurrentDevicePowerState to DeviceState immediately.
// This enables any code checking state to consider us as sleeping or off
// already, as this will imminently become our state.
// For requests to DeviceState D0 ( fully on ), sets fGoingToD0 flag TRUE
// to flag that we must set a completion routine and update
// deviceExtension->CurrentDevicePowerState there.
// In the case of powering up to fully on, we really want to make sure
// the process is completed before updating our CurrentDevicePowerState,
// so no IO will be attempted or accepted before we're really ready.
fGoingToD0 = setDevicePowerState(irpStack->Parameters.Power.State.DeviceState); // returns TRUE for D0
if (fGoingToD0)
{
acquireRemoveLock();// Callback will release the lock
TRACE("Set PowerIrp Completion Routine, fGoingToD0 =%d\n", fGoingToD0);
irp->copyCurrentStackLocationToNext(Irp);
irp->setCompletionRoutine(Irp,
onPowerIrpComplete,
// Always pass FDO to completion routine as its Context;
// This is because the DriverObject passed by the system to the routine
// is the Physical Device Object ( PDO ) not the Functional Device Object ( FDO )
this,
TRUE, // invoke on success
TRUE, // invoke on error
TRUE); // invoke on cancellation of the Irp
// Completion routine will set our state and start next power Irp
}
else
{
// D3 device state
//Device reduces power, so do specific for device processing...
onSystemPowerDown();
// Report our state to power manager
desiredDevicePowerState.DeviceState = PowerDeviceD3;
power->declarePowerState(getSystemObject(),DevicePowerState,desiredDevicePowerState);
irp->copyCurrentStackLocationToNext(Irp);
power->startNextPowerIrp(Irp);
}
status = power->callPowerDriver(getLowerDriver(),Irp);
break;
} /* case irpStack->Parameters.Power.Type */
return status;
}
#pragma PAGEDCODE
VOID CUSBDevice::onSystemPowerDown()
{
return;
}
#pragma PAGEDCODE
VOID CUSBDevice::onSystemPowerUp()
{
return;
}
#pragma PAGEDCODE
BOOLEAN CUSBDevice::setDevicePowerState(IN DEVICE_POWER_STATE DeviceState)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
BOOLEAN fRes = FALSE;
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("SetDevicePowerState() PowerDeviceD3 (OFF)\n");
setCurrentDevicePowerState(DeviceState);
break;
case PowerDeviceD1:
case PowerDeviceD2:
// power states D1,D2 translate to USB suspend
#ifdef DEBUG
TRACE("SetDevicePowerState() %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;
}
/*++
Routine Description:
This is the completion routine set in a call to PoRequestPowerIrp()
that was made in ProcessPowerIrp() in response to receiving
an IRP_MN_SET_POWER of type 'SystemPowerState' when the device was
not in a compatible device power state. In this case, a pointer to
the IRP_MN_SET_POWER Irp is saved into the FDO device extension
(deviceExtension->PowerIrp), and then a call must be
made to PoRequestPowerIrp() to put the device into a proper power state,
and this routine is set as the completion routine.
We decrement our pending io count and pass the saved IRP_MN_SET_POWER Irp
on to the next driver
Arguments:
DeviceObject - Pointer to the device object for the class device.
Note that we must get our own device object from the Context
Context - Driver defined context, in this case our own functional device object ( FDO )
Return Value:
The function value is the final status from the operation.
--*/
#pragma LOCKEDCODE
NTSTATUS onPowerRequestCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
IN PVOID Context,
IN PIO_STATUS_BLOCK IoStatus
)
{
PIRP Irp;
NTSTATUS status;
if(!Context) return STATUS_INVALID_PARAMETER;
CUSBReader* device = (CUSBReader*) Context;
// Get the Irp we saved for later processing
// when we decided to request the Power Irp that this routine
// is the completion routine for.
Irp = device->getPowerIrp();
// We will return the status set by the PDO for the power request we're completing
status = IoStatus->Status;
DBG_PRINT("Enter onPowerRequestCompletion()\n");
// we must pass down to the next driver in the stack
IoCopyCurrentIrpStackLocationToNext(Irp);
// Calling PoStartNextPowerIrp() indicates that the driver is finished
// with the previous power IRP, if any, and is ready to handle the next power IRP.
// It must be called for every power IRP.Although power IRPs are completed only once,
// typically by the lowest-level driver for a device, PoStartNextPowerIrp must be called
// for every stack location. Drivers must call PoStartNextPowerIrp while the current IRP
// stack location points to the current driver. Therefore, this routine must be called
// before IoCompleteRequest, IoSkipCurrentStackLocation, and PoCallDriver.
PoStartNextPowerIrp(Irp);
// PoCallDriver is used to pass any power IRPs to the PDO instead of IoCallDriver.
// When passing a power IRP down to a lower-level driver, the caller should use
// IoSkipCurrentIrpStackLocation or IoCopyCurrentIrpStackLocationToNext to copy the IRP to
// the next stack location, then call PoCallDriver. Use IoCopyCurrentIrpStackLocationToNext
// if processing the IRP requires setting a completion routine, or IoSkipCurrentStackLocation
// if no completion routine is needed.
PoCallDriver(device->getLowerDriver(),Irp);
device->unregisterPowerIrp();
device->releaseRemoveLock();
DBG_PRINT("Exit onPowerRequestCompletion()\n");
return status;
}
/*++
Routine Description:
This routine is called when An IRP_MN_SET_POWER of type 'DevicePowerState'
has been received by BulkUsb_ProcessPowerIrp(), and that routine has determined
1) the request is for full powerup ( to PowerDeviceD0 ), and
2) We are not already in that state
A call is then made to PoRequestPowerIrp() with this routine set as the completion routine.
Arguments:
DeviceObject - Pointer to the device object for the class device.
Irp - Irp completed.
Context - Driver defined context.
Return Value:
The function value is the final status from the operation.
--*/
#pragma LOCKEDCODE
NTSTATUS onPowerIrpComplete(
IN PDEVICE_OBJECT NullDeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION irpStack;
POWER_STATE desiredDevicePowerState;
DBG_PRINT("Enter onPowerIrpComplete()\n");
if(!Context) return STATUS_INVALID_PARAMETER;
CUSBReader* device = (CUSBReader*) Context;
// If the lower driver returned PENDING, mark our stack location as pending also.
if (Irp->PendingReturned) IoMarkIrpPending(Irp);
irpStack = IoGetCurrentIrpStackLocation (Irp);
// We can assert that we're a device powerup-to D0 request,
// because that was the only type of request we set a completion routine
// for in the first place
ASSERT(irpStack->MajorFunction == IRP_MJ_POWER);
ASSERT(irpStack->MinorFunction == IRP_MN_SET_POWER);
ASSERT(irpStack->Parameters.Power.Type==DevicePowerState);
ASSERT(irpStack->Parameters.Power.State.DeviceState==PowerDeviceD0);
// Now that we know we've let the lower drivers do what was needed to power up,
// we can set our device extension flags accordingly
device->setCurrentDevicePowerState(PowerDeviceD0);
// Do device specific stuff...
device->onSystemPowerUp();
Irp->IoStatus.Status = status;
device->releaseRemoveLock();
desiredDevicePowerState.DeviceState = PowerDeviceD0;
PoSetPowerState(device->getSystemObject(),DevicePowerState,desiredDevicePowerState);
PoStartNextPowerIrp(Irp);
DBG_PRINT("Exit onPowerIrpComplete() for the state D0\n");
return status;
}
#pragma PAGEDCODE
NTSTATUS CUSBDevice::power_HandleWaitWake(IN PIRP Irp)
{
return power_Default(Irp);
}
NTSTATUS CUSBDevice::power_HandleSequencePower(IN PIRP Irp)
{
return power_Default(Irp);
}
NTSTATUS CUSBDevice::power_HandleQueryPower(IN PIRP Irp)
{
TRACE("******** QUERY POWER ********\n");
if(isDeviceLocked())
{
TRACE("******** FAILED TO CHANGE POWER (DEVICE BUSY) ********\n");
Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
power->startNextPowerIrp(Irp); // must be done while we own the IRP
return completeDeviceRequest(Irp, STATUS_DEVICE_BUSY, 0);
}
Irp->IoStatus.Status = STATUS_SUCCESS;
return power_Default(Irp);
}
NTSTATUS CUSBDevice::createDeviceObjectByName(PDEVICE_OBJECT* ppFdo)
{
NTSTATUS status;
// Construct device name...
CUString* index = new (PagedPool) CUString(getDeviceNumber(),10);
CUString* base = new (PagedPool) CUString(NT_OBJECT_NAME);
if(!ALLOCATED_OK(index) || !ALLOCATED_OK(base))
{
DISPOSE_OBJECT(index);
DISPOSE_OBJECT(base);
return STATUS_INSUFFICIENT_RESOURCES;
}
USHORT size = (USHORT)(index->getLength() + base->getLength() + sizeof(WCHAR));
// Allocate string with required length
m_DeviceObjectName = new (NonPagedPool) CUString(size);
if(!ALLOCATED_OK(m_DeviceObjectName))
{
DISPOSE_OBJECT(index);
DISPOSE_OBJECT(base);
DISPOSE_OBJECT(m_DeviceObjectName);
return STATUS_INSUFFICIENT_RESOURCES;
}
m_DeviceObjectName->append(&base->m_String);
m_DeviceObjectName->append(&index->m_String);
TRACE("Driver registers DeviceObjectName as %ws\n", m_DeviceObjectName->m_String.Buffer);
delete index;
delete base;
status = system->createDevice(m_DriverObject,sizeof(CWDMDevice*),&m_DeviceObjectName->m_String,
FILE_DEVICE_UNKNOWN,0,FALSE,ppFdo);
if(!NT_SUCCESS(status))
{
TRACE("#### Failed to create physical device! Status %x\n",status);
delete m_DeviceObjectName;
}
return status;
}
#endif // USBDEVICE_PROJECT