precomp.h File Reference

#include <wdm.h>
#include <hidpddi.h>
#include <stdio.h>
#include <hidport.h>

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	HIDCLASS_DRIVER_EXTENSION
struct	HIDCLASS_COMMON_DEVICE_EXTENSION
struct	HIDCLASS_FDO_EXTENSION
struct	HIDCLASS_PDO_DEVICE_EXTENSION
struct	__HIDCLASS_FILEOP_CONTEXT__
struct	HIDCLASS_IRP_CONTEXT

Macros
#define	_HIDPI_NO_FUNCTION_MACROS_
#define	HIDCLASS_TAG   'CdiH'

Typedefs
typedef struct HIDCLASS_DRIVER_EXTENSION *	PHIDCLASS_DRIVER_EXTENSION
typedef struct HIDCLASS_COMMON_DEVICE_EXTENSION *	PHIDCLASS_COMMON_DEVICE_EXTENSION
typedef struct HIDCLASS_FDO_EXTENSION *	PHIDCLASS_FDO_EXTENSION
typedef struct HIDCLASS_PDO_DEVICE_EXTENSION *	PHIDCLASS_PDO_DEVICE_EXTENSION
typedef struct __HIDCLASS_FILEOP_CONTEXT__	HIDCLASS_FILEOP_CONTEXT
typedef struct __HIDCLASS_FILEOP_CONTEXT__ *	PHIDCLASS_FILEOP_CONTEXT
typedef struct HIDCLASS_IRP_CONTEXT *	PHIDCLASS_IRP_CONTEXT

