Не удается найти указаный файл при попытке запуска драйвера

#include <ntddk.h>
#include <wdf.h>
#define NTSTRSAFE_LIB
#include <ntstrsafe.h>
#include <initguid.h>
#include <wdmguid.h>
#include <ntddmou.h>
 
 
NTSTATUS DriverEntry(IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING RegistryPath);
NTSTATUS LaserPUAddDevice(IN PDRIVER_OBJECT DriverObject,IN PDEVICE_OBJECT PhysicalDeviceObject);
VOID LaserPUUnload(IN PDRIVER_OBJECT DriverObject);
NTSTATUS LaserPUDispatchPnp(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp);
NTSTATUS LaserPU_CompleteIRP(IN PDEVICE_OBJECT   DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS LaserPUDispatchPower(IN PDEVICE_OBJECT    DeviceObject, IN PIRP Irp);
NTSTATUS LaserPU_DispatchDeviceControl(IN PDEVICE_OBJECT   DeviceObject, IN PIRP  Irp);
NTSTATUS LaserPU_DispatchPassThrough(IN PDEVICE_OBJECT   DeviceObject, IN PIRP    Irp);
VOID
LaserPU_ServiceCallback(
    IN PDEVICE_OBJECT DeviceObject,
    IN PMOUSE_INPUT_DATA InputDataStart,
    IN PMOUSE_INPUT_DATA InputDataEnd,
    IN OUT PULONG InputDataConsumed
    )

#include "LaserPU.h"
 
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(PAGE, LaserPUAddDevice)
#pragma alloc_text(PAGE, LaserPUUnload)
#pragma alloc_text(PAGE, LaserPUDispatchPnp)
#pragma alloc_text(PAGE, LaserPUDispatchPower)
#endif
 
//------------------------------------------------------------------
// DriverEntry()
// Инициализация драйвера при установке
//------------------------------------------------------------------
NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath)
 
{
    USHORT              regPathLen;
    ULONG               ulIndex;
    PDRIVER_DISPATCH  * dispatch;
 
    KdPrint(("Entered the Driver Entry\n"));
 
    // Заполняю массив главных функций указателем на функцию,
    // пропускающую пакеты вниз по стеку.
    for (ulIndex = 0, dispatch = DriverObject->MajorFunction;
         ulIndex <= IRP_MJ_MAXIMUM_FUNCTION;
         ulIndex++, dispatch++) {
 
        *dispatch = LaserPU_DispatchPassThrough;
    }
 
    // Обновляю указатели на используемые объекты
    DriverObject->MajorFunction[IRP_MJ_PNP]                         = LaserPUDispatchPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER]                       = LaserPUDispatchPower;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL]     = LaserPU_DispatchDeviceControl;
    DriverObject->DriverExtension->AddDevice                        = LaserPUAddDevice;
    DriverObject->DriverUnload                                      = LaserPUUnload;
 
    return STATUS_SUCCESS;
}

/*++
 
Module Name:
 
    LaserPU.c
 
Abstract:
 
    Этот модуль содержит код драйвера-фильтра для LPU.
 
Environment:
 
    Kernel mode
 
Revision History:
 
    Валерий Петриев - Написан 20 ноября 2005 г.
 
    (На основе примера Firefly в DDK 2003)
 
--*/
 
 
#include "LaserPU.h"
 
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(PAGE, LaserPUAddDevice)
#pragma alloc_text(PAGE, LaserPUUnload)
#pragma alloc_text(PAGE, LaserPUDispatchPnp)
#pragma alloc_text(PAGE, LaserPUDispatchPower)
#endif
 
//------------------------------------------------------------------
// DriverEntry()
// Инициализация драйвера при установке
//------------------------------------------------------------------
NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath)
 
