www.pudn.com > pnpi8042.rar > pnp.c
/*++
Copyright (c) 1997-1998 Microsoft Corporation, All Rights Reserved
Module Name:
pnp.c
Abstract:
This module contains general PnP and Power code for the i8042prt Driver.
Environment:
Kernel mode.
Revision History:
--*/
#include "i8042prt.h"
#include "i8042log.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, I8xAddDevice)
#pragma alloc_text(PAGE, I8xFilterResourceRequirements)
#pragma alloc_text(PAGE, I8xFindPortCallout)
#pragma alloc_text(PAGE, I8xManuallyRemoveDevice)
#pragma alloc_text(PAGE, I8xPnP)
#pragma alloc_text(PAGE, I8xPower)
#pragma alloc_text(PAGE, I8xRegisterDeviceInterface)
#pragma alloc_text(PAGE, I8xRemovePort)
#pragma alloc_text(PAGE, I8xSendIrpSynchronously)
#endif
NTSTATUS
I8xAddDevice (
IN PDRIVER_OBJECT Driver,
IN PDEVICE_OBJECT PDO
)
/*++
Routine Description:
Adds a device to the stack and sets up the appropriate flags and
device extension for the newly created device.
Arguments:
Driver - The driver object
PDO - the device that we are attaching ourselves on top of
Return Value:
NTSTATUS result code.
--*/
{
PCOMMON_DATA commonData;
PIO_ERROR_LOG_PACKET errorLogEntry;
PDEVICE_OBJECT device;
NTSTATUS status = STATUS_SUCCESS;
ULONG maxSize;
PAGED_CODE();
Print(DBG_PNP_TRACE, ("enter Add Device \n"));
maxSize = sizeof(PORT_KEYBOARD_EXTENSION) > sizeof(PORT_MOUSE_EXTENSION) ?
sizeof(PORT_KEYBOARD_EXTENSION) :
sizeof(PORT_MOUSE_EXTENSION);
status = IoCreateDevice(Driver, // driver
maxSize, // size of extension
NULL, // device name
FILE_DEVICE_8042_PORT, // device type ?? unknown at this time!!!
0, // device characteristics
FALSE, // exclusive
&device // new device
);
if (!NT_SUCCESS(status)) {
return (status);
}
RtlZeroMemory(device->DeviceExtension, maxSize);
commonData = GET_COMMON_DATA(device->DeviceExtension);
commonData->TopOfStack = IoAttachDeviceToDeviceStack(device, PDO);
if (commonData->TopOfStack == NULL) {
//
// Not good; in only extreme cases will this fail
//
errorLogEntry = (PIO_ERROR_LOG_PACKET)
IoAllocateErrorLogEntry(Driver, (UCHAR)sizeof(IO_ERROR_LOG_PACKET));
if (errorLogEntry) {
errorLogEntry->ErrorCode = I8042_ATTACH_DEVICE_FAILED;
errorLogEntry->DumpDataSize = 0;
errorLogEntry->SequenceNumber = 0;
errorLogEntry->MajorFunctionCode = 0;
errorLogEntry->IoControlCode = 0;
errorLogEntry->RetryCount = 0;
errorLogEntry->UniqueErrorValue = 0;
errorLogEntry->FinalStatus = STATUS_DEVICE_NOT_CONNECTED;
IoWriteErrorLogEntry (errorLogEntry);
}
IoDeleteDevice (device);
return STATUS_DEVICE_NOT_CONNECTED;
}
ASSERT(commonData->TopOfStack);
commonData->Self = device;
commonData->PDO = PDO;
commonData->PowerState = PowerDeviceD0;
KeInitializeSpinLock(&commonData->InterruptSpinLock);
//
// Initialize the data consumption timer
//
KeInitializeTimer(&commonData->DataConsumptionTimer);
//
// Initialize the port DPC queue to log overrun and internal
// device errors.
//
KeInitializeDpc(
&commonData->ErrorLogDpc,
(PKDEFERRED_ROUTINE) I8042ErrorLogDpc,
device
);
//
// Initialize the device completion DPC for requests that exceed the
// maximum number of retries.
//
KeInitializeDpc(
&commonData->RetriesExceededDpc,
(PKDEFERRED_ROUTINE) I8042RetriesExceededDpc,
device
);
//
// Initialize the device completion DPC for requests that have timed out
//
KeInitializeDpc(
&commonData->TimeOutDpc,
(PKDEFERRED_ROUTINE) I8042TimeOutDpc,
device
);
//
// Initialize the port completion DPC object in the device extension.
// This DPC routine handles the completion of successful set requests.
//
IoInitializeDpcRequest(device, I8042CompletionDpc);
IoInitializeRemoveLock(&commonData->RemoveLock,
I8042_POOL_TAG,
0,
0);
device->Flags |= DO_BUFFERED_IO;
device->Flags |= DO_POWER_PAGABLE;
device->Flags &= ~DO_DEVICE_INITIALIZING;
Print(DBG_PNP_TRACE, ("Add Device (0x%x)\n", status));
return status;
}
NTSTATUS
I8xSendIrpSynchronously (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN BOOLEAN Strict
)
/*++
Routine Description:
Generic routine to send an irp DeviceObject and wait for its return up the
device stack.
Arguments:
DeviceObject - The device object to which we want to send the Irp
Irp - The Irp we want to send
Return Value:
return code from the Irp
--*/
{
KEVENT event;
NTSTATUS status;
PAGED_CODE();
KeInitializeEvent(&event,
SynchronizationEvent,
FALSE
);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
I8xPnPComplete,
&event,
TRUE,
TRUE,
TRUE
);
status = IoCallDriver(DeviceObject, Irp);
//
// Wait for lower drivers to be done with the Irp
//
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL
);
status = Irp->IoStatus.Status;
}
if (!Strict &&
(status == STATUS_NOT_SUPPORTED ||
status == STATUS_INVALID_DEVICE_REQUEST)) {
status = STATUS_SUCCESS;
}
return status;
}
NTSTATUS
I8xPnPComplete (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PKEVENT Event
)
/*++
Routine Description:
Completion routine for all PnP IRPs
Arguments:
DeviceObject - Pointer to the DeviceObject
Irp - Pointer to the request packet
Event - The event to set once processing is complete
Return Value:
STATUS_MORE_PROCESSING_REQUIRED
--*/
{
UNREFERENCED_PARAMETER (DeviceObject);
UNREFERENCED_PARAMETER (Irp);
//
// Since this completion routines sole purpose in life is to synchronize
// Irp, we know that unless something else happens that the IoCallDriver
// will unwind AFTER the we have complete this Irp. Therefore we should
// NOT bubble up the pending bit.
//
// if (Irp->PendingReturned) {
// IoMarkIrpPending(Irp);
// }
//
KeSetEvent(Event, 0, FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
I8xPnP (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This is the dispatch routine for PnP requests
Arguments:
DeviceObject - Pointer to the device object
Irp - Pointer to the request packet
Return Value:
STATUS_SUCCESSFUL if successful,
an valid NTSTATUS error code otherwise
--*/
{
PPORT_KEYBOARD_EXTENSION kbExtension;
PPORT_MOUSE_EXTENSION mouseExtension;
PCOMMON_DATA commonData;
PIO_STACK_LOCATION stack;
NTSTATUS status = STATUS_SUCCESS;
KIRQL oldIrql;
PAGED_CODE();
commonData = GET_COMMON_DATA(DeviceObject->DeviceExtension);
stack = IoGetCurrentIrpStackLocation(Irp);
status = IoAcquireRemoveLock(&commonData->RemoveLock, Irp);
if (!NT_SUCCESS(status)) {
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
Print(DBG_PNP_TRACE,
("I8xPnP (%s), enter (min func=0x%x)\n",
commonData->IsKeyboard ? "kb" : "mou",
(ULONG) stack->MinorFunction
));
switch (stack->MinorFunction) {
case IRP_MN_START_DEVICE:
//
// The device is starting.
//
// We cannot touch the device (send it any non pnp irps) until a
// start device has been passed down to the lower drivers.
//
status = I8xSendIrpSynchronously(commonData->TopOfStack, Irp, TRUE);
if (NT_SUCCESS(status) && NT_SUCCESS(Irp->IoStatus.Status)) {
//
// As we are successfully now back from our start device
// we can do work.
ExAcquireFastMutexUnsafe(&Globals.DispatchMutex);
if (commonData->Started) {
Print(DBG_PNP_ERROR,
("received 1+ starts on %s\n",
commonData->IsKeyboard ? "kb" : "mouse"
));
}
else {
//
// commonData->IsKeyboard is set during
// IOCTL_INTERNAL_KEYBOARD_CONNECT to TRUE and
// IOCTL_INTERNAL_MOUSE_CONNECT to FALSE
//
if (IS_KEYBOARD(commonData)) {
status = I8xKeyboardStartDevice(
(PPORT_KEYBOARD_EXTENSION) DeviceObject->DeviceExtension,
stack->Parameters.StartDevice.AllocatedResourcesTranslated
);
}
else {
status = I8xMouseStartDevice(
(PPORT_MOUSE_EXTENSION) DeviceObject->DeviceExtension,
stack->Parameters.StartDevice.AllocatedResourcesTranslated
);
}
if (NT_SUCCESS(status)) {
InterlockedIncrement(&Globals.StartedDevices);
commonData->Started = TRUE;
}
}
ExReleaseFastMutexUnsafe(&Globals.DispatchMutex);
}
//
// We must now complete the IRP, since we stopped it in the
// completetion routine with MORE_PROCESSING_REQUIRED.
//
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
//
// The general rule of thumb for handling this minor code is this:
// add resources when the irp is going down the stack and
// remove resources when the irp is coming back up the stack
//
// The irp has the original resources on the way down.
//
status = I8xSendIrpSynchronously(commonData->TopOfStack, Irp, FALSE);
if (NT_SUCCESS(status)) {
status = I8xFilterResourceRequirements(DeviceObject,
Irp
);
}
else {
Print(DBG_PNP_ERROR,
("error pending filter res req event (0x%x)\n",
status
));
}
//
// Irp->IoStatus.Information will contain the new i/o resource
// requirements list so leave it alone
//
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
case IRP_MN_QUERY_PNP_DEVICE_STATE:
status = I8xSendIrpSynchronously(commonData->TopOfStack, Irp, FALSE);
if (NT_SUCCESS(status)) {
(PNP_DEVICE_STATE) Irp->IoStatus.Information |=
commonData->PnpDeviceState;
}
else {
Print(DBG_PNP_ERROR,
("error pending query pnp device state event (0x%x)\n",
status
));
}
//
// Irp->IoStatus.Information will contain the new i/o resource
// requirements list so leave it alone
//
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
//
// Don't let either of the requests succeed, otherwise the kb/mouse
// might be rendered useless.
//
// NOTE: this behavior is particular to i8042prt. Any other driver,
// especially any other keyboard or port driver, should
// succeed the query remove or stop. i8042prt has this different
// behavior because of the shared I/O ports but independent interrupts.
//
// FURTHERMORE, if you allow the query to succeed, it should be sent
// down the stack (see sermouse.sys for an example of how to do this)
//
case IRP_MN_QUERY_REMOVE_DEVICE:
case IRP_MN_QUERY_STOP_DEVICE:
status = (MANUALLY_REMOVED(commonData) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
//
// If we succeed the irp, we must send it down the stack
//
if (NT_SUCCESS(status)) {
IoSkipCurrentIrpStackLocation(Irp);
status = IoCallDriver(commonData->TopOfStack, Irp);
}
else {
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
break;
//
// PnP rules dictate we send the IRP down to the PDO first
//
case IRP_MN_CANCEL_REMOVE_DEVICE:
case IRP_MN_CANCEL_STOP_DEVICE:
status = I8xSendIrpSynchronously(commonData->TopOfStack, Irp, FALSE);
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
// case IRP_MN_SURPRISE_REMOVAL:
case IRP_MN_REMOVE_DEVICE:
Print(DBG_PNP_INFO,
("(surprise) remove device (0x%x function 0x%x)\n",
commonData->Self,
(ULONG) stack->MinorFunction));
if (commonData->Initialized) {
IoWMIRegistrationControl(commonData->Self,
WMIREG_ACTION_DEREGISTER
);
}
if (commonData->Started) {
InterlockedDecrement(&Globals.StartedDevices);
}
//
// Wait for any pending I/O to drain
//
IoReleaseRemoveLockAndWait(&commonData->RemoveLock, Irp);
ExAcquireFastMutexUnsafe(&Globals.DispatchMutex);
if (IS_KEYBOARD(commonData)) {
I8xKeyboardRemoveDevice(DeviceObject);
}
else {
I8xMouseRemoveDevice(DeviceObject);
}
ExReleaseFastMutexUnsafe(&Globals.DispatchMutex);
//
// Set these flags so that when a surprise remove is sent, it will be
// handled just like a remove, and when the remove comes, no other
// removal type actions will occur.
//
commonData->Started = FALSE;
commonData->Initialized = FALSE;
Irp->IoStatus.Status = STATUS_SUCCESS;
IoSkipCurrentIrpStackLocation(Irp);
status = IoCallDriver(commonData->TopOfStack, Irp);
IoDetachDevice(commonData->TopOfStack);
IoDeleteDevice(DeviceObject);
return status;
case IRP_MN_QUERY_CAPABILITIES:
//
// Change the device caps to not allow wait wake requests on level
// triggered interrupts for mice because when an errant mouse movement
// occurs while we are going to sleep, the interrupt will remain
// triggered indefinitely.
//
// If the mouse does not have a level triggered interrupt, just let the
// irp go by...
//
if (commonData->Started &&
IS_MOUSE(commonData) && IS_LEVEL_TRIGGERED(commonData)) {
Print(DBG_PNP_NOISE, ("query caps, mouse is level triggered\n"));
status = I8xSendIrpSynchronously(commonData->TopOfStack, Irp, TRUE);
if (NT_SUCCESS(status) && NT_SUCCESS(Irp->IoStatus.Status)) {
PDEVICE_CAPABILITIES devCaps;
Print(DBG_PNP_INFO, ("query caps, removing wake caps\n"));
stack = IoGetCurrentIrpStackLocation(Irp);
devCaps = stack->Parameters.DeviceCapabilities.Capabilities;
ASSERT(devCaps);
if (devCaps) {
Print(DBG_PNP_NOISE,
("old DeviceWake was D%d and SystemWake was S%d.\n",
devCaps->DeviceWake-1, devCaps->SystemWake-1
)) ;
devCaps->DeviceWake = PowerDeviceUnspecified;
devCaps->SystemWake = PowerSystemUnspecified;
}
}
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
}
case IRP_MN_STOP_DEVICE:
case IRP_MN_QUERY_DEVICE_RELATIONS:
case IRP_MN_QUERY_INTERFACE:
case IRP_MN_QUERY_DEVICE_TEXT:
case IRP_MN_QUERY_RESOURCES:
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
case IRP_MN_READ_CONFIG:
case IRP_MN_WRITE_CONFIG:
case IRP_MN_EJECT:
case IRP_MN_SET_LOCK:
case IRP_MN_QUERY_ID:
default:
//
// Here the driver below i8042prt might modify the behavior of these IRPS
// Please see PlugPlay documentation for use of these IRPs.
//
IoSkipCurrentIrpStackLocation(Irp);
status = IoCallDriver(commonData->TopOfStack, Irp);
break;
}
Print(DBG_PNP_TRACE,
("I8xPnP (%s) exit (status=0x%x)\n",
commonData->IsKeyboard ? "kb" : "mou",
status
));
IoReleaseRemoveLock(&commonData->RemoveLock, Irp);
return status;
}
LONG
I8xManuallyRemoveDevice(
PCOMMON_DATA CommonData
)
/*++
Routine Description:
Invalidates CommonData->PDO's device state and sets the manually removed
flag
Arguments:
CommonData - represent either the keyboard or mouse
Return Value:
new device count for that particular type of device
--*/
{
LONG deviceCount;
PAGED_CODE();
if (IS_KEYBOARD(CommonData)) {
deviceCount = InterlockedDecrement(&Globals.AddedKeyboards);
if (deviceCount < 1) {
Print(DBG_PNP_INFO, ("clear kb (manually remove)\n"));
CLEAR_KEYBOARD_PRESENT();
}
} else {
deviceCount = InterlockedDecrement(&Globals.AddedMice);
if (deviceCount < 1) {
Print(DBG_PNP_INFO, ("clear mou (manually remove)\n"));
CLEAR_MOUSE_PRESENT();
}
}
CommonData->PnpDeviceState |= PNP_DEVICE_REMOVED | PNP_DEVICE_DONT_DISPLAY_IN_UI;
IoInvalidateDeviceState(CommonData->PDO);
return deviceCount;
}
#define PhysAddrCmp(a,b) ( (a).LowPart == (b).LowPart && (a).HighPart == (b).HighPart )
BOOLEAN
I8xRemovePort(
IN PIO_RESOURCE_DESCRIPTOR ResDesc
)
/*++
Routine Description:
If the physical address contained in the ResDesc is not in the list of
previously seen physicall addresses, it is placed within the list.
Arguments:
ResDesc - contains the physical address
Return Value:
TRUE - if the physical address was found in the list
FALSE - if the physical address was not found in the list (and thus inserted
into it)
--*/
{
ULONG i;
PHYSICAL_ADDRESS address;
PAGED_CODE();
if (Globals.ControllerData->KnownPortsCount == -1) {
return FALSE;
}
address = ResDesc->u.Port.MinimumAddress;
for (i = 0; i < Globals.ControllerData->KnownPortsCount; i++) {
if (PhysAddrCmp(address, Globals.ControllerData->KnownPorts[i])) {
return TRUE;
}
}
if (Globals.ControllerData->KnownPortsCount < MaximumPortCount) {
Globals.ControllerData->KnownPorts[
Globals.ControllerData->KnownPortsCount++] = address;
}
Print(DBG_PNP_INFO,
("Saw port [0x%08x %08x] - [0x%08x %08x]\n",
address.HighPart,
address.LowPart,
ResDesc->u.Port.MaximumAddress.HighPart,
ResDesc->u.Port.MaximumAddress.LowPart
));
return FALSE;
}
NTSTATUS
I8xFindPortCallout(
IN PVOID Context,
IN PUNICODE_STRING PathName,
IN INTERFACE_TYPE BusType,
IN ULONG BusNumber,
IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
IN CONFIGURATION_TYPE ControllerType,
IN ULONG ControllerNumber,
IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
IN CONFIGURATION_TYPE PeripheralType,
IN ULONG PeripheralNumber,
IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
)
/*++
Routine Description:
This is the callout routine sent as a parameter to
IoQueryDeviceDescription. It grabs the keyboard controller and
peripheral configuration information.
Arguments:
Context - Context parameter that was passed in by the routine
that called IoQueryDeviceDescription.
PathName - The full pathname for the registry key.
BusType - Bus interface type (Isa, Eisa, Mca, etc.).
BusNumber - The bus sub-key (0, 1, etc.).
BusInformation - Pointer to the array of pointers to the full value
information for the bus.
ControllerType - The controller type (should be KeyboardController).
ControllerNumber - The controller sub-key (0, 1, etc.).
ControllerInformation - Pointer to the array of pointers to the full
value information for the controller key.
PeripheralType - The peripheral type (should be KeyboardPeripheral).
PeripheralNumber - The peripheral sub-key.
PeripheralInformation - Pointer to the array of pointers to the full
value information for the peripheral key.
Return Value:
None. If successful, will have the following side-effects:
- Sets DeviceObject->DeviceExtension->HardwarePresent.
- Sets configuration fields in
DeviceObject->DeviceExtension->Configuration.
--*/
{
PUCHAR controllerData;
NTSTATUS status = STATUS_UNSUCCESSFUL;
ULONG i,
listCount,
portCount = 0;
PIO_RESOURCE_LIST pResList = (PIO_RESOURCE_LIST) Context;
PIO_RESOURCE_DESCRIPTOR pResDesc;
PKEY_VALUE_FULL_INFORMATION controllerInfo = NULL;
PCM_PARTIAL_RESOURCE_DESCRIPTOR resourceDescriptor;
PAGED_CODE();
UNREFERENCED_PARAMETER(PathName);
UNREFERENCED_PARAMETER(BusType);
UNREFERENCED_PARAMETER(BusNumber);
UNREFERENCED_PARAMETER(BusInformation);
UNREFERENCED_PARAMETER(ControllerType);
UNREFERENCED_PARAMETER(ControllerNumber);
UNREFERENCED_PARAMETER(PeripheralType);
UNREFERENCED_PARAMETER(PeripheralNumber);
UNREFERENCED_PARAMETER(PeripheralInformation);
pResDesc = pResList->Descriptors + pResList->Count;
controllerInfo = ControllerInformation[IoQueryDeviceConfigurationData];
Print(DBG_PNP_TRACE, ("I8xFindPortCallout enter\n"));
if (controllerInfo->DataLength != 0) {
controllerData = ((PUCHAR) controllerInfo) + controllerInfo->DataOffset;
controllerData += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
PartialResourceList);
listCount = ((PCM_PARTIAL_RESOURCE_LIST) controllerData)->Count;
resourceDescriptor =
((PCM_PARTIAL_RESOURCE_LIST) controllerData)->PartialDescriptors;
for (i = 0; i < listCount; i++, resourceDescriptor++) {
switch(resourceDescriptor->Type) {
case CmResourceTypePort:
if (portCount < 2) {
Print(DBG_PNP_INFO,
("found port [0x%x 0x%x] with length %d\n",
resourceDescriptor->u.Port.Start.HighPart,
resourceDescriptor->u.Port.Start.LowPart,
resourceDescriptor->u.Port.Length
));
pResDesc->Type = resourceDescriptor->Type;
pResDesc->Flags = resourceDescriptor->Flags;
pResDesc->ShareDisposition = CmResourceShareDeviceExclusive;
pResDesc->u.Port.Alignment = 1;
pResDesc->u.Port.Length =
resourceDescriptor->u.Port.Length;
pResDesc->u.Port.MinimumAddress.QuadPart =
resourceDescriptor->u.Port.Start.QuadPart;
pResDesc->u.Port.MaximumAddress.QuadPart =
pResDesc->u.Port.MinimumAddress.QuadPart +
pResDesc->u.Port.Length - 1;
pResList->Count++;
//
// We want to record the ports we stole from the kb as seen
// so that if the keyboard is started later, we can trim
// its resources and not have a resource conflict...
//
// ...we are getting too smart for ourselves here :]
//
I8xRemovePort(pResDesc);
pResDesc++;
}
status = STATUS_SUCCESS;
break;
default:
Print(DBG_PNP_NOISE, ("type 0x%x found\n",
(LONG) resourceDescriptor->Type));
break;
}
}
}
Print(DBG_PNP_TRACE, ("I8xFindPortCallout exit (0x%x)\n", status));
return status;
}
NTSTATUS
I8xFilterResourceRequirements(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Iterates through the resource requirements list contained in the IRP and removes
any duplicate requests for I/O ports. (This is a common problem on the Alphas.)
No removal is performed if more than one resource requirements list is present.
Arguments:
DeviceObject - A pointer to the device object
Irp - A pointer to the request packet which contains the resource req. list.
Return Value:
None.
--*/
{
PIO_RESOURCE_REQUIREMENTS_LIST pReqList = NULL,
pNewReqList = NULL;
PIO_RESOURCE_LIST pResList = NULL,
pNewResList = NULL;
PIO_RESOURCE_DESCRIPTOR pResDesc = NULL,
pNewResDesc = NULL;
ULONG i = 0, j = 0,
removeCount,
reqCount,
size;
BOOLEAN foundInt = FALSE,
foundPorts = FALSE;
PIO_STACK_LOCATION stack;
PAGED_CODE();
ASSERT(DeviceObject);
ASSERT(DeviceObject->DeviceExtension);
Print(DBG_PNP_NOISE,
("Received IRP_MN_FILTER_RESOURCE_REQUIREMENTS for %s\n",
(GET_COMMON_DATA(DeviceObject->DeviceExtension))->IsKeyboard ? "kb" : "mouse"
));
stack = IoGetCurrentIrpStackLocation(Irp);
//
// The list can be in either the information field, or in the current
// stack location. The Information field has a higher precedence over
// the stack location.
//
if (Irp->IoStatus.Information == 0) {
pReqList =
stack->Parameters.FilterResourceRequirements.IoResourceRequirementList;
Irp->IoStatus.Information = (ULONG_PTR) pReqList;
}
else {
pReqList = (PIO_RESOURCE_REQUIREMENTS_LIST) Irp->IoStatus.Information;
}
if (!pReqList) {
//
// Not much can be done here except return
//
Print(DBG_PNP_MASK & ~ DBG_PNP_TRACE,
("(%s) NULL resource list in I8xFilterResourceRequirements\n",
(GET_COMMON_DATA(DeviceObject->DeviceExtension))->IsKeyboard ?
"kb" : "mou"
));
return STATUS_SUCCESS;
}
ASSERT(Irp->IoStatus.Information != 0);
ASSERT(pReqList != 0);
reqCount = pReqList->AlternativeLists;
//
// Only one AlternativeList is supported. If there is more than one list,
// then there is now way of knowing which list will be chosen. Also, if
// there are multiple lists, then chances are that a list with no i/o port
// conflicts will be chosen.
//
if (reqCount > 1) {
return STATUS_SUCCESS;
}
pResList = pReqList->List;
removeCount = 0;
for (j = 0; j < pResList->Count; j++) {
pResDesc = &pResList->Descriptors[j];
switch (pResDesc->Type) {
case CmResourceTypePort:
Print(DBG_PNP_INFO,
("option = 0x%x, flags = 0x%x\n",
(LONG) pResDesc->Option,
(LONG) pResDesc->Flags
));
if (I8xRemovePort(pResDesc)) {
//
// Increment the remove count and tag this resource as
// one that we don't want to copy to the new list
//
removeCount++;
pResDesc->Type = I8X_REMOVE_RESOURCE;
}
foundPorts = TRUE;
break;
case CmResourceTypeInterrupt:
if (Globals.ControllerData->Configuration.SharedInterrupts) {
if (pResDesc->ShareDisposition != CmResourceShareShared) {
Print(DBG_PNP_INFO, ("forcing non shared int to shared\n"));
}
pResDesc->ShareDisposition = CmResourceShareShared;
}
foundInt = TRUE;
break;
default:
break;
}
}
if (removeCount) {
size = pReqList->ListSize;
//
// One element of the array is already allocated (via the struct
// definition) so make sure that we are allocating at least that
// much memory.
//
ASSERT(pResList->Count >= removeCount);
if (pResList->Count > 1) {
size -= removeCount * sizeof(IO_RESOURCE_DESCRIPTOR);
}
pNewReqList =
(PIO_RESOURCE_REQUIREMENTS_LIST) ExAllocatePool(PagedPool, size);
if (!pNewReqList) {
//
// This is not good, but the system doesn't really need to know about
// this, so just fix up our munging and return the original list
//
pReqList = stack->Parameters.FilterResourceRequirements.IoResourceRequirementList;
reqCount = pReqList->AlternativeLists;
removeCount = 0;
for (i = 0; i < reqCount; i++) {
pResList = &pReqList->List[i];
for (j = 0; j < pResList->Count; j++) {
pResDesc = &pResList->Descriptors[j];
if (pResDesc->Type == I8X_REMOVE_RESOURCE) {
pResDesc->Type = CmResourceTypePort;
}
}
}
return STATUS_SUCCESS;
}
//
// Clear out the newly allocated list
//
RtlZeroMemory(pNewReqList,
size
);
//
// Copy the list header information except for the IO resource list
// itself
//
RtlCopyMemory(pNewReqList,
pReqList,
sizeof(IO_RESOURCE_REQUIREMENTS_LIST) -
sizeof(IO_RESOURCE_LIST)
);
pNewReqList->ListSize = size;
pResList = pReqList->List;
pNewResList = pNewReqList->List;
//
// Copy the list header information except for the IO resource
// descriptor list itself
//
RtlCopyMemory(pNewResList,
pResList,
sizeof(IO_RESOURCE_LIST) -
sizeof(IO_RESOURCE_DESCRIPTOR)
);
pNewResList->Count = 0;
pNewResDesc = pNewResList->Descriptors;
for (j = 0; j < pResList->Count; j++) {
pResDesc = &pResList->Descriptors[j];
if (pResDesc->Type != I8X_REMOVE_RESOURCE) {
//
// Keep this resource, so copy it into the new list and
// incement the count and the location for the next
// IO resource descriptor
//
*pNewResDesc = *pResDesc;
pNewResDesc++;
pNewResList->Count++;
Print(DBG_PNP_INFO,
("List #%d, Descriptor #%d ... keeping res type %d\n",
i, j,
(ULONG) pResDesc->Type
));
}
else {
//
// Decrement the remove count so we can assert it is
// zero once we are done
//
Print(DBG_PNP_INFO,
("Removing port [0x%08x %08x] - [0x%#08x %08x]\n",
pResDesc->u.Port.MinimumAddress.HighPart,
pResDesc->u.Port.MinimumAddress.LowPart,
pResDesc->u.Port.MaximumAddress.HighPart,
pResDesc->u.Port.MaximumAddress.LowPart
));
removeCount--;
}
}
ASSERT(removeCount == 0);
//
// There have been bugs where the old list was being used. Zero it out to
// make sure that no conflicts arise. (Not to mention the fact that some
// other code is accessing freed memory
//
RtlZeroMemory(pReqList,
pReqList->ListSize
);
//
// Free the old list and place the new one in its place
//
ExFreePool(pReqList);
stack->Parameters.FilterResourceRequirements.IoResourceRequirementList =
pNewReqList;
Irp->IoStatus.Information = (ULONG_PTR) pNewReqList;
}
else if (!KEYBOARD_PRESENT() && !foundPorts && foundInt) {
INTERFACE_TYPE interfaceType;
NTSTATUS status;
ULONG prevCount;
CONFIGURATION_TYPE controllerType = KeyboardController;
CONFIGURATION_TYPE peripheralType = KeyboardPeripheral;
ASSERT( MOUSE_PRESENT() );
Print(DBG_PNP_INFO, ("Adding ports to res list!\n"));
//
// We will now yank the resources from the keyboard to start the mouse
// solo
//
size = pReqList->ListSize + 2 * sizeof(IO_RESOURCE_DESCRIPTOR);
pNewReqList = (PIO_RESOURCE_REQUIREMENTS_LIST)
ExAllocatePool(
PagedPool,
size
);
if (!pNewReqList) {
return STATUS_SUCCESS;
}
//
// Clear out the newly allocated list
//
RtlZeroMemory(pNewReqList,
size
);
//
// Copy the entire old list
//
RtlCopyMemory(pNewReqList,
pReqList,
pReqList->ListSize
);
pResList = pReqList->List;
pNewResList = pNewReqList->List;
prevCount = pNewResList->Count;
for (i = 0; i < MaximumInterfaceType; i++) {
//
// Get the registry information for this device.
//
interfaceType = i;
status = IoQueryDeviceDescription(
&interfaceType,
NULL,
&controllerType,
NULL,
&peripheralType,
NULL,
I8xFindPortCallout,
(PVOID) pNewResList
);
if (NT_SUCCESS(status) || prevCount != pNewResList->Count) {
break;
}
}
if (NT_SUCCESS(status) || prevCount != pNewResList->Count) {
pNewReqList->ListSize = size - (2 - (pNewResList->Count - prevCount));
//
// Free the old list and place the new one in its place
//
ExFreePool(pReqList);
stack->Parameters.FilterResourceRequirements.IoResourceRequirementList =
pNewReqList;
Irp->IoStatus.Information = (ULONG_PTR) pNewReqList;
}
else {
ExFreePool(pNewReqList);
}
}
return STATUS_SUCCESS;
}
NTSTATUS
I8xRegisterDeviceInterface(
PDEVICE_OBJECT PDO,
CONST GUID * Guid,
PUNICODE_STRING SymbolicName
)
{
NTSTATUS status;
PAGED_CODE();
status = IoRegisterDeviceInterface(
PDO,
Guid,
NULL,
SymbolicName
);
if (NT_SUCCESS(status)) {
status = IoSetDeviceInterfaceState(SymbolicName,
TRUE
);
}
return status;
}
void
I8xSetPowerFlag(
IN ULONG Flag,
IN BOOLEAN Set
)
{
KIRQL irql;
KeAcquireSpinLock(&Globals.ControllerData->PowerSpinLock, &irql);
if (Set) {
Globals.PowerFlags |= Flag;
}
else {
Globals.PowerFlags &= ~Flag;
}
KeReleaseSpinLock(&Globals.ControllerData->PowerSpinLock, irql);
}
BOOLEAN
I8xCheckPowerFlag(
ULONG Flag
)
{
KIRQL irql;
BOOLEAN rVal = FALSE;
KeAcquireSpinLock(&Globals.ControllerData->PowerSpinLock, &irql);
if (Globals.PowerFlags & Flag) {
rVal = TRUE;
}
KeReleaseSpinLock(&Globals.ControllerData->PowerSpinLock, irql);
return rVal;
}
NTSTATUS
I8xPower (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This is the dispatch routine for power requests.
Arguments:
DeviceObject - Pointer to the device object.
Irp - Pointer to the request packet.
Return Value:
STATUS_SUCCESSFUL if successful,
an valid NTSTATUS error code otherwise
--*/
{
PCOMMON_DATA commonData;
PIO_STACK_LOCATION stack;
NTSTATUS status = STATUS_SUCCESS;
PAGED_CODE();
commonData = GET_COMMON_DATA(DeviceObject->DeviceExtension);
stack = IoGetCurrentIrpStackLocation(Irp);
Print(DBG_POWER_TRACE,
("Power (%s), enter\n",
commonData->IsKeyboard ? "keyboard" :
"mouse"
));
//
// A power irp can be sent to the device before we have been started or
// initialized. Since the code below relies on StartDevice() to have
// executed, just fire and forget the irp
//
if (!commonData->Started || !commonData->Initialized) {
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = STATUS_SUCCESS;
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(commonData->TopOfStack, Irp);
}
switch(stack->MinorFunction) {
case IRP_MN_WAIT_WAKE:
Print(DBG_POWER_NOISE, ("Got IRP_MN_WAIT_WAKE\n" ));
//
// Fail all wait wake requests on level triggered interrupts for mice
// because when an errant mouse movement occurs while we are going to
// sleep, it will keep the interrupt triggered indefinitely.
//
// We should not even get into this situation because the caps of the
// mouse should have been altered to not report wait wake
//
if (IS_MOUSE(commonData) && IS_LEVEL_TRIGGERED(commonData)) {
PoStartNextPowerIrp(Irp);
status = Irp->IoStatus.Status = STATUS_INVALID_DEVICE_STATE;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
Print(DBG_POWER_INFO | DBG_POWER_ERROR,
("failing a wait wake request on a level triggered mouse\n"));
return status;
}
break;
case IRP_MN_POWER_SEQUENCE:
Print(DBG_POWER_NOISE, ("Got IRP_MN_POWER_SEQUENCE\n" ));
break;
case IRP_MN_SET_POWER:
Print(DBG_POWER_NOISE, ("Got IRP_MN_SET_POWER\n" ));
//
// Don't handle anything but DevicePowerState changes
//
if (stack->Parameters.Power.Type != DevicePowerState) {
commonData->SystemState = stack->Parameters.Power.State.SystemState;
Print(DBG_POWER_INFO, ("system power irp, S%d\n", commonData->SystemState-1));
break;
}
//
// Check for no change in state, and if none, do nothing. This state
// can occur when the device is armed for wake. We will get a D0 in
// response to the WW irp completing and then another D0 corresponding
// to the S0 irp sent to the stack.
//
if (stack->Parameters.Power.State.DeviceState ==
commonData->PowerState) {
Print(DBG_POWER_INFO,
("no change in state (PowerDeviceD%d)\n",
commonData->PowerState-1
));
break;
}
switch (stack->Parameters.Power.State.DeviceState) {
case PowerDeviceD0:
Print(DBG_POWER_INFO, ("Powering up to PowerDeviceD0\n"));
IoAcquireRemoveLock(&commonData->RemoveLock, Irp);
if (IS_KEYBOARD(commonData)) {
I8xSetPowerFlag(KBD_POWERED_UP_STARTED, TRUE);
}
else {
I8xSetPowerFlag(MOU_POWERED_UP_STARTED, TRUE);
}
//
// PoSetPowerState will be called in I8xReinitalizeHardware for each
// device once all the devices have powered back up
//
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
I8xPowerUpToD0Complete,
NULL,
TRUE, // on success
TRUE, // on error
TRUE // on cancel
);
//
// PoStartNextPowerIrp() gets called when the irp gets completed
// in either the completion routine or the resulting work item
//
// It is OK to call PoCallDriver and return pending b/c we are
// pending the irp in the completion routine and we may change
// the completion status if we can't alloc pool. If we return the
// value from PoCallDriver, we are tied to that status value on the
// way back up.
//
IoMarkIrpPending(Irp);
PoCallDriver(commonData->TopOfStack, Irp);
return STATUS_PENDING;
case PowerDeviceD1:
case PowerDeviceD2:
case PowerDeviceD3:
Print(DBG_POWER_INFO,
("Powering down to PowerDeviceD%d\n",
stack->Parameters.Power.State.DeviceState-1
));
//
// If WORK_ITEM_QUEUED is set, that means that a work item is
// either queued to be run, or running now so we don't want to yank
// any devices underneath from the work item
//
if (I8xCheckPowerFlag(WORK_ITEM_QUEUED)) {
Print(DBG_POWER_INFO | DBG_POWER_ERROR,
("denying power down request because work item is running\n"
));
PoStartNextPowerIrp(Irp);
status = Irp->IoStatus.Status = STATUS_POWER_STATE_INVALID;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
if (IS_KEYBOARD(commonData)) {
I8xSetPowerFlag(KBD_POWERED_DOWN, TRUE);
}
else {
I8xSetPowerFlag(MOU_POWERED_DOWN, TRUE);
}
PoSetPowerState(DeviceObject,
stack->Parameters.Power.Type,
stack->Parameters.Power.State
);
//
// Disconnect level triggered interupts on mice when we go into
// low power so errant mouse movement doesn't leave the interrupt
// signalled for long periods of time
//
if (IS_MOUSE(commonData) && IS_LEVEL_TRIGGERED(commonData)) {
PKINTERRUPT interrupt = commonData->InterruptObject;
Print(DBG_POWER_NOISE,
("disconnecting interrupt on level triggered mouse\n")
);
commonData->InterruptObject = NULL;
if (interrupt) {
IoDisconnectInterrupt(interrupt);
}
}
commonData->PowerState = stack->Parameters.Power.State.DeviceState;
commonData->ShutdownType = stack->Parameters.Power.ShutdownType;
//
// For what we are doing, we don't need a completion routine
// since we don't race on the power requests.
//
Irp->IoStatus.Status = STATUS_SUCCESS;
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(commonData->TopOfStack, Irp);
default:
Print(DBG_POWER_INFO, ("unknown state\n"));
break;
}
break;
case IRP_MN_QUERY_POWER:
Print(DBG_POWER_NOISE, ("Got IRP_MN_QUERY_POWER\n" ));
break;
default:
Print(DBG_POWER_NOISE,
("Got unhandled minor function (%d)\n",
stack->MinorFunction
));
break;
}
Print(DBG_POWER_TRACE, ("Power, exit\n"));
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(commonData->TopOfStack, Irp);
}
NTSTATUS
I8xPowerUpToD0Complete(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
/*++
Routine Description:
Reinitializes the i8042 haardware after any type of hibernation/sleep.
Arguments:
DeviceObject - Pointer to the device object
Irp - Pointer to the request
Context - Context passed in from the funciton that set the completion
routine. UNUSED.
Return Value:
STATUS_SUCCESSFUL if successful,
an valid NTSTATUS error code otherwise
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PCOMMON_DATA commonData;
PPOWER_UP_WORK_ITEM item;
KIRQL irql;
UCHAR poweredDownDevices = 0,
poweredUpDevices = 0,
failedDevices = 0;
BOOLEAN queueItem = FALSE,
clearFlags = FALSE,
failMouIrp = FALSE;
PIRP mouIrp = NULL,
kbdIrp = NULL;
UNREFERENCED_PARAMETER(Context);
commonData = GET_COMMON_DATA(DeviceObject->DeviceExtension);
Print(DBG_POWER_TRACE,
("PowerUpToD0Complete (%s), Enter\n",
commonData->IsKeyboard ? "kb" : "mouse"
));
//
// We can use a regular work item because we have a non completed power irp
// which has an outstanding reference to this stack.
//
item = (PPOWER_UP_WORK_ITEM) ExAllocatePool(NonPagedPool,
sizeof(POWER_UP_WORK_ITEM));
KeAcquireSpinLock(&Globals.ControllerData->PowerSpinLock, &irql);
Print(DBG_POWER_TRACE,
("Power up to D0 completion enter, power flags 0x%x\n",
Globals.PowerFlags));
if (NT_SUCCESS(Irp->IoStatus.Status)) {
commonData->OutstandingPowerIrp = Irp;
status = STATUS_MORE_PROCESSING_REQUIRED;
if (IS_KEYBOARD(commonData)) {
KEYBOARD_POWERED_UP_SUCCESSFULLY();
}
else {
MOUSE_POWERED_UP_SUCCESSFULLY();
}
}
else {
if (IS_KEYBOARD(commonData)) {
KEYBOARD_POWERED_UP_FAILURE();
}
else {
MOUSE_POWERED_UP_FAILURE();
}
}
if (KEYBOARD_POWERED_DOWN_SUCCESS()) {
Print(DBG_POWER_NOISE, ("--kbd powered down successfully\n"));
poweredDownDevices++;
}
if (MOUSE_POWERED_DOWN_SUCCESS()) {
Print(DBG_POWER_NOISE, ("--mou powered down successfully\n"));
poweredDownDevices++;
}
if (KEYBOARD_POWERED_UP_SUCCESS()) {
Print(DBG_POWER_NOISE, ("++kbd powered up successfully\n"));
poweredUpDevices++;
}
if (MOUSE_POWERED_UP_SUCCESS()) {
Print(DBG_POWER_NOISE, ("++mou powered up successfully\n"));
poweredUpDevices++;
}
if (KEYBOARD_POWERED_UP_FAILED()) {
Print(DBG_POWER_NOISE|DBG_POWER_ERROR, (">>kbd powered down failed\n"));
failedDevices++;
}
if (MOUSE_POWERED_UP_FAILED()) {
Print(DBG_POWER_NOISE|DBG_POWER_ERROR, (">>mou powered down failed\n"));
failedDevices++;
}
Print(DBG_POWER_INFO,
("up %d, down %d, failed %d, flags 0x%x\n",
(ULONG) poweredUpDevices,
(ULONG) poweredDownDevices,
(ULONG) failedDevices,
Globals.PowerFlags));
if ((poweredUpDevices + failedDevices) == poweredDownDevices) {
if (poweredUpDevices > 0) {
//
// The ports are associated with the keyboard. If it has failed to
// power up while the mouse succeeded, we still need to fail the
// mouse b/c there is no hardware to talk to
//
if (failedDevices > 0 && KEYBOARD_POWERED_UP_FAILED()) {
ASSERT(MOUSE_POWERED_UP_SUCCESS());
ASSERT(Globals.KeyboardExtension->OutstandingPowerIrp == NULL);
mouIrp = Globals.MouseExtension->OutstandingPowerIrp;
Globals.MouseExtension->OutstandingPowerIrp = NULL;
Globals.PowerFlags &= ~MOU_POWER_FLAGS;
clearFlags = TRUE;
if (mouIrp != Irp) {
//
// we have queued the irp, complete it later in this
// function under a special case
//
failMouIrp = TRUE;
}
else {
//
// The mouse irp is the current irp. We have already
// completed the kbd irp in our previous processing. Set
// the irp status to some unsuccessful value so that we will
// call PoStartNextPowerIrp later in this function. Also
// set status to != STATUS_MORE_PROCESSING_REQUIRED so the
// irp will be completed when the function exits.
//
status = mouIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
}
else {
Print(DBG_POWER_INFO, ("at least one device powered up!\n"));
queueItem = TRUE;
}
}
else {
Print(DBG_POWER_INFO,
("all devices failed power up, 0x%x\n",
Globals.PowerFlags));
clearFlags = TRUE;
}
}
else {
//
// the other device is still powered down, wait for it to power back
// up before processing power states
//
Print(DBG_POWER_INFO,
("queueing, waiting for 2nd dev obj to power cycle\n"));
}
if (queueItem || clearFlags) {
//
// Extract the irp from each successfully started device and clear the
// associated power flags for the device
//
if (MOUSE_POWERED_UP_SUCCESS()) {
mouIrp = Globals.MouseExtension->OutstandingPowerIrp;
Globals.MouseExtension->OutstandingPowerIrp = NULL;
ASSERT(!TEST_PWR_FLAGS(MOU_POWERED_UP_FAILURE));
Globals.PowerFlags &= ~MOU_POWER_FLAGS;
}
else {
Globals.PowerFlags &= ~(MOU_POWERED_UP_FAILURE);
}
if (KEYBOARD_POWERED_UP_SUCCESS()) {
kbdIrp = Globals.KeyboardExtension->OutstandingPowerIrp;
Globals.KeyboardExtension->OutstandingPowerIrp = NULL;
ASSERT(!TEST_PWR_FLAGS(KBD_POWERED_UP_FAILURE));
Globals.PowerFlags &= ~(KBD_POWER_FLAGS);
}
else {
Globals.PowerFlags &= ~(KBD_POWERED_UP_FAILURE);
}
//
// Mark that the work item is queued. This is used to make sure that 2
// work items are not queued concucrrently
//
if (item && queueItem) {
Print(DBG_POWER_INFO, ("setting work item queued flag\n"));
Globals.PowerFlags |= WORK_ITEM_QUEUED;
}
}
KeReleaseSpinLock(&Globals.ControllerData->PowerSpinLock, irql);
if (queueItem) {
if (item == NULL) {
//
// complete any queued power irps
//
Print(DBG_POWER_INFO | DBG_POWER_ERROR,
("failed to alloc work item\n"));
//
// what about PoSetPowerState?
//
if (mouIrp != NULL) {
Print(DBG_POWER_ERROR | DBG_POWER_INFO,
("completing mouse power irp 0x%x", mouIrp));
mouIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
mouIrp->IoStatus.Information = 0x0;
PoStartNextPowerIrp(mouIrp);
IoCompleteRequest(mouIrp, IO_NO_INCREMENT);
IoReleaseRemoveLock(&Globals.MouseExtension->RemoveLock,
mouIrp);
mouIrp = NULL;
}
if (kbdIrp != NULL) {
Print(DBG_POWER_ERROR | DBG_POWER_INFO,
("completing kbd power irp 0x%x", kbdIrp));
kbdIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
kbdIrp->IoStatus.Information = 0x0;
PoStartNextPowerIrp(kbdIrp);
IoCompleteRequest(kbdIrp, IO_NO_INCREMENT);
IoReleaseRemoveLock(&Globals.KeyboardExtension->RemoveLock,
kbdIrp);
kbdIrp = NULL;
}
//
// The passed in Irp has just been completed; by returning more
// processing required, it will not be double completed
//
return STATUS_MORE_PROCESSING_REQUIRED;
}
else {
RtlZeroMemory(item, sizeof(*item));
if (MOUSE_STARTED()) {
SET_RECORD_STATE(Globals.MouseExtension,
RECORD_RESUME_FROM_POWER);
}
Print(DBG_POWER_INFO, ("queueing work item for init\n"));
item->KeyboardPowerIrp = kbdIrp;
item->MousePowerIrp = mouIrp;
ExInitializeWorkItem(&item->Item, I8xReinitializeHardware, item);
ExQueueWorkItem(&item->Item, DelayedWorkQueue);
}
}
else if (item != NULL) {
Print(DBG_POWER_NOISE,("freeing unused item %p\n", item));
ExFreePool(item);
item = NULL;
}
if (failMouIrp) {
Print(DBG_POWER_INFO | DBG_POWER_ERROR,
("failing successful mouse irp %p because kbd failed power up\n",
mouIrp));
PoStartNextPowerIrp(mouIrp);
IoCompleteRequest(mouIrp, IO_NO_INCREMENT);
IoReleaseRemoveLock(&Globals.MouseExtension->RemoveLock, mouIrp);
mouIrp = NULL;
}
if (!NT_SUCCESS(Irp->IoStatus.Status)) {
Print(DBG_POWER_INFO | DBG_POWER_ERROR,
("irp %p failed, starting next\n", Irp));
PoStartNextPowerIrp(Irp);
Irp = NULL;
ASSERT(status != STATUS_MORE_PROCESSING_REQUIRED);
}
return status;
}