Functions
NTSTATUS	HidClassFDO_PnP (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	HidClassFDO_DispatchRequest (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	HidClassFDO_DispatchRequestSynchronous (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	HidClassPDO_CreatePDO (IN PDEVICE_OBJECT DeviceObject, OUT PDEVICE_RELATIONS *OutDeviceRelations)
NTSTATUS	HidClassPDO_PnP (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
PHIDP_COLLECTION_DESC	HidClassPDO_GetCollectionDescription (PHIDP_DEVICE_DESC DeviceDescription, ULONG CollectionNumber)
PHIDP_REPORT_IDS	HidClassPDO_GetReportDescription (PHIDP_DEVICE_DESC DeviceDescription, ULONG CollectionNumber)
PHIDP_REPORT_IDS	HidClassPDO_GetReportDescriptionByReportID (PHIDP_DEVICE_DESC DeviceDescription, UCHAR ReportID)

Macro Definition Documentation

_HIDPI_NO_FUNCTION_MACROS_

#define _HIDPI_NO_FUNCTION_MACROS_

Definition at line 4 of file precomp.h.

HIDCLASS_TAG

#define HIDCLASS_TAG   'CdiH'

Definition at line 10 of file precomp.h.

Typedef Documentation

HIDCLASS_FILEOP_CONTEXT

typedef struct __HIDCLASS_FILEOP_CONTEXT__ HIDCLASS_FILEOP_CONTEXT

PHIDCLASS_COMMON_DEVICE_EXTENSION

typedef struct HIDCLASS_COMMON_DEVICE_EXTENSION * PHIDCLASS_COMMON_DEVICE_EXTENSION

PHIDCLASS_DRIVER_EXTENSION

typedef struct HIDCLASS_DRIVER_EXTENSION * PHIDCLASS_DRIVER_EXTENSION

PHIDCLASS_FDO_EXTENSION

typedef struct HIDCLASS_FDO_EXTENSION * PHIDCLASS_FDO_EXTENSION

PHIDCLASS_FILEOP_CONTEXT

typedef struct __HIDCLASS_FILEOP_CONTEXT__ * PHIDCLASS_FILEOP_CONTEXT

PHIDCLASS_IRP_CONTEXT

typedef struct HIDCLASS_IRP_CONTEXT * PHIDCLASS_IRP_CONTEXT

PHIDCLASS_PDO_DEVICE_EXTENSION

typedef struct HIDCLASS_PDO_DEVICE_EXTENSION * PHIDCLASS_PDO_DEVICE_EXTENSION

Function Documentation

HidClassFDO_DispatchRequest()

NTSTATUS HidClassFDO_DispatchRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 217 of file fdo.c.

{
    PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
 
    //
    // get device extension
    //
    CommonDeviceExtension = DeviceObject->DeviceExtension;
 
    ASSERT(Irp->CurrentLocation > 0);
 
    //
    // create stack location
    //
    IoSetNextIrpStackLocation(Irp);
 
    //
    // get next stack location
    //
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    //
    // store device object
    //
    IoStack->DeviceObject = DeviceObject;
 
    //
    // sanity check
    //
    ASSERT(CommonDeviceExtension->DriverExtension->MajorFunction[IoStack->MajorFunction] != NULL);
 
    //
    // call driver
    //
    Status = CommonDeviceExtension->DriverExtension->MajorFunction[IoStack->MajorFunction](DeviceObject, Irp);
 
    //
    // done
    //
    return Status;
}

Referenced by HidClass_Power(), and HidClassFDO_PnP().

HidClassFDO_DispatchRequestSynchronous()

NTSTATUS HidClassFDO_DispatchRequestSynchronous	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 147 of file fdo.c.

{
    KEVENT Event;
    PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
 
    //
    // init event
    //
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    //
    // get device extension
    //
    CommonDeviceExtension = DeviceObject->DeviceExtension;
 
    //
    // set completion routine
    //
    IoSetCompletionRoutine(Irp, HidClassFDO_DispatchRequestSynchronousCompletion, &Event, TRUE, TRUE, TRUE);
 
    ASSERT(Irp->CurrentLocation > 0);
    //
    // create stack location
    //
    IoSetNextIrpStackLocation(Irp);
 
    //
    // get next stack location
    //
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    //
    // store device object
    //
    IoStack->DeviceObject = DeviceObject;
 
    //
    // sanity check
    //
    ASSERT(CommonDeviceExtension->DriverExtension->MajorFunction[IoStack->MajorFunction] != NULL);
 
    //
    // call minidriver (hidusb)
    //
    Status = CommonDeviceExtension->DriverExtension->MajorFunction[IoStack->MajorFunction](DeviceObject, Irp);
 
    //
    // wait for the request to finish
    //
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 
        //
        // update status
        //
        Status = Irp->IoStatus.Status;
    }
 
    //
    // done
    //
    return Status;
}

Referenced by HidClassFDO_GetDescriptors(), HidClassFDO_RemoveDevice(), HidClassFDO_StartDevice(), HidClassPDO_HandleQueryDeviceId(), and HidClassPDO_HandleQueryHardwareId().

HidClassFDO_PnP()

NTSTATUS HidClassFDO_PnP	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 631 of file fdo.c.

{
    PIO_STACK_LOCATION IoStack;
    PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
    NTSTATUS Status;
 
    //
    // get device extension
    //
    FDODeviceExtension = DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    //
    // get current irp stack location
    //
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    switch (IoStack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
             return HidClassFDO_StartDevice(DeviceObject, Irp);
        }
        case IRP_MN_REMOVE_DEVICE:
        {
             return HidClassFDO_RemoveDevice(DeviceObject, Irp);
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
             return HidClassFDO_DeviceRelations(DeviceObject, Irp);
        }
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        {
            //
            // set status to success and fall through
            //
            Irp->IoStatus.Status = STATUS_SUCCESS;
        }
        default:
        {
            //
            // dispatch to mini driver
            //
           IoCopyCurrentIrpStackLocationToNext(Irp);
           Status = HidClassFDO_DispatchRequest(DeviceObject, Irp);
           return Status;
        }
    }
}

Referenced by HidClass_PnP().

HidClassPDO_CreatePDO()

NTSTATUS HidClassPDO_CreatePDO	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PDEVICE_RELATIONS *	OutDeviceRelations
	)

Definition at line 668 of file pdo.c.

{
    PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
    NTSTATUS Status = STATUS_SUCCESS;
    PDEVICE_OBJECT PDODeviceObject;
    PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
    ULONG Index;
    PDEVICE_RELATIONS DeviceRelations;
    ULONG Length;
 
    //
    // get device extension
    //
    FDODeviceExtension = DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    //
    // first allocate device relations
    //
    Length = FIELD_OFFSET(DEVICE_RELATIONS, Objects) + sizeof(PDEVICE_OBJECT) * FDODeviceExtension->Common.DeviceDescription.CollectionDescLength;
    DeviceRelations = ExAllocatePoolWithTag(PagedPool, Length, HIDCLASS_TAG);
    if (!DeviceRelations)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // zero device relations
    //
    RtlZeroMemory(DeviceRelations, Length);
 
    //
    // let's create a PDO for top level collection
    //
    Index = 0;
    while (Index < FDODeviceExtension->Common.DeviceDescription.CollectionDescLength)
    {
        //
        // let's create the device object
        //
        Status = IoCreateDevice(FDODeviceExtension->Common.DriverExtension->DriverObject,
                                sizeof(HIDCLASS_PDO_DEVICE_EXTENSION),
                                NULL,
                                FILE_DEVICE_UNKNOWN,
                                FILE_AUTOGENERATED_DEVICE_NAME,
                                FALSE,
                                &PDODeviceObject);
        if (!NT_SUCCESS(Status))
        {
            //
            // failed to create device
            //
            DPRINT1("[HIDCLASS] Failed to create PDO %x\n", Status);
            break;
        }
 
        //
        // patch stack size
        //
        PDODeviceObject->StackSize = DeviceObject->StackSize + 1;
 
        //
        // get device extension
        //
        PDODeviceExtension = PDODeviceObject->DeviceExtension;
 
        //
        // init device extension
        //
        PDODeviceExtension->Common.HidDeviceExtension.MiniDeviceExtension = FDODeviceExtension->Common.HidDeviceExtension.MiniDeviceExtension;
        PDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject = FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject;
        PDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject = FDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject;
        PDODeviceExtension->Common.IsFDO = FALSE;
        PDODeviceExtension->FDODeviceExtension = FDODeviceExtension;
        PDODeviceExtension->FDODeviceObject = DeviceObject;
        PDODeviceExtension->Common.DriverExtension = FDODeviceExtension->Common.DriverExtension;
        PDODeviceExtension->CollectionNumber = FDODeviceExtension->Common.DeviceDescription.CollectionDesc[Index].CollectionNumber;
 
        //
        // copy device data
        //
        RtlCopyMemory(&PDODeviceExtension->Common.Attributes, &FDODeviceExtension->Common.Attributes, sizeof(HID_DEVICE_ATTRIBUTES));
        RtlCopyMemory(&PDODeviceExtension->Common.DeviceDescription, &FDODeviceExtension->Common.DeviceDescription, sizeof(HIDP_DEVICE_DESC));
        RtlCopyMemory(&PDODeviceExtension->Capabilities, &FDODeviceExtension->Capabilities, sizeof(DEVICE_CAPABILITIES));
 
        //
        // set device flags
        //
        PDODeviceObject->Flags |= DO_MAP_IO_BUFFER;
 
        //
        // device is initialized
        //
        PDODeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
        //
        // store device object in device relations
        //
        DeviceRelations->Objects[Index] = PDODeviceObject;
        DeviceRelations->Count++;
 
        //
        // move to next
        //
        Index++;
 
    }
 
 
    //
    // check if creating succeeded
    //
    if (!NT_SUCCESS(Status))
    {
        //
        // failed
        //
        for (Index = 0; Index < DeviceRelations->Count; Index++)
        {
            //
            // delete device
            //
            IoDeleteDevice(DeviceRelations->Objects[Index]);
        }
 
        //
        // free device relations
        //
        ExFreePoolWithTag(DeviceRelations, HIDCLASS_TAG);
        return Status;
    }
 
    //
    // store device relations
    //
    *OutDeviceRelations = DeviceRelations;
 
    //
    // done
    //
    return STATUS_SUCCESS;
}

Referenced by HidClassFDO_DeviceRelations().

HidClassPDO_GetCollectionDescription()

PHIDP_COLLECTION_DESC HidClassPDO_GetCollectionDescription	(	PHIDP_DEVICE_DESC	DeviceDescription,
		ULONG	CollectionNumber
	)

Definition at line 19 of file pdo.c.

{
    ULONG Index;
 
    for(Index = 0; Index < DeviceDescription->CollectionDescLength; Index++)
    {
        if (DeviceDescription->CollectionDesc[Index].CollectionNumber == CollectionNumber)
        {
            //
            // found collection
            //
            return &DeviceDescription->CollectionDesc[Index];
        }
    }
 
    //
    // failed to find collection
    //
    DPRINT1("[HIDCLASS] GetCollectionDescription CollectionNumber %x not found\n", CollectionNumber);
    ASSERT(FALSE);
    return NULL;
}

Referenced by HidClass_BuildIrp(), HidClass_DeviceControl(), HidClass_ReadCompleteIrp(), and HidClassPDO_HandleQueryHardwareId().

HidClassPDO_GetReportDescription()

PHIDP_REPORT_IDS HidClassPDO_GetReportDescription	(	PHIDP_DEVICE_DESC	DeviceDescription,
		ULONG	CollectionNumber
	)

Definition at line 45 of file pdo.c.

{
    ULONG Index;
 
    for (Index = 0; Index < DeviceDescription->ReportIDsLength; Index++)
    {
        if (DeviceDescription->ReportIDs[Index].CollectionNumber == CollectionNumber)
        {
            //
            // found collection
            //
            return &DeviceDescription->ReportIDs[Index];
        }
    }
 
    //
    // failed to find collection
    //
    DPRINT1("[HIDCLASS] GetReportDescription CollectionNumber %x not found\n", CollectionNumber);
    ASSERT(FALSE);
    return NULL;
}

Referenced by HidClass_BuildIrp(), and HidClass_ReadCompleteIrp().

HidClassPDO_GetReportDescriptionByReportID()

PHIDP_REPORT_IDS HidClassPDO_GetReportDescriptionByReportID	(	PHIDP_DEVICE_DESC	DeviceDescription,
		UCHAR	ReportID
	)

Definition at line 71 of file pdo.c.

{
    ULONG Index;
 
    for (Index = 0; Index < DeviceDescription->ReportIDsLength; Index++)
    {
        if (DeviceDescription->ReportIDs[Index].ReportID == ReportID)
        {
            //
            // found report id
            //
            return &DeviceDescription->ReportIDs[Index];
        }
    }
 
    //
    // failed to find report id
    //
    DPRINT1("[HIDCLASS] GetReportDescriptionByReportID ReportID %x not found\n", ReportID);
    ASSERT(FALSE);
    return NULL;
}

Referenced by HidClass_DeviceControl().

HidClassPDO_PnP()

NTSTATUS HidClassPDO_PnP	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 379 of file pdo.c.

{
    PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PPNP_BUS_INFORMATION BusInformation;
    PDEVICE_RELATIONS DeviceRelation;
    ULONG Index, bFound;
 
    //
    // get device extension
    //
    PDODeviceExtension = DeviceObject->DeviceExtension;
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    //
    // get current irp stack location
    //
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    //
    // handle request
    //
    switch (IoStack->MinorFunction)
    {
        case IRP_MN_QUERY_ID:
        {
            if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
            {
                //
                // handle query device id
                //
                Status = HidClassPDO_HandleQueryDeviceId(DeviceObject, Irp);
                break;
            }
            else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
            {
                //
                // handle instance id
                //
                Status = HidClassPDO_HandleQueryHardwareId(DeviceObject, Irp);
                break;
            }
            else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
            {
                //
                // handle instance id
                //
                Status = HidClassPDO_HandleQueryInstanceId(DeviceObject, Irp);
                break;
            }
            else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
            {
                //
                // handle instance id
                //
                Status = HidClassPDO_HandleQueryCompatibleId(DeviceObject, Irp);
                break;
            }
 
            DPRINT1("[HIDCLASS]: IRP_MN_QUERY_ID IdType %x unimplemented\n", IoStack->Parameters.QueryId.IdType);
            Status = STATUS_NOT_SUPPORTED;
            Irp->IoStatus.Information = 0;
            break;
        }
        case IRP_MN_QUERY_CAPABILITIES:
        {
            if (IoStack->Parameters.DeviceCapabilities.Capabilities == NULL)
            {
                //
                // invalid request
                //
                Status = STATUS_DEVICE_CONFIGURATION_ERROR;
                break;
            }
 
            //
            // copy capabilities
            //
            RtlCopyMemory(IoStack->Parameters.DeviceCapabilities.Capabilities,
                          &PDODeviceExtension->Capabilities,
                          sizeof(DEVICE_CAPABILITIES));
 
            //
            // override some capabilities
            //
            IoStack->Parameters.DeviceCapabilities.Capabilities->Removable = FALSE;
            IoStack->Parameters.DeviceCapabilities.Capabilities->SilentInstall = TRUE;
            IoStack->Parameters.DeviceCapabilities.Capabilities->SurpriseRemovalOK = TRUE;
 
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_BUS_INFORMATION:
        {
            //
            //
            //
            BusInformation = ExAllocatePoolWithTag(NonPagedPool, sizeof(PNP_BUS_INFORMATION), HIDCLASS_TAG);
 
            //
            // fill in result
            //
            RtlCopyMemory(&BusInformation->BusTypeGuid, &GUID_BUS_TYPE_HID, sizeof(GUID));
            BusInformation->LegacyBusType = PNPBus;
            BusInformation->BusNumber = 0; //FIXME
 
            //
            // store result
            //
            Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
        {
            //
            // FIXME set flags when driver fails / disabled
            //
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            //
            // only target relations are supported
            //
            if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
            {
                //
                // not supported
                //
                Status = Irp->IoStatus.Status;
                break;
            }
 
            //
            // allocate device relations
            //
            DeviceRelation = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_RELATIONS), HIDCLASS_TAG);
            if (!DeviceRelation)
            {
                //
                // no memory
                //
                Status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            //
            // init device relation
            //
            DeviceRelation->Count = 1;
            DeviceRelation->Objects[0] = DeviceObject;
            ObReferenceObject(DeviceRelation->Objects[0]);
 
            //
            // store result
            //
            Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_START_DEVICE:
        {
            //
            // FIXME: support polled devices
            //
            ASSERT(PDODeviceExtension->Common.DriverExtension->DevicesArePolled == FALSE);
 
            //
            // now register the device interface
            //
            Status = IoRegisterDeviceInterface(PDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject,
                                               &GUID_DEVINTERFACE_HID,
                                               NULL,
                                               &PDODeviceExtension->DeviceInterface);
            DPRINT("[HIDCLASS] IoRegisterDeviceInterfaceState Status %x\n", Status);
            if (NT_SUCCESS(Status))
            {
                //
                // enable device interface
                //
                Status = IoSetDeviceInterfaceState(&PDODeviceExtension->DeviceInterface, TRUE);
                DPRINT("[HIDCLASS] IoSetDeviceInterFaceState %x\n", Status);
            }
 
            //
            // done
            //
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_REMOVE_DEVICE:
        {
            /* Disable the device interface */
            if (PDODeviceExtension->DeviceInterface.Length != 0)
                IoSetDeviceInterfaceState(&PDODeviceExtension->DeviceInterface, FALSE);
 
            //
            // remove us from the fdo's pdo list
            //
            bFound = FALSE;
            for (Index = 0; Index < PDODeviceExtension->FDODeviceExtension->DeviceRelations->Count; Index++)
            {
                if (PDODeviceExtension->FDODeviceExtension->DeviceRelations->Objects[Index] == DeviceObject)
                {
                    //
                    // remove us
                    //
                    bFound = TRUE;
                    PDODeviceExtension->FDODeviceExtension->DeviceRelations->Objects[Index] = NULL;
                    break;
                }
            }
 
            /* Complete the IRP */
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
            if (bFound)
            {
                /* Delete our device object*/
                IoDeleteDevice(DeviceObject);
            }
 
            return STATUS_SUCCESS;
        }
        case IRP_MN_QUERY_INTERFACE:
        {
            DPRINT1("[HIDCLASS] PDO IRP_MN_QUERY_INTERFACE not implemented\n");
 
            //
            // do nothing
            //
            Status = Irp->IoStatus.Status;
            break;
        }
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        {
            //
            // no/op
            //
#if 0
            Status = STATUS_SUCCESS;
#else
            DPRINT1("Denying removal of HID device due to IRP cancellation bugs\n");
            Status = STATUS_UNSUCCESSFUL;
#endif
            break;
        }
        default:
        {
            //
            // do nothing
            //
            Status = Irp->IoStatus.Status;
            break;
        }
    }
 
    //
    // complete request
    //
    if (Status != STATUS_PENDING)
    {
        //
        // store result
        //
        Irp->IoStatus.Status = Status;
 
        //
        // complete request
        //
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    //
    // done processing
    //
    return Status;
}

Referenced by HidClass_PnP().