/*++ Copyright (c) 1997 Microsoft Corporation Module Name: pnp.c Abstract: This module contains plug & play code for the HID Mouse Filter Driver, including code for the creation and removal of HID mouse device contexts. Environment: Kernel & user mode. Revision History: Jan-1997 : Initial writing, Dan Markarian --*/ // // For this module only we set the INITGUID macro before including wdm.h and // hidclass.h. This not only declares the GUIDs but also initializes them. // #include "mouhid.h" #include "hidclass.h" #include #include #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE,MouHid_CallHidClass) #pragma alloc_text(PAGE,MouHid_AddDevice) #pragma alloc_text(PAGE,MouHid_StartDevice) #pragma alloc_text(PAGE,MouHid_PnP) #endif NTSTATUS MouHid_CallHidClass( IN PDEVICE_EXTENSION Data, IN ULONG Ioctl, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN OUT PVOID OutputBuffer, IN ULONG OutputBufferLength ) /*++ Routine Description: Make a *synchronous* request of the HID class driver Arguments: Ioctl - Value of the IOCTL request. InputBuffer - Buffer to be sent to the HID class driver. InputBufferLength - Size of buffer to be sent to the HID class driver. OutputBuffer - Buffer for received data from the HID class driver. OutputBufferLength - Size of receive buffer from the HID class. Return Value: STATUS_SUCCESS if successful, STATUS_UNSUCCESSFUL otherwise --*/ { KEVENT event; IO_STATUS_BLOCK ioStatus; PIRP irp; PIO_STACK_LOCATION nextStack; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE (); Print (DBG_PNP_TRACE, ("PNP-CallHidClass: Enter." )); // // Prepare to issue a synchronous request. // KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest ( Ioctl, Data->TopOfStack, InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, FALSE, // external IOCTL &event, &ioStatus); if (irp == NULL) { return STATUS_UNSUCCESSFUL; } // // Call the class driver to perform the operation. If the returned status // is PENDING, wait for the request to complete. // nextStack = IoGetNextIrpStackLocation(irp); ASSERT(nextStack != NULL); status = IoCallDriver(Data->TopOfStack, irp); if (status == STATUS_PENDING) { status = KeWaitForSingleObject( &event, Executive, // wait reason KernelMode, FALSE, // not alertable NULL); // no time out } if (NT_SUCCESS (status)) { status = ioStatus.Status; } Print (DBG_PNP_TRACE, ("PNP-CallHidClass: Enter." )); return status; } NTSTATUS MouHid_QueryDeviceKey ( IN HANDLE Handle, IN PWCHAR ValueNameString, OUT PVOID Data, IN ULONG DataLength ) { NTSTATUS status; UNICODE_STRING valueName; ULONG length; PKEY_VALUE_FULL_INFORMATION fullInfo; RtlInitUnicodeString (&valueName, ValueNameString); length = sizeof (KEY_VALUE_FULL_INFORMATION) + valueName.MaximumLength + DataLength; fullInfo = ExAllocatePool (PagedPool, length); if (fullInfo) { status = ZwQueryValueKey (Handle, &valueName, KeyValueFullInformation, fullInfo, length, &length); if (NT_SUCCESS (status)) { ASSERT (DataLength == fullInfo->DataLength); RtlCopyMemory (Data, ((PUCHAR) fullInfo) + fullInfo->DataOffset, fullInfo->DataLength); } ExFreePool (fullInfo); } else { status = STATUS_NO_MEMORY; } return status; } NTSTATUS MouHid_AddDevice ( IN PDRIVER_OBJECT Driver, IN PDEVICE_OBJECT PDO ) /*++ Routine Description: Arguments: Return Value: NTSTATUS result code. --*/ { NTSTATUS status = STATUS_SUCCESS; PDEVICE_EXTENSION data; PDEVICE_OBJECT device; HANDLE devInstRegKey; ULONG tmp = 0; POWER_STATE state; PAGED_CODE (); Print (DBG_PNP_TRACE, ("enter Add Device \n")); status = IoCreateDevice(Driver, sizeof(DEVICE_EXTENSION), NULL, // no name for this Filter DO FILE_DEVICE_MOUSE, 0, FALSE, &device); if (!NT_SUCCESS (status)) { return( status ); } data = (PDEVICE_EXTENSION) device->DeviceExtension; // // Initialize the fields. // data->TopOfStack = IoAttachDeviceToDeviceStack (device, PDO); if (data->TopOfStack == NULL) { PIO_ERROR_LOG_PACKET errorLogEntry; // // 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 = MOUHID_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 (data->TopOfStack); data->Self = device; data->Started = FALSE; data->Initialized = FALSE; data->UnitId = (USHORT) InterlockedIncrement (&Globals.UnitId); data->PDO = PDO; data->ReadIrp = IoAllocateIrp (data->TopOfStack->StackSize, FALSE); // Initializiation happens automatically. if (NULL == data->ReadIrp) { IoDetachDevice (data->TopOfStack); IoDeleteDevice (device); return STATUS_INSUFFICIENT_RESOURCES; } KeInitializeEvent (&data->ReadCompleteEvent, SynchronizationEvent, FALSE); KeInitializeEvent (&data->ReadSentEvent, NotificationEvent, TRUE); IoInitializeRemoveLock (&data->RemoveLock, MOUHID_POOL_TAG, 1, 10); data->ReadFile = NULL; ExInitializeFastMutex (&data->CreateCloseMutex); data->InputData.UnitId = data->UnitId; // // Initialize the mouse attributes. // data->Attributes.MouseIdentifier = MOUSE_HID_HARDWARE; data->Attributes.SampleRate = 0; data->Attributes.InputDataQueueLength = 2; // // Find device specific parameters for this hid mouse device. // if (NT_SUCCESS (status)) { status = IoOpenDeviceRegistryKey (PDO, PLUGPLAY_REGKEY_DEVICE, STANDARD_RIGHTS_ALL, &devInstRegKey); data->FlipFlop = FALSE; if (NT_SUCCESS (status)) { status = MouHid_QueryDeviceKey (devInstRegKey, FLIP_FLOP_WHEEL, &tmp, sizeof (tmp)); if (NT_SUCCESS (status)) { data->FlipFlop = (BOOLEAN) tmp; } status = MouHid_QueryDeviceKey (devInstRegKey, SCALING_FACTOR_WHEEL, &tmp, sizeof (tmp)); if (NT_SUCCESS (status)) { data->WheelScalingFactor = (ULONG) tmp; } else { data->WheelScalingFactor = 120; } ZwClose (devInstRegKey); } status = STATUS_SUCCESS; } state.DeviceState = PowerDeviceD0; PoSetPowerState (device, DevicePowerState, state); data->WmiLibInfo.GuidCount = sizeof (MouHid_WmiGuidList) / sizeof (WMIGUIDREGINFO); ASSERT (1 == data->WmiLibInfo.GuidCount); data->WmiLibInfo.GuidList = MouHid_WmiGuidList; data->WmiLibInfo.QueryWmiRegInfo = MouHid_QueryWmiRegInfo; data->WmiLibInfo.QueryWmiDataBlock = MouHid_QueryWmiDataBlock; data->WmiLibInfo.SetWmiDataBlock = MouHid_SetWmiDataBlock; data->WmiLibInfo.SetWmiDataItem = MouHid_SetWmiDataItem; data->WmiLibInfo.ExecuteWmiMethod = NULL; data->WmiLibInfo.WmiFunctionControl = NULL; device->Flags |= DO_POWER_PAGABLE; device->Flags &= ~DO_DEVICE_INITIALIZING; return status; } NTSTATUS MouHid_StartDevice ( IN PDEVICE_EXTENSION Data ) /*++ Routine Description: Arguments: Return Value: NTSTATUS result code. --*/ { HIDP_CAPS caps; // the capabilities of the found hid device HID_COLLECTION_INFORMATION info; NTSTATUS status = STATUS_SUCCESS; PHIDP_PREPARSED_DATA preparsedData = NULL; PHID_EXTENSION hid = NULL; ULONG length, inputBufferLength, usageListLength; USHORT maxUsages; PCHAR buffer; USHORT slength; HIDP_VALUE_CAPS valueCaps; PAGED_CODE (); Print (DBG_PNP_TRACE, ("enter START Device \n")); // // Retrieve the capabilities of this hid device // IOCTL_HID_GET_COLLECTION_INFORMATION fills in HID_COLLECTION_INFORMATION. // we are interested in the Descriptor Size, which tells us how big a // buffer to allocate for the preparsed data. // if (!NT_SUCCESS (status = MouHid_CallHidClass ( Data, IOCTL_HID_GET_COLLECTION_INFORMATION, 0, 0, // no input &info, sizeof (info)))) { goto MouHid_StartDeviceReject; } // // Allocate memory to hold the preparsed data. // preparsedData = (PHIDP_PREPARSED_DATA) ExAllocatePool (NonPagedPool, info.DescriptorSize); if (!preparsedData) { status = STATUS_INSUFFICIENT_RESOURCES; goto MouHid_StartDeviceReject; } // // Retrieve that information. // if (!NT_SUCCESS (status = MouHid_CallHidClass ( Data, IOCTL_HID_GET_COLLECTION_DESCRIPTOR, 0, 0, // no input preparsedData, info.DescriptorSize))) { goto MouHid_StartDeviceReject; } // // Call the parser to determine the capabilites of this HID device. // if (!NT_SUCCESS (status = HidP_GetCaps (preparsedData, &caps))) { goto MouHid_StartDeviceReject; } // // Is this the thing we want? // // In this particular case we are looking for a keyboard. // if ( (HID_USAGE_PAGE_GENERIC == caps.UsagePage) && ( (HID_USAGE_GENERIC_MOUSE == caps.Usage) || ( (HID_USAGE_GENERIC_POINTER == caps.Usage) && (!Globals.UseOnlyMice)))) { ; } else { // // Someone made an INF blunder! // ASSERT ( (HID_USAGE_PAGE_GENERIC == caps.UsagePage) && ( (HID_USAGE_GENERIC_MOUSE == caps.Usage) || ( (HID_USAGE_GENERIC_POINTER == caps.Usage) && (!Globals.UseOnlyMice)))); status = STATUS_UNSUCCESSFUL; goto MouHid_StartDeviceReject; } // // Note: here we might also want to check the button and value capabilities // of the device as well. // // Then let's use it. // // // a buffer length to allow an Input buffer, output buffer, feature buffer, // and the total number of usages that can be returned from a read packet. // maxUsages = (USHORT) HidP_MaxUsageListLength (HidP_Input, HID_USAGE_PAGE_BUTTON, preparsedData); // // Create space in the device extension for the buffer storage when working // with this HID device. // // We need four buffers to hold the button codes (length returned from // HidP_MaxUsageListLength) this will hold the current list of usages, // the previous list of usages, the ``Make'' and the ``Break'' lists. // We also need a place to put the input, output, and feature report // buffers. // usageListLength = ALIGNPTRLEN(maxUsages * sizeof (USAGE)); inputBufferLength = ALIGNPTRLEN(caps.InputReportByteLength); length = (4 * usageListLength) + inputBufferLength + sizeof (HID_EXTENSION); Data->HidExtension = hid = ExAllocatePool (NonPagedPool, length); if (!hid) { status = STATUS_INSUFFICIENT_RESOURCES; goto MouHid_StartDeviceReject; } RtlZeroMemory (hid, length); // // Initialize the fields. // hid->Ppd = preparsedData; hid->Caps = caps; hid->MaxUsages = maxUsages; Data->Attributes.NumberOfButtons = (USHORT) maxUsages; hid->InputBuffer = buffer = hid->Buffer; hid->PreviousUsageList = (PUSAGE) (buffer += inputBufferLength); hid->CurrentUsageList = (PUSAGE) (buffer += usageListLength); hid->BreakUsageList = (PUSAGE) (buffer += usageListLength); hid->MakeUsageList = (PUSAGE) (buffer + usageListLength); // // Create the MDLs // HidClass uses direct IO so you need MDLs // hid->InputMdl = IoAllocateMdl (hid->InputBuffer, // The virtual address caps.InputReportByteLength, // length FALSE, // No associated IRP => not secondary FALSE, // No quota charge 0); // No associated IRP if (NULL == hid->InputMdl) { status = STATUS_INSUFFICIENT_RESOURCES; goto MouHid_StartDeviceReject; } MmBuildMdlForNonPagedPool (hid->InputMdl); // Build this MDL. // // Determine if X,Y,Z values are absolute or relative for this device. // Only check X axis (assume Y,Z are the same -- we have no choice but // to make this assumption since the MOUSE_INPUT_DATA structure does // not accomodate mixed absolute/relative position fields). // slength = 1; if (!NT_SUCCESS (status = HidP_GetSpecificValueCaps( HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_X, &valueCaps, &slength, preparsedData) ) ) { goto MouHid_StartDeviceReject; } ASSERT (1 == slength); if (valueCaps.IsAbsolute) { if ((HID_USAGE_GENERIC_POINTER == caps.Usage) && (Globals.TreatAbsolutePointerAsAbsolute)) { // // All pointers that declare themselfs as Absolute should be // treated as such, regardless of the TreatAbsoluteAsRelative flag // Data->InputData.Flags = MOUSE_MOVE_ABSOLUTE; hid->IsAbsolute = TRUE; } else if (Globals.TreatAbsoluteAsRelative) { // // Here we have overriden the HID descriptors absolute flag. // We will treat this as a relative device even though it claims // to be an absolute device. // Data->InputData.Flags = MOUSE_MOVE_RELATIVE; hid->IsAbsolute = FALSE; // // Report the problem with this mouse's report descriptor and // report it to the user. // Data->ProblemFlags |= PROBLEM_BAD_ABSOLUTE_FLAG_X_Y; MouHid_LogError(Data->Self->DriverObject, MOUHID_INVALID_ABSOLUTE_AXES, NULL); } else { // // No switches with which to play. Do what seems natural // Data->InputData.Flags = MOUSE_MOVE_ABSOLUTE; hid->IsAbsolute = TRUE; } } else { Data->InputData.Flags = MOUSE_MOVE_RELATIVE; hid->IsAbsolute = FALSE; } // // Determine X axis usage value's bit size. // hid->BitSize.X = valueCaps.BitSize; hid->MaxX = valueCaps.PhysicalMax; hid->MaxX = (hid->MaxX) ? (hid->MaxX) : ((1 << (hid->BitSize.X - 1)) - 1); // // Determine Y axis usage value's bit size. // slength = 1; if (!NT_SUCCESS (status = HidP_GetSpecificValueCaps( HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Y, &valueCaps, &slength, preparsedData) ) ) { goto MouHid_StartDeviceReject; } ASSERT (1 == slength); hid->BitSize.Y = valueCaps.BitSize; hid->MaxY = valueCaps.PhysicalMax; hid->MaxY = (hid->MaxY) ? (hid->MaxY) : ((1 << (hid->BitSize.Y - 1)) - 1); // // Initialize wheel usage not-detected flag to false (determined later). // hid->HasNoWheelUsage = FALSE; hid->HasNoZUsage = FALSE; // // Determine Z axis usage value's bit size (if this is a wheel mouse). // Note that a Z axis may not exist, so we handle this case differently. // slength = 1; if (NT_SUCCESS (HidP_GetSpecificValueCaps( HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_WHEEL, &valueCaps, &slength, preparsedData) ) && slength == 1) { hid->BitSize.Z = valueCaps.BitSize; Data->Attributes.MouseIdentifier = WHEELMOUSE_HID_HARDWARE; } else { // hid->HasNoWheelUsage = TRUE; slength = 1; if (NT_SUCCESS (HidP_GetSpecificValueCaps( HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Z, &valueCaps, &slength, preparsedData) ) && slength == 1) { hid->BitSize.Z = valueCaps.BitSize; Data->Attributes.MouseIdentifier = WHEELMOUSE_HID_HARDWARE; } else { // hid->HasNoZUsage = TRUE; hid->BitSize.Z = 0; } } // // We are done. Return peacefully. // return status; MouHid_StartDeviceReject: if (preparsedData) { // no need to set hid->Ppd to NULL becuase we will be freeing it as well ExFreePool (preparsedData); } if (hid) { if (hid->InputMdl) { IoFreeMdl (hid->InputMdl); } ExFreePool (hid); Data->HidExtension = NULL; } return status; } NTSTATUS MouHid_PnP ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: The plug and play dispatch routines. Most of these this filter driver will completely ignore. In all cases it must pass on the IRP to the lower driver. Arguments: DeviceObject - pointer to a device object. Irp - pointer to an I/O Request Packet. Return Value: NT status code --*/ { PDEVICE_EXTENSION data; PHID_EXTENSION hid; PIO_STACK_LOCATION stack; NTSTATUS status; ULONG i, j; LONG ioCount; PDEVICE_EXTENSION * classDataList; PAGED_CODE (); data = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension; stack = IoGetCurrentIrpStackLocation (Irp); hid = data->HidExtension; status = IoAcquireRemoveLock (&data->RemoveLock, Irp); if (!NT_SUCCESS (status)) { // // Someone gave us a pnp irp after a remove. Unthinkable! // ASSERT (FALSE); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = status; IoCompleteRequest (Irp, IO_NO_INCREMENT); return status; } Print(DBG_PNP_TRACE, ("PNP: Minor code = %x.", stack->MinorFunction)); switch (stack->MinorFunction) { case IRP_MN_START_DEVICE: if (data->Started) { Print(DBG_PNP_INFO, ("PNP: Device already started." )); status = STATUS_SUCCESS; Irp->IoStatus.Status = status; IoCompleteRequest (Irp, IO_NO_INCREMENT); break; } // // 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. // IoCopyCurrentIrpStackLocationToNext (Irp); KeInitializeEvent(&data->StartEvent, NotificationEvent, FALSE); IoSetCompletionRoutine (Irp, MouHid_PnPComplete, data, TRUE, TRUE, TRUE); // No need for Cancel Irp->IoStatus.Status = STATUS_SUCCESS; status = IoCallDriver (data->TopOfStack, Irp); if (STATUS_PENDING == status) { KeWaitForSingleObject( &data->StartEvent, Executive, // Waiting for reason of a driver KernelMode, // Waiting in kernel mode FALSE, // No allert NULL); // No timeout } if (NT_SUCCESS (status) && NT_SUCCESS (Irp->IoStatus.Status)) { // // As we are successfully now back from our start device // we can do work. // if (!data->Initialized) { status = MouHid_StartDevice (data); if (NT_SUCCESS (status)) { IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_REGISTER ); data->Started = TRUE; data->Initialized = TRUE; } } else { data->Started = TRUE; } } // // 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_STOP_DEVICE: // // After the start IRP has been sent to the lower driver object, the // bus may NOT send any more IRPS down ``touch'' until another START // has occured. // What ever access is required must be done before the Irp is passed // on. // if (data->Started) { // // Do what ever // } // // We don't need a completion routine so fire and forget. // // Set the current stack location to the next stack location and // call the next device object. // // // Stop Device touching the hardware MouStopDevice(data, TRUE); // data->Started = FALSE; Irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation (Irp); status = IoCallDriver (data->TopOfStack, Irp); break; case IRP_MN_REMOVE_DEVICE: // // The PlugPlay system has dictacted the removal of this device. We // have no choise but to detach and delete the device objecct. // (If we wanted to express and interest in preventing this removal, // we should have filtered the query remove and query stop routines.) // // Note! we might receive a remove WITHOUT first receiving a stop. // ASSERT (!usbData->Removed); Print (DBG_PNP_TRACE, ("enter RemoveDevice \n")); IoWMIRegistrationControl(data->Self, WMIREG_ACTION_DEREGISTER ); if (data->Started) { // Stop the device without touching the hardware. // MouStopDevice(data, FALSE); } // // Here if we had any outstanding requests in a personal queue we should // complete them all now. // // Note, the device could be GONE so we cannot send it any non- // PNP IRPS. // // // Cancel our read IRP. [DAN] // Note - waiting is only really necessary on 98, where pnp doesn't // make sure all handles are closed before sending the remove. // data->ShuttingDown = TRUE; KeWaitForSingleObject (&data->ReadSentEvent, Executive, KernelMode, FALSE, NULL ); IoCancelIrp(data->ReadIrp); // // Send on the remove IRP // Irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation (Irp); status = IoCallDriver (data->TopOfStack, Irp); // // Wait for the remove lock to free. // IoReleaseRemoveLockAndWait (&data->RemoveLock, Irp); // // Free the associated memory. // IoFreeIrp (data->ReadIrp); if (hid) { // // If we are removed without being started then we will have // no hid extension // ExFreePool (hid->Ppd); IoFreeMdl (hid->InputMdl); ExFreePool (hid); } IoDetachDevice (data->TopOfStack); IoDeleteDevice (data->Self); return status; case IRP_MN_SURPRISE_REMOVAL: case IRP_MN_QUERY_REMOVE_DEVICE: case IRP_MN_CANCEL_REMOVE_DEVICE: case IRP_MN_QUERY_STOP_DEVICE: case IRP_MN_CANCEL_STOP_DEVICE: // // These IRPs have to have their status changed from // STATUS_NOT_SUPPORTED b4 passing them down. // Irp->IoStatus.Status = STATUS_SUCCESS; case IRP_MN_QUERY_DEVICE_RELATIONS: case IRP_MN_QUERY_INTERFACE: case IRP_MN_QUERY_CAPABILITIES: 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: case IRP_MN_QUERY_PNP_DEVICE_STATE: default: // // Here the filter driver might modify the behavior of these IRPS // Please see PlugPlay documentation for use of these IRPs. // IoSkipCurrentIrpStackLocation (Irp); status = IoCallDriver (data->TopOfStack, Irp); break; } IoReleaseRemoveLock (&data->RemoveLock, Irp); return status; } NTSTATUS MouHid_PnPComplete ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context ) /*++ Routine Description: The pnp IRP is in the process of completing. signal Arguments: Context set to the device object in question. --*/ { PIO_STACK_LOCATION stack; PDEVICE_EXTENSION data; NTSTATUS status; UNREFERENCED_PARAMETER (DeviceObject); status = STATUS_SUCCESS; data = (PDEVICE_EXTENSION) Context; stack = IoGetCurrentIrpStackLocation (Irp); if (Irp->PendingReturned) { IoMarkIrpPending( Irp ); } switch (stack->MajorFunction) { case IRP_MJ_PNP: switch (stack->MinorFunction) { case IRP_MN_START_DEVICE: KeSetEvent (&data->StartEvent, 0, FALSE); // // Take the IRP back so that we can continue using it during // the IRP_MN_START_DEVICE dispatch routine. // NB: we will have to call IoCompleteRequest // return STATUS_MORE_PROCESSING_REQUIRED; default: break; } break; case IRP_MJ_POWER: default: break; } return status; } NTSTATUS MouHid_Power ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) { PIO_STACK_LOCATION stack; NTSTATUS status; PDEVICE_EXTENSION data; POWER_STATE powerState; POWER_STATE_TYPE powerType; Print(DBG_POWER_TRACE, ("Power Enter." )); data = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension; stack = IoGetCurrentIrpStackLocation (Irp); powerType = stack->Parameters.Power.Type; powerState = stack->Parameters.Power.State; status = IoAcquireRemoveLock (&data->RemoveLock, Irp); if (!NT_SUCCESS (status)) { PoStartNextPowerIrp (Irp); Irp->IoStatus.Status = status; IoCompleteRequest (Irp, IO_NO_INCREMENT); return status; } switch (stack->MinorFunction) { case IRP_MN_SET_POWER: Print(DBG_POWER_INFO, ("Power Setting %s state to %d\n", ((powerType == SystemPowerState) ? "System" : "Device"), powerState.SystemState)); break; case IRP_MN_QUERY_POWER: Print (DBG_POWER_INFO, ("Power query %s status to %d\n", ((powerType == SystemPowerState) ? "System" : "Device"), powerState.SystemState)); break; default: Print (DBG_POWER_ERROR, ("Power minor (0x%x) no known\n", stack->MinorFunction)); } PoStartNextPowerIrp (Irp); IoSkipCurrentIrpStackLocation (Irp); status = PoCallDriver (data->TopOfStack, Irp); IoReleaseRemoveLock (&data->RemoveLock, Irp); return status; }