{
    USHORT              regPathLen;
    ULONG               ulIndex;
    PDRIVER_DISPATCH  * dispatch;
 
    DebugPrint(("Entered the Driver Entry\n"));
 
    // Заполняю массив главных функций указателем на функцию,
    // пропускающую пакеты вниз по стеку.
    for (ulIndex = 0, dispatch = DriverObject->MajorFunction;
         ulIndex <= IRP_MJ_MAXIMUM_FUNCTION;
         ulIndex++, dispatch++) {
 
        *dispatch = LaserPU_DispatchPassThrough;
    }
 
    // Обновляю указатели на используемые объекты
    DriverObject->MajorFunction[IRP_MJ_PNP]                         = LaserPUDispatchPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER]                       = LaserPUDispatchPower;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL]     = LaserPU_DispatchDeviceControl;
    DriverObject->DriverExtension->AddDevice                        = LaserPUAddDevice;
    DriverObject->DriverUnload                                      = LaserPUUnload;
 
    return STATUS_SUCCESS;
}
 
//------------------------------------------------------------------
// LaserPU_AddDevice()
// Добавление драйвера в стек драйверов мыши
//------------------------------------------------------------------
NTSTATUS
LaserPUAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject)
 
{
    NTSTATUS                status;
    PDEVICE_OBJECT          deviceObject;
    PDEVICE_EXTENSION       deviceExtension = NULL;
 
    PAGED_CODE();
    
    // Создаем объект-фильтр устройства. 
    status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),
        NULL,                       // No Name
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        &deviceObject
        );
 
    if (!NT_SUCCESS(status)) {
 
        //
        // Returning failure here prevents the entire stack from functioning,
        // but most likely the rest of the stack will not be able to create
        // device objects either, so it is still OK.
        //
        return status;
    }
 
    DebugPrint((
        "AddDevice PDO (0x%x) FDO (0x%x)\n",
        PhysicalDeviceObject,
        deviceObject
        ));
 
    // Получаем указатель на расширение нашего устройства.
    deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
 
    // Сохраняю для дальнейшего использования.
    deviceExtension->Self = deviceObject;
    deviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
 
    // Создаем объект устройства, находящегося в данный момент на вершине стека;
    // Сохраняем указатель на него и подключаем фильтр к вершине стека.
    deviceExtension->NextLowerDriver = IoAttachDeviceToDeviceStack(
        deviceObject,
        PhysicalDeviceObject
        );
 
    // Если не подсоединился - проблема в PnP, удалить объект устройства
    if (NULL == deviceExtension->NextLowerDriver) {
        IoDeleteDevice(deviceObject);
        return STATUS_UNSUCCESSFUL;
    }
 
    // Копирование флагов устройства из устройства ниже по стеку.
    deviceObject->Flags |= deviceExtension->NextLowerDriver->Flags &
                            (DO_BUFFERED_IO | DO_DIRECT_IO |
                            DO_POWER_PAGABLE  | DO_POWER_INRUSH);
 
    deviceObject->DeviceType = deviceExtension->NextLowerDriver->DeviceType;
 
    deviceObject->Characteristics =
                          deviceExtension->NextLowerDriver->Characteristics;
 
    // Инициализирование состояния устройства.   
    INITIALIZE_PNP_STATE(deviceExtension);
 
 
    IoInitializeRemoveLock (&deviceExtension->RemoveLock , 
                            POOL_TAG,
                            1, // MaxLockedMinutes 
                            5); // HighWatermark, this parameter is 
                                // used only on checked build.
                                
    DebugPrint((
        "AddDevice: %x to %x->%x \n",
        deviceObject,
        deviceExtension->NextLowerDriver,
        PhysicalDeviceObject
        ));
 
    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return STATUS_SUCCESS;
}
 
 
//---------------------------------------------------------------------
// LaserPU_Unload()
// Выгрузка драйвера
//---------------------------------------------------------------------
VOID
LaserPUUnload(
    IN PDRIVER_OBJECT DriverObject
    )
 
{
    PAGED_CODE();
 
    ASSERT(DriverObject->DeviceObject == NULL);
 
    DebugPrint(("unload\n"));
 
    return;
}
 
 
//-------------------------------------------------------------------
// LaserPU_DispatchPnp()
// Обработка PnP пакетов. Мы обрабатываем PnP пакеты, чтобы вовремя отсоединиться
//-------------------------------------------------------------------
NTSTATUS
LaserPUDispatchPnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp)
 
