|
|
#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
|