{
    PDEVICE_EXTENSION           deviceExtension;
    PIO_STACK_LOCATION          irpStack, nextStack;
    NTSTATUS                    status;
    KEVENT                      event;
 
    PAGED_CODE();
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    // Получить ячейку стека для нашего драйвера.
    irpStack = IoGetCurrentIrpStackLocation(Irp);
 
   status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
    // Просмотр доп. функции в пакете.
    switch(irpStack->MinorFunction) {
 
    case IRP_MN_START_DEVICE:
 
        // Драйвер стартует.
        // Нельзя работать с драйвером, пока пакет не обработается 
        // всеми драйверами стека.
        KeInitializeEvent(&event,
                          NotificationEvent,
                          FALSE
                          );
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        IoSetCompletionRoutine(
            Irp,
            LaserPU_CompleteIRP,
            &event,
            TRUE,
            TRUE,
            TRUE
            );
 
        status = IoCallDriver(deviceExtension->NextLowerDriver, Irp);
 
        if (STATUS_PENDING == status) {
 
            KeWaitForSingleObject(
               &event,
               Executive, // Waiting for reason of a driver
               KernelMode, // Waiting in kernel mode
               FALSE, // No alert
               NULL // No timeout
               );
 
            status = Irp->IoStatus.Status;
        }
 
        if (NT_SUCCESS(status)) {
            
            // Устройство стартовало.
            SET_NEW_PNP_STATE(deviceExtension, Started);
        }
 
        //
        // We must now complete the IRP, since we stopped it in the
        // completion routine with STATUS_MORE_PROCESSING_REQUIRED.
        //
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
        return status;
 
    case IRP_MN_REMOVE_DEVICE:
 
        SET_NEW_PNP_STATE(deviceExtension, Deleted);
 
        //
        // Wait for all outstanding requests to complete
        //
        DebugPrint(("Waiting for outstanding requests\n"));
        IoReleaseRemoveLockAndWait(&deviceExtension->RemoveLock, Irp);
        
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->NextLowerDriver, Irp);
 
        IoDetachDevice(deviceExtension->NextLowerDriver);
        IoDeleteDevice(DeviceObject);
        return status;
 
    case IRP_MN_QUERY_STOP_DEVICE:
        SET_NEW_PNP_STATE(deviceExtension, StopPending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_CANCEL_STOP_DEVICE:
 
        //
        // Check to see whether you have received cancel-stop
        // without first receiving a query-stop. This could happen if someone
        // above us fails a query-stop and passes down the subsequent
        // cancel-stop.
        //
 
        if(StopPending == deviceExtension->DevicePnPState)
        {
            //
            // We did receive a query-stop, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
        }
        status = STATUS_SUCCESS; // We must not fail this IRP.
        break;
 
    case IRP_MN_STOP_DEVICE:
        SET_NEW_PNP_STATE(deviceExtension, StopPending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_QUERY_REMOVE_DEVICE:
 
        SET_NEW_PNP_STATE(deviceExtension, RemovePending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_SURPRISE_REMOVAL:
 
        SET_NEW_PNP_STATE(deviceExtension, SurpriseRemovePending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_CANCEL_REMOVE_DEVICE:
 
        //
        // Check to see whether you have received cancel-remove
        // without first receiving a query-remove. This could happen if
        // someone above us fails a query-remove and passes down the
        // subsequent cancel-remove.
        //
        if (RemovePending == deviceExtension->DevicePnPState) {
 
            //
            // We did receive a query-remove, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
        }
 
        status = STATUS_SUCCESS; // We must not fail this IRP.
        break;
 
    default:
 
        //
        // If you don't handle any IRP you must leave the
        // status as is.
        //
        status = Irp->IoStatus.Status;
        break;
    }
 
    //
    // Pass the IRP down and forget it.
    //
    Irp->IoStatus.Status = status;
    IoSkipCurrentIrpStackLocation (Irp);
    status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
    return status;
}
 
//---------------------------------------------------------------------
// LaserPU_CompleteIRP()
// Позволяет драйверу посылать IRP вниз по стеку, отлавливать их на обратном пути
// (используется в LaserPU_DispatchPnp)
//---------------------------------------------------------------------
NTSTATUS
LaserPU_CompleteIRP(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context)
 
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    //
    // We could switch on the major and minor functions of the IRP to perform
    // different functions, but we know that Context is an event that needs
    // to be set.
    //
    KeSetEvent((PKEVENT) Context, IO_NO_INCREMENT, FALSE);
 
    //
    // Allows the caller to use the IRP after it is completed
    //
    return STATUS_MORE_PROCESSING_REQUIRED;
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchPower()
// Управление энергопотреблением
//---------------------------------------------------------------------
NTSTATUS
LaserPUDispatchPower(
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp)
 
{
    PDEVICE_EXTENSION deviceExtension;
    NTSTATUS status;
    
    PAGED_CODE();
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) { // may be device is being removed.
        Irp->IoStatus.Status = status;
        PoStartNextPowerIrp(Irp);
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
 
    PoStartNextPowerIrp(Irp);
 
    IoSkipCurrentIrpStackLocation(Irp);
    status =  PoCallDriver(deviceExtension->NextLowerDriver, Irp);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
    return status;
    
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchPassThrough()
// Функция, пропускающая пакеты, которые мы не обрабатываем
//---------------------------------------------------------------------
NTSTATUS
LaserPU_DispatchPassThrough(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp)
 
{
    PDEVICE_EXTENSION deviceExtension;
    NTSTATUS status;
    
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
   IoSkipCurrentIrpStackLocation (Irp);
   status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
   IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
   return status;
   
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchDeviceControl()
// В данной функции подсоединяемся к очереди пакетов Mouclass для их фильтрации
// Для этого регистрируется сервис возврата LaserPU_ServiceCallback
//---------------------------------------------------------------------
NTSTATUS
LaserPU_DispatchDeviceControl(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{
    PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    PCONNECT_DATA               connectData;
    NTSTATUS                    status;
 
    DebugPrint(( "Wot i sluchilos DispatchDeviceControl\n"));
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    Irp->IoStatus.Information = 0;
    irpStack = IoGetCurrentIrpStackLocation(Irp);
        
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
 
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
    // Подключение классового драйвера к драйверу порта
    if (irpStack->Parameters.DeviceIoControl.IoControlCode ==
                        IOCTL_INTERNAL_MOUSE_CONNECT) {
 
        // Допустимо только одно подключение
        if (deviceExtension->UpperConnectData.ClassService != NULL) {
            return STATUS_SHARING_VIOLATION;
        }
        
        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                        sizeof(CONNECT_DATA)) {
        
        // Недопустимый буфер
            return STATUS_INVALID_PARAMETER;
        }
        
        // Копируем параметры в расширение устройства
        connectData = ((PCONNECT_DATA)
            (irpStack->Parameters.DeviceIoControl.Type3InputBuffer));
 
        deviceExtension->UpperConnectData = *connectData;
 
        // Подключаюсь к очереди пакетов.
        // Как только появится пакет, адресованный системе - 
        // вызов LaserPU_ServiceCallback
        connectData->ClassDeviceObject = deviceExtension->Self;
        connectData->ClassService = LaserPU_ServiceCallback;
    }
 
    if (irpStack->Parameters.DeviceIoControl.IoControlCode == 
                        IOCTL_INTERNAL_MOUSE_DISCONNECT) {
 
        // Очистка параметров соединения в расширении устройства
        deviceExtension->UpperConnectData.ClassDeviceObject = NULL;
        deviceExtension->UpperConnectData.ClassService = NULL;
 
        status = STATUS_NOT_IMPLEMENTED;
        }
            
   IoSkipCurrentIrpStackLocation (Irp);
   status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
   IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
   return status;
}
 
 
//---------------------------------------------------------------------
// LaserPU_ServiceCallback()
// В данную функцию собственно передается управление при возникновении
// события от мыши. Передачу управления производит менеджер ввода\вывода
// когда Mouclass заполнит внутреннюю очередь пакетов.
//---------------------------------------------------------------------
VOID
LaserPU_ServiceCallback(
    IN PDEVICE_OBJECT DeviceObject,
    IN PMOUSE_INPUT_DATA InputDataStart,
    IN PMOUSE_INPUT_DATA InputDataEnd,
    IN OUT PULONG InputDataConsumed
    )
 
{
    PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    PCONNECT_DATA               connectData;
    PMOUSE_INPUT_DATA           MouseInputData;
    NTSTATUS                    status;
    
    int num;
    int i;
 
    DebugPrint(( "Entered LaserPU_ServiceCallback\n"));
        
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    //
    // UpperConnectData must be called at DISPATCH
    //
 
    for (MouseInputData = InputDataStart;
         MouseInputData < InputDataEnd;
         MouseInputData++) 
    {
 
        MouseInputData->LastX = 0x0;
        MouseInputData->LastY = 0x0;
 
        // обработка нажатия левой и правой кнопок мыши
        // если левая кнопка - текст вниз, правая - текст вверх
        // в противном случае - очистка событий
        
        if (MouseInputData->ButtonFlags == MOUSE_LEFT_BUTTON_DOWN)
                {
                MouseInputData->ButtonFlags = 0x400;                
                MouseInputData -> ButtonData  = 0x78;   
                DebugPrint(( "LB\n"));
                }
            else if (InputDataStart->ButtonFlags == MOUSE_RIGHT_BUTTON_DOWN)
                {
                MouseInputData->ButtonFlags = 0x400;                
                MouseInputData -> ButtonData  = 0xff88; 
                DebugPrint(( "RB\n"));
                }
            else
                {
                MouseInputData->ButtonFlags = 0x0;
                }
    }
 
 
    (*(PSERVICE_CALLBACK_ROUTINE) deviceExtension->UpperConnectData.ClassService)(
        deviceExtension->UpperConnectData.ClassDeviceObject,
        InputDataStart,
        InputDataEnd,
        InputDataConsumed
        );
    return;
}

NTSTATUS CtlDispatch(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
    PIO_STACK_LOCATION pIrpStack;
    PUSHORT pIOBuffer; 
 
    USHORT Port;
    USHORT ValueToPort;
 
    pIrpStack=IoGetCurrentIrpStackLocation(Irp);
    pIOBuffer=Irp->AssociatedIrp.SystemBuffer;               
 
    switch (pIrpStack->Parameters.DeviceIoControl.IoControlCode)
    {
 
        case IOCTL_READ:
            Port=pIOBuffer[0];
            pIOBuffer[0]=READ_PORT_UCHAR((PUCHAR)Port);
            Irp->IoStatus.Information=2;
            break; 
 
        case IOCTL_WRITE:
            Port=pIOBuffer[0];
            ValueToPort=pIOBuffer[1];
            WRITE_PORT_USHORT((PUSHORT)Port,(USHORT)ValueToPort);
            Irp->IoStatus.Information=0;
            break;
 
    }
 
   //IoSkipCurrentIrpStackLocation (Irp); - в стеке вроде как и нет этого пакета, это не нужно?
   status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
   //IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);  - вот это же мне точно не нужно? это ведь только мой пакет...
   return status;
 
}

if (Irp->PendingReturned)
{
    IoMarkIrpPending(Irp);
}

typedef
VOID
(_stdcall * PFN_MOUCLS_CB)(
    __in    DEVICE_OBJECT     * /* pDeviceObj         */,
    __in    MOUSE_INPUT_DATA  * /* pInputDataStart    */,
    __in    MOUSE_INPUT_DATA  * /* pInputDataEnd      */,
    __inout ULONG             * /* pInputDataConsumed */
    );
 
PFN_MOUCLS_CB MouclassSvcCallback = pDeviceExt->OriginalSvcCallback;
MouClassSvcCallback(pDeviceObj, pInDataFrom, pInDataTo, &nItemsConsumed);