ReactOS  0.4.15-dev-344-g6808e40
mouhid.c File Reference
#include "mouhid.h"
Include dependency graph for mouhid.c:

Go to the source code of this file.

Functions

VOID MouHid_GetButtonMove (IN PMOUHID_DEVICE_EXTENSION DeviceExtension, OUT PLONG LastX, OUT PLONG LastY)
 
VOID MouHid_GetButtonFlags (IN PMOUHID_DEVICE_EXTENSION DeviceExtension, OUT PUSHORT ButtonFlags, OUT PUSHORT Flags)
 
VOID MouHid_DispatchInputData (IN PMOUHID_DEVICE_EXTENSION DeviceExtension, IN PMOUSE_INPUT_DATA InputData)
 
NTSTATUS NTAPI MouHid_ReadCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
 
NTSTATUS MouHid_InitiateRead (IN PMOUHID_DEVICE_EXTENSION DeviceExtension)
 
NTSTATUS NTAPI MouHid_CreateCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
 
NTSTATUS NTAPI MouHid_Create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_Close (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_InternalDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_DeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_Power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_SystemControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS MouHid_SubmitRequest (PDEVICE_OBJECT DeviceObject, ULONG IoControlCode, ULONG InputBufferSize, PVOID InputBuffer, ULONG OutputBufferSize, PVOID OutputBuffer)
 
NTSTATUS NTAPI MouHid_StartDevice (IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS NTAPI MouHid_StartDeviceCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
 
NTSTATUS NTAPI MouHid_FreeResources (IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS NTAPI MouHid_Flush (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_Pnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI MouHid_AddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
 
VOID NTAPI MouHid_Unload (IN PDRIVER_OBJECT DriverObject)
 
NTSTATUS NTAPI DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegPath)
 

Variables

static USHORT MouHid_ButtonUpFlags []
 
static USHORT MouHid_ButtonDownFlags []
 

Function Documentation

◆ DriverEntry()

NTSTATUS NTAPI DriverEntry ( IN PDRIVER_OBJECT  DriverObject,
IN PUNICODE_STRING  RegPath 
)

Definition at line 1235 of file mouhid.c.

1238 {
1239  /* FIXME check for parameters 'UseOnlyMice', 'TreatAbsoluteAsRelative', 'TreatAbsolutePointerAsAbsolute' */
1240 
1241  /* initialize driver object */
1252 
1253  /* done */
1254  return STATUS_SUCCESS;
1255 }
NTSTATUS NTAPI MouHid_Power(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:693
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define IRP_MJ_FLUSH_BUFFERS
NTSTATUS NTAPI MouHid_Flush(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:1016
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
NTSTATUS NTAPI MouHid_DeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:675
VOID NTAPI MouHid_Unload(IN PDRIVER_OBJECT DriverObject)
Definition: mouhid.c:1226
NTSTATUS NTAPI MouHid_Create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:446
PDRIVER_EXTENSION DriverExtension
Definition: iotypes.h:2174
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
NTSTATUS NTAPI MouHid_Close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:522
NTSTATUS NTAPI MouHid_InternalDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:559
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
#define IRP_MJ_POWER
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
PDRIVER_UNLOAD DriverUnload
Definition: iotypes.h:2180
#define IRP_MJ_SYSTEM_CONTROL
PDRIVER_ADD_DEVICE AddDevice
Definition: iotypes.h:2112
NTSTATUS NTAPI MouHid_Pnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:1042
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: iotypes.h:2181
NTSTATUS NTAPI MouHid_AddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
Definition: mouhid.c:1162
return STATUS_SUCCESS
Definition: btrfs.c:3014
NTSTATUS NTAPI MouHid_SystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: mouhid.c:707
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52

◆ MouHid_AddDevice()

NTSTATUS NTAPI MouHid_AddDevice ( IN PDRIVER_OBJECT  DriverObject,
IN PDEVICE_OBJECT  PhysicalDeviceObject 
)

Definition at line 1162 of file mouhid.c.

1165 {
1166  NTSTATUS Status;
1168  PMOUHID_DEVICE_EXTENSION DeviceExtension;
1170 
1171  /* create device object */
1173  sizeof(MOUHID_DEVICE_EXTENSION),
1174  NULL,
1176  0,
1177  FALSE,
1178  &DeviceObject);
1179  if (!NT_SUCCESS(Status))
1180  {
1181  /* failed to create device object */
1182  return Status;
1183  }
1184 
1185  /* now attach it */
1187  if (!NextDeviceObject)
1188  {
1189  /* failed to attach */
1192  }
1193 
1194  /* get device extension */
1195  DeviceExtension = DeviceObject->DeviceExtension;
1196 
1197  /* zero extension */
1198  RtlZeroMemory(DeviceExtension, sizeof(MOUHID_DEVICE_EXTENSION));
1199 
1200  /* init device extension */
1201  DeviceExtension->MouseIdentifier = MOUSE_HID_HARDWARE;
1202  DeviceExtension->WheelUsagePage = 0;
1203  DeviceExtension->NextDeviceObject = NextDeviceObject;
1205  DeviceExtension->Irp = IoAllocateIrp(NextDeviceObject->StackSize, FALSE);
1206 
1207  /* FIXME handle allocation error */
1208  ASSERT(DeviceExtension->Irp);
1209 
1210  /* FIXME query parameter 'FlipFlopWheel', 'WheelScalingFactor' */
1211 
1212  /* set power state to D0 */
1213  State.DeviceState = PowerDeviceD0;
1215 
1216  /* init device object */
1219 
1220  /* completed successfully */
1221  return STATUS_SUCCESS;
1222 }
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define DO_POWER_PAGABLE
LONG NTSTATUS
Definition: precomp.h:26
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1155
KEVENT ReadCompletionEvent
Definition: mouhid.h:30
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
#define STATUS_DEVICE_NOT_CONNECTED
Definition: udferr_usr.h:160
USHORT MouseIdentifier
Definition: mouhid.h:45
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define DO_BUFFERED_IO
Definition: env_spec_w32.h:394
#define FILE_DEVICE_MOUSE
Definition: winioctl.h:120
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT * NextDeviceObject
Definition: ndis.h:4640
#define MOUSE_HID_HARDWARE
Definition: ntddmou.h:104
Status
Definition: gdiplustypes.h:24
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
enum State_ State
Definition: pofuncs.h:54
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
POWER_STATE NTAPI PoSetPowerState(IN PDEVICE_OBJECT DeviceObject, IN POWER_STATE_TYPE Type, IN POWER_STATE State)
Definition: power.c:708
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by DriverEntry().

◆ MouHid_Close()

NTSTATUS NTAPI MouHid_Close ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 522 of file mouhid.c.

525 {
526  PMOUHID_DEVICE_EXTENSION DeviceExtension;
527 
528  /* get device extension */
529  DeviceExtension = DeviceObject->DeviceExtension;
530 
531  DPRINT("[MOUHID] IRP_MJ_CLOSE ReadReportActive %x\n", DeviceExtension->ReadReportActive);
532 
533  if (DeviceExtension->ReadReportActive)
534  {
535  /* request stopping of the report cycle */
536  DeviceExtension->StopReadReport = TRUE;
537 
538  /* wait until the reports have been read */
540 
541  /* cancel irp */
542  IoCancelIrp(DeviceExtension->Irp);
543  }
544 
545  DPRINT("[MOUHID] IRP_MJ_CLOSE ReadReportActive %x\n", DeviceExtension->ReadReportActive);
546 
547  /* remove file object */
548  DeviceExtension->FileObject = NULL;
549 
550  /* skip location */
552 
553  /* pass irp to down the stack */
554  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
555 }
#define TRUE
Definition: types.h:120
_In_ PIRP Irp
Definition: csq.h:116
PFILE_OBJECT FileObject
Definition: mouhid.h:105
KEVENT ReadCompletionEvent
Definition: mouhid.h:30
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
BOOLEAN NTAPI IoCancelIrp(IN PIRP Irp)
Definition: irp.c:1101

Referenced by DriverEntry().

◆ MouHid_Create()

NTSTATUS NTAPI MouHid_Create ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 446 of file mouhid.c.

449 {
450  PIO_STACK_LOCATION IoStack;
452  KEVENT Event;
453  PMOUHID_DEVICE_EXTENSION DeviceExtension;
454 
455  DPRINT("MOUHID: IRP_MJ_CREATE\n");
456 
457  /* get device extension */
458  DeviceExtension = DeviceObject->DeviceExtension;
459 
460  /* get stack location */
462 
463  /* copy stack location to next */
465 
466  /* init event */
468 
469  /* prepare irp */
471 
472  /* call lower driver */
473  Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
474  if (Status == STATUS_PENDING)
475  {
476  /* request pending */
478  }
479 
480  /* check for success */
481  if (!NT_SUCCESS(Status))
482  {
483  /* failed */
484  Irp->IoStatus.Status = Status;
486  return Status;
487  }
488 
489  /* is the driver already in use */
490  if (DeviceExtension->FileObject == NULL)
491  {
492  /* did the caller specify correct attributes */
493  ASSERT(IoStack->Parameters.Create.SecurityContext);
494  if (IoStack->Parameters.Create.SecurityContext->DesiredAccess)
495  {
496  /* store file object */
497  DeviceExtension->FileObject = IoStack->FileObject;
498 
499  /* reset event */
500  KeClearEvent(&DeviceExtension->ReadCompletionEvent);
501 
502  /* initiating read */
503  Status = MouHid_InitiateRead(DeviceExtension);
504  DPRINT("[MOUHID] MouHid_InitiateRead: status %x\n", Status);
505  if (Status == STATUS_PENDING)
506  {
507  /* report irp is pending */
509  }
510  }
511  }
512 
513  /* complete request */
514  Irp->IoStatus.Status = Status;
516  return Status;
517 }
#define TRUE
Definition: types.h:120
_In_ PIRP Irp
Definition: csq.h:116
PFILE_OBJECT FileObject
Definition: mouhid.h:105
LONG NTSTATUS
Definition: precomp.h:26
KEVENT ReadCompletionEvent
Definition: mouhid.h:30
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:498
FORCEINLINE VOID IoCopyCurrentIrpStackLocationToNext(_Inout_ PIRP Irp)
Definition: iofuncs.h:2820
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:435
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
#define IoCompleteRequest
Definition: irp.c:1240
void DPRINT(...)
Definition: polytest.cpp:61
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Status
Definition: gdiplustypes.h:24
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS MouHid_InitiateRead(IN PMOUHID_DEVICE_EXTENSION DeviceExtension)
Definition: mouhid.c:397
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IO_NO_INCREMENT
Definition: iotypes.h:566
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
return STATUS_SUCCESS
Definition: btrfs.c:3014
HRESULT Create([out]ITransactionReceiver **ppReceiver)
NTSTATUS NTAPI MouHid_CreateCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: mouhid.c:434

Referenced by DriverEntry().

◆ MouHid_CreateCompletion()

NTSTATUS NTAPI MouHid_CreateCompletion ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Context 
)

Definition at line 434 of file mouhid.c.

438 {
439  KeSetEvent(Context, 0, FALSE);
441 }
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159

Referenced by MouHid_Create().

◆ MouHid_DeviceControl()

NTSTATUS NTAPI MouHid_DeviceControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 675 of file mouhid.c.

678 {
679  PMOUHID_DEVICE_EXTENSION DeviceExtension;
680 
681  /* get device extension */
682  DeviceExtension = DeviceObject->DeviceExtension;
683 
684  /* skip stack location */
686 
687  /* pass and forget */
688  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
689 }
_In_ PIRP Irp
Definition: csq.h:116
PVOID DeviceExtension
Definition: env_spec_w32.h:418
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421

Referenced by DriverEntry().

◆ MouHid_DispatchInputData()

VOID MouHid_DispatchInputData ( IN PMOUHID_DEVICE_EXTENSION  DeviceExtension,
IN PMOUSE_INPUT_DATA  InputData 
)

Definition at line 277 of file mouhid.c.

280 {
281  KIRQL OldIrql;
282  ULONG InputDataConsumed;
283 
284  if (!DeviceExtension->ClassService)
285  return;
286 
287  /* sanity check */
288  ASSERT(DeviceExtension->ClassService);
289  ASSERT(DeviceExtension->ClassDeviceObject);
290 
291  /* raise irql */
293 
294  /* dispatch input data */
295  (*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->ClassService)(DeviceExtension->ClassDeviceObject, InputData, InputData + 1, &InputDataConsumed);
296 
297  /* lower irql to previous level */
299 }
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
UCHAR KIRQL
Definition: env_spec_w32.h:591
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID(STDAPICALLTYPE * PSERVICE_CALLBACK_ROUTINE)(IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN OUT PVOID SystemArgument3)
Definition: kbdmou.h:86
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
unsigned int ULONG
Definition: retypes.h:1

Referenced by MouHid_ReadCompletion().

◆ MouHid_Flush()

NTSTATUS NTAPI MouHid_Flush ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 1016 of file mouhid.c.

1019 {
1020  PIO_STACK_LOCATION IoStack;
1021  PMOUHID_DEVICE_EXTENSION DeviceExtension;
1022 
1023  /* get device extension */
1024  DeviceExtension = DeviceObject->DeviceExtension;
1025 
1026  /* skip current stack location */
1028 
1029  /* get next stack location */
1030  IoStack = IoGetNextIrpStackLocation(Irp);
1031 
1032  /* change request to hid flush queue request */
1034  IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_HID_FLUSH_QUEUE;
1035 
1036  /* call device */
1037  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1038 }
_In_ PIRP Irp
Definition: csq.h:116
PVOID DeviceExtension
Definition: env_spec_w32.h:418
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2647
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
#define IOCTL_HID_FLUSH_QUEUE
Definition: hidclass.h:57
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52

Referenced by DriverEntry().

◆ MouHid_FreeResources()

NTSTATUS NTAPI MouHid_FreeResources ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 974 of file mouhid.c.

976 {
977  PMOUHID_DEVICE_EXTENSION DeviceExtension;
978 
979  /* get device extension */
980  DeviceExtension = DeviceObject->DeviceExtension;
981 
982  /* free resources */
983  if (DeviceExtension->PreparsedData)
984  {
985  ExFreePoolWithTag(DeviceExtension->PreparsedData, MOUHID_TAG);
986  DeviceExtension->PreparsedData = NULL;
987  }
988 
989  if (DeviceExtension->UsageListBuffer)
990  {
991  ExFreePoolWithTag(DeviceExtension->UsageListBuffer, MOUHID_TAG);
992  DeviceExtension->UsageListBuffer = NULL;
993  DeviceExtension->CurrentUsageList = NULL;
994  DeviceExtension->PreviousUsageList = NULL;
995  DeviceExtension->MakeUsageList = NULL;
996  DeviceExtension->BreakUsageList = NULL;
997  }
998 
999  if (DeviceExtension->ReportMDL)
1000  {
1001  IoFreeMdl(DeviceExtension->ReportMDL);
1002  DeviceExtension->ReportMDL = NULL;
1003  }
1004 
1005  if (DeviceExtension->Report)
1006  {
1007  ExFreePoolWithTag(DeviceExtension->Report, MOUHID_TAG);
1008  DeviceExtension->Report = NULL;
1009  }
1010 
1011  return STATUS_SUCCESS;
1012 }
PUSAGE PreviousUsageList
Definition: mouhid.h:70
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
#define MOUHID_TAG
Definition: mouhid.h:142
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
return STATUS_SUCCESS
Definition: btrfs.c:3014
PUSAGE CurrentUsageList
Definition: mouhid.h:65

Referenced by MouHid_Pnp().

◆ MouHid_GetButtonFlags()

VOID MouHid_GetButtonFlags ( IN PMOUHID_DEVICE_EXTENSION  DeviceExtension,
OUT PUSHORT  ButtonFlags,
OUT PUSHORT  Flags 
)

Definition at line 179 of file mouhid.c.

183 {
185  USAGE Usage;
186  ULONG Index;
187  PUSAGE TempList;
188  ULONG CurrentUsageListLength;
189 
190  /* init flags */
191  *ButtonFlags = 0;
192  *Flags = 0;
193 
194  /* get usages */
195  CurrentUsageListLength = DeviceExtension->UsageListLength;
199  DeviceExtension->CurrentUsageList,
200  &CurrentUsageListLength,
201  DeviceExtension->PreparsedData,
202  DeviceExtension->Report,
203  DeviceExtension->ReportLength);
205  {
206  DPRINT1("MouHid_GetButtonFlags failed to get usages with %x\n", Status);
207  return;
208  }
209 
210  /* extract usage list difference */
211  Status = HidP_UsageListDifference(DeviceExtension->PreviousUsageList,
212  DeviceExtension->CurrentUsageList,
213  DeviceExtension->BreakUsageList,
214  DeviceExtension->MakeUsageList,
215  DeviceExtension->UsageListLength);
217  {
218  DPRINT1("MouHid_GetButtonFlags failed to get usages with %x\n", Status);
219  return;
220  }
221 
222  if (DeviceExtension->UsageListLength)
223  {
224  Index = 0;
225  do
226  {
227  /* get usage */
228  Usage = DeviceExtension->BreakUsageList[Index];
229  if (!Usage)
230  break;
231 
232  if (Usage <= 5)
233  {
234  /* max 5 buttons supported */
235  *ButtonFlags |= MouHid_ButtonDownFlags[Usage];
236  }
237 
238  /* move to next index*/
239  Index++;
240  }while(Index < DeviceExtension->UsageListLength);
241  }
242 
243  if (DeviceExtension->UsageListLength)
244  {
245  Index = 0;
246  do
247  {
248  /* get usage */
249  Usage = DeviceExtension->MakeUsageList[Index];
250  if (!Usage)
251  break;
252 
253  if (Usage <= 5)
254  {
255  /* max 5 buttons supported */
256  *ButtonFlags |= MouHid_ButtonUpFlags[Usage];
257  }
258 
259  /* move to next index*/
260  Index++;
261  }while(Index < DeviceExtension->UsageListLength);
262  }
263 
264  /* now switch the previous list with current list */
265  TempList = DeviceExtension->CurrentUsageList;
266  DeviceExtension->CurrentUsageList = DeviceExtension->PreviousUsageList;
267  DeviceExtension->PreviousUsageList = TempList;
268 
269  if (DeviceExtension->MouseAbsolute)
270  {
271  // mouse operates absolute
273  }
274 }
static USHORT MouHid_ButtonDownFlags[]
Definition: mouhid.c:23
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
Definition: hidpi.h:382
LONG NTSTATUS
Definition: precomp.h:26
static USHORT MouHid_ButtonUpFlags[]
Definition: mouhid.c:13
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
HIDAPI NTSTATUS NTAPI HidP_UsageListDifference(IN PUSAGE PreviousUsageList, IN PUSAGE CurrentUsageList, OUT PUSAGE BreakUsageList, OUT PUSAGE MakeUsageList, IN ULONG UsageListLength)
Definition: hidp.c:190
USHORT * PUSAGE
Definition: hidusage.h:30
static const UCHAR Index[8]
Definition: usbohci.c:18
USHORT USAGE
Definition: hidusage.h:30
_Must_inspect_result_ HIDAPI NTSTATUS NTAPI HidP_GetUsages(_In_ HIDP_REPORT_TYPE ReportType, _In_ USAGE UsagePage, _In_ USHORT LinkCollection, _Out_writes_to_(*UsageLength, *UsageLength) USAGE *UsageList, _Inout_ ULONG *UsageLength, _In_ PHIDP_PREPARSED_DATA PreparsedData, _Out_writes_bytes_(ReportLength) PCHAR Report, _In_ ULONG ReportLength)
_Must_inspect_result_ _In_ ULONG UsageListLength
Definition: hidpi.h:647
Status
Definition: gdiplustypes.h:24
#define HIDP_LINK_COLLECTION_UNSPECIFIED
Definition: hidpi.h:185
#define HID_USAGE_PAGE_BUTTON
Definition: hidusage.h:183
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
#define HIDP_STATUS_SUCCESS
Definition: hidpi.h:248
#define MOUSE_MOVE_ABSOLUTE
Definition: ntddmou.h:68

Referenced by MouHid_ReadCompletion().

◆ MouHid_GetButtonMove()

VOID MouHid_GetButtonMove ( IN PMOUHID_DEVICE_EXTENSION  DeviceExtension,
OUT PLONG  LastX,
OUT PLONG  LastY 
)

Definition at line 35 of file mouhid.c.

39 {
41  ULONG ValueX, ValueY;
42 
43  /* init result */
44  *LastX = 0;
45  *LastY = 0;
46 
47  if (!DeviceExtension->MouseAbsolute)
48  {
49  /* get scaled usage value x */
54  LastX,
55  DeviceExtension->PreparsedData,
56  DeviceExtension->Report,
57  DeviceExtension->ReportLength);
58 
60  {
61  /* FIXME: handle more errors */
63  {
64  /* FIXME: assume it operates in absolute mode */
65  DeviceExtension->MouseAbsolute = TRUE;
66 
67  /* get unscaled value */
72  &ValueX,
73  DeviceExtension->PreparsedData,
74  DeviceExtension->Report,
75  DeviceExtension->ReportLength);
76 
77  /* FIXME handle error */
79 
80  /* absolute pointing devices values need be in range 0 - 0xffff */
81  ASSERT(DeviceExtension->ValueCapsX.LogicalMax > 0);
82  ASSERT(DeviceExtension->ValueCapsX.LogicalMax > DeviceExtension->ValueCapsX.LogicalMin);
83 
84  /* convert to logical range */
85  *LastX = (ValueX * VIRTUAL_SCREEN_SIZE_X) / DeviceExtension->ValueCapsX.LogicalMax;
86  }
87  }
88  }
89  else
90  {
91  /* get unscaled value */
96  &ValueX,
97  DeviceExtension->PreparsedData,
98  DeviceExtension->Report,
99  DeviceExtension->ReportLength);
100 
101  /* FIXME handle error */
103 
104  /* absolute pointing devices values need be in range 0 - 0xffff */
105  ASSERT(DeviceExtension->ValueCapsX.LogicalMax > 0);
106  ASSERT(DeviceExtension->ValueCapsX.LogicalMax > DeviceExtension->ValueCapsX.LogicalMin);
107 
108  /* convert to logical range */
109  *LastX = (ValueX * VIRTUAL_SCREEN_SIZE_X) / DeviceExtension->ValueCapsX.LogicalMax;
110  }
111 
112  if (!DeviceExtension->MouseAbsolute)
113  {
114  /* get scaled usage value y */
119  LastY,
120  DeviceExtension->PreparsedData,
121  DeviceExtension->Report,
122  DeviceExtension->ReportLength);
123 
125  {
126  // FIXME: handle more errors
128  {
129  // assume it operates in absolute mode
130  DeviceExtension->MouseAbsolute = TRUE;
131 
132  // get unscaled value
137  &ValueY,
138  DeviceExtension->PreparsedData,
139  DeviceExtension->Report,
140  DeviceExtension->ReportLength);
141 
142  /* FIXME handle error */
144 
145  /* absolute pointing devices values need be in range 0 - 0xffff */
146  ASSERT(DeviceExtension->ValueCapsY.LogicalMax > 0);
147  ASSERT(DeviceExtension->ValueCapsY.LogicalMax > DeviceExtension->ValueCapsY.LogicalMin);
148 
149  /* convert to logical range */
150  *LastY = (ValueY * VIRTUAL_SCREEN_SIZE_Y) / DeviceExtension->ValueCapsY.LogicalMax;
151  }
152  }
153  }
154  else
155  {
156  // get unscaled value
161  &ValueY,
162  DeviceExtension->PreparsedData,
163  DeviceExtension->Report,
164  DeviceExtension->ReportLength);
165 
166  /* FIXME handle error */
168 
169  /* absolute pointing devices values need be in range 0 - 0xffff */
170  ASSERT(DeviceExtension->ValueCapsY.LogicalMax > 0);
171  ASSERT(DeviceExtension->ValueCapsY.LogicalMax > DeviceExtension->ValueCapsY.LogicalMin);
172 
173  /* convert to logical range */
174  *LastY = (ValueY * VIRTUAL_SCREEN_SIZE_Y) / DeviceExtension->ValueCapsY.LogicalMax;
175  }
176 }
#define VIRTUAL_SCREEN_SIZE_X
Definition: mouhid.h:135
#define TRUE
Definition: types.h:120
_Must_inspect_result_ HIDAPI NTSTATUS NTAPI HidP_GetUsageValue(_In_ HIDP_REPORT_TYPE ReportType, _In_ USAGE UsagePage, _In_ USHORT LinkCollection, _In_ USAGE Usage, _Out_ PULONG UsageValue, _In_ PHIDP_PREPARSED_DATA PreparsedData, _In_reads_bytes_(ReportLength) PCHAR Report, _In_ ULONG ReportLength)
#define HIDP_STATUS_BAD_LOG_PHY_VALUES
Definition: hidpi.h:255
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ HIDAPI NTSTATUS NTAPI HidP_GetScaledUsageValue(_In_ HIDP_REPORT_TYPE ReportType, _In_ USAGE UsagePage, _In_ USHORT LinkCollection, _In_ USAGE Usage, _Out_ PLONG UsageValue, _In_ PHIDP_PREPARSED_DATA PreparsedData, _In_reads_bytes_(ReportLength) PCHAR Report, _In_ ULONG ReportLength)
#define VIRTUAL_SCREEN_SIZE_Y
Definition: mouhid.h:136
#define HID_USAGE_PAGE_GENERIC
Definition: hidusage.h:176
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define HID_USAGE_GENERIC_Y
Definition: hidusage.h:40
Status
Definition: gdiplustypes.h:24
#define HIDP_LINK_COLLECTION_UNSPECIFIED
Definition: hidpi.h:185
#define HID_USAGE_GENERIC_X
Definition: hidusage.h:39
unsigned int ULONG
Definition: retypes.h:1
#define HIDP_STATUS_SUCCESS
Definition: hidpi.h:248

Referenced by MouHid_ReadCompletion().

◆ MouHid_InitiateRead()

NTSTATUS MouHid_InitiateRead ( IN PMOUHID_DEVICE_EXTENSION  DeviceExtension)

Definition at line 397 of file mouhid.c.

399 {
400  PIO_STACK_LOCATION IoStack;
402 
403  /* re-use irp */
404  IoReuseIrp(DeviceExtension->Irp, STATUS_SUCCESS);
405 
406  /* init irp */
407  DeviceExtension->Irp->MdlAddress = DeviceExtension->ReportMDL;
408 
409  /* get next stack location */
410  IoStack = IoGetNextIrpStackLocation(DeviceExtension->Irp);
411 
412  /* init stack location */
413  IoStack->Parameters.Read.Length = DeviceExtension->ReportLength;
414  IoStack->Parameters.Read.Key = 0;
415  IoStack->Parameters.Read.ByteOffset.QuadPart = 0LL;
416  IoStack->MajorFunction = IRP_MJ_READ;
417  IoStack->FileObject = DeviceExtension->FileObject;
418 
419  /* set completion routine */
420  IoSetCompletionRoutine(DeviceExtension->Irp, MouHid_ReadCompletion, DeviceExtension, TRUE, TRUE, TRUE);
421 
422  /* read is active */
423  DeviceExtension->ReadReportActive = TRUE;
424 
425  /* start the read */
426  Status = IoCallDriver(DeviceExtension->NextDeviceObject, DeviceExtension->Irp);
427 
428  /* done */
429  return Status;
430 }
#define TRUE
Definition: types.h:120
#define LL
Definition: tui.h:84
VOID NTAPI IoReuseIrp(IN OUT PIRP Irp, IN NTSTATUS Status)
Definition: irp.c:1971
LONG NTSTATUS
Definition: precomp.h:26
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:498
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2647
Status
Definition: gdiplustypes.h:24
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
NTSTATUS NTAPI MouHid_ReadCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: mouhid.c:303
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IRP_MJ_READ
Definition: rdpdr.c:46
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by MouHid_Create(), and MouHid_ReadCompletion().

◆ MouHid_InternalDeviceControl()

NTSTATUS NTAPI MouHid_InternalDeviceControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 559 of file mouhid.c.

562 {
563  PIO_STACK_LOCATION IoStack;
565  PMOUHID_DEVICE_EXTENSION DeviceExtension;
567 
568  /* get current stack location */
570 
571  DPRINT("[MOUHID] InternalDeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
572 
573  /* get device extension */
574  DeviceExtension = DeviceObject->DeviceExtension;
575 
576  /* handle requests */
577  switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
578  {
580  /* verify output buffer length */
581  if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUSE_ATTRIBUTES))
582  {
583  /* invalid request */
584  DPRINT1("[MOUHID] IOCTL_MOUSE_QUERY_ATTRIBUTES Buffer too small\n");
585  Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
588  }
589 
590  /* get output buffer */
591  Attributes = Irp->AssociatedIrp.SystemBuffer;
592 
593  /* type of mouse */
594  Attributes->MouseIdentifier = DeviceExtension->MouseIdentifier;
595 
596  /* number of buttons */
597  Attributes->NumberOfButtons = DeviceExtension->UsageListLength;
598 
599  /* sample rate not used for usb */
600  Attributes->SampleRate = 0;
601 
602  /* queue length */
603  Attributes->InputDataQueueLength = 2;
604 
605  DPRINT("[MOUHID] MouseIdentifier %x\n", Attributes->MouseIdentifier);
606  DPRINT("[MOUHID] NumberOfButtons %x\n", Attributes->NumberOfButtons);
607  DPRINT("[MOUHID] SampleRate %x\n", Attributes->SampleRate);
608  DPRINT("[MOUHID] InputDataQueueLength %x\n", Attributes->InputDataQueueLength);
609 
610  /* complete request */
611  Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
612  Irp->IoStatus.Status = STATUS_SUCCESS;
614  return STATUS_SUCCESS;
615 
617  /* verify input buffer length */
618  if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(CONNECT_DATA))
619  {
620  /* invalid request */
621  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
624  }
625 
626  /* is it already connected */
627  if (DeviceExtension->ClassService)
628  {
629  /* already connected */
630  Irp->IoStatus.Status = STATUS_SHARING_VIOLATION;
633  }
634 
635  /* get connect data */
636  Data = IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
637 
638  /* store connect details */
639  DeviceExtension->ClassDeviceObject = Data->ClassDeviceObject;
640  DeviceExtension->ClassService = Data->ClassService;
641 
642  /* completed successfully */
643  Irp->IoStatus.Status = STATUS_SUCCESS;
645  return STATUS_SUCCESS;
646 
648  /* not supported */
649  Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
651  return STATUS_NOT_IMPLEMENTED;
652 
654  /* not supported */
655  Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
657  return STATUS_NOT_SUPPORTED;
658 
660  /* not supported */
661  Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
664  }
665 
666  DPRINT1("[MOUHID] Unknown DeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
667  /* unknown request not supported */
668  Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
670  return STATUS_NOT_SUPPORTED;
671 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
PDEVICE_OBJECT ClassDeviceObject
Definition: mouhid.h:35
#define IOCTL_INTERNAL_MOUSE_ENABLE
Definition: kbdmou.h:74
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_SHARING_VIOLATION
Definition: udferr_usr.h:154
PVOID DeviceExtension
Definition: env_spec_w32.h:418
USHORT UsageListLength
Definition: mouhid.h:60
_In_ LPGUID _In_ PVOID Data
Definition: classpnp.h:778
#define IoCompleteRequest
Definition: irp.c:1240
void DPRINT(...)
Definition: polytest.cpp:61
#define IOCTL_INTERNAL_MOUSE_DISABLE
Definition: kbdmou.h:77
USHORT MouseIdentifier
Definition: mouhid.h:45
#define IOCTL_INTERNAL_MOUSE_DISCONNECT
Definition: kbdmou.h:71
#define IOCTL_INTERNAL_MOUSE_CONNECT
Definition: kbdmou.h:68
#define IOCTL_MOUSE_QUERY_ATTRIBUTES
Definition: ntddmou.h:32
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
_Must_inspect_result_ _In_ USHORT _In_ PHIDP_PREPARSED_DATA _Out_writes_to_ LengthAttributes PHIDP_EXTENDED_ATTRIBUTES Attributes
Definition: hidpi.h:348
#define DPRINT1
Definition: precomp.h:8
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
#define IO_NO_INCREMENT
Definition: iotypes.h:566
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:3014
struct _MOUSE_ATTRIBUTES MOUSE_ATTRIBUTES

Referenced by DriverEntry().

◆ MouHid_Pnp()

NTSTATUS NTAPI MouHid_Pnp ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 1042 of file mouhid.c.

1045 {
1046  PIO_STACK_LOCATION IoStack;
1047  KEVENT Event;
1048  NTSTATUS Status;
1049  PMOUHID_DEVICE_EXTENSION DeviceExtension;
1050 
1051  /* get device extension */
1052  DeviceExtension = DeviceObject->DeviceExtension;
1053 
1054  /* get current irp stack */
1055  IoStack = IoGetCurrentIrpStackLocation(Irp);
1056  DPRINT("[MOUHID] IRP_MJ_PNP Request: %x\n", IoStack->MinorFunction);
1057 
1058  switch (IoStack->MinorFunction)
1059  {
1060  case IRP_MN_STOP_DEVICE:
1062  /* free resources */
1068  /* indicate success */
1069  Irp->IoStatus.Status = STATUS_SUCCESS;
1070 
1071  /* skip irp stack location */
1073 
1074  /* dispatch to lower device */
1075  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1076 
1077  case IRP_MN_REMOVE_DEVICE:
1078  /* FIXME synchronization */
1079 
1080  /* request stop */
1081  DeviceExtension->StopReadReport = TRUE;
1082 
1083  /* cancel irp */
1084  IoCancelIrp(DeviceExtension->Irp);
1085 
1086  /* free resources */
1088 
1089  /* indicate success */
1090  Irp->IoStatus.Status = STATUS_SUCCESS;
1091 
1092  /* skip irp stack location */
1094 
1095  /* dispatch to lower device */
1096  Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1097 
1098  /* wait for completion of stop event */
1100 
1101  /* free irp */
1102  IoFreeIrp(DeviceExtension->Irp);
1103 
1104  /* detach device */
1105  IoDetachDevice(DeviceExtension->NextDeviceObject);
1106 
1107  /* delete device */
1109 
1110  /* done */
1111  return Status;
1112 
1113  case IRP_MN_START_DEVICE:
1114  /* init event */
1116 
1117  /* copy stack location */
1119 
1120  /* set completion routine */
1122  Irp->IoStatus.Status = 0;
1123 
1124  /* pass request */
1125  Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1126  if (Status == STATUS_PENDING)
1127  {
1129  Status = Irp->IoStatus.Status;
1130  }
1131 
1132  if (!NT_SUCCESS(Status))
1133  {
1134  /* failed */
1135  Irp->IoStatus.Status = Status;
1137  return Status;
1138  }
1139 
1140  /* lets start the device */
1142  DPRINT("MouHid_StartDevice %x\n", Status);
1143 
1144  /* complete request */
1145  Irp->IoStatus.Status = Status;
1147 
1148  /* done */
1149  return Status;
1150 
1151  default:
1152  /* skip irp stack location */
1154 
1155  /* dispatch to lower device */
1156  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1157  }
1158 }
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define TRUE
Definition: types.h:120
#define IRP_MN_REMOVE_DEVICE
_In_ PIRP Irp
Definition: csq.h:116
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
KEVENT ReadCompletionEvent
Definition: mouhid.h:30
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:498
FORCEINLINE VOID IoCopyCurrentIrpStackLocationToNext(_Inout_ PIRP Irp)
Definition: iofuncs.h:2820
#define IRP_MN_QUERY_REMOVE_DEVICE
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:435
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
#define IoCompleteRequest
Definition: irp.c:1240
void DPRINT(...)
Definition: polytest.cpp:61
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
#define IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_SURPRISE_REMOVAL
Definition: ntifs_ex.h:408
#define IRP_MN_STOP_DEVICE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IRP_MN_START_DEVICE
NTSTATUS NTAPI MouHid_StartDeviceCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: mouhid.c:963
Status
Definition: gdiplustypes.h:24
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
BOOLEAN NTAPI IoCancelIrp(IN PIRP Irp)
Definition: irp.c:1101
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
#define IO_NO_INCREMENT
Definition: iotypes.h:566
#define IRP_MN_CANCEL_STOP_DEVICE
NTSTATUS NTAPI MouHid_StartDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: mouhid.c:770
return STATUS_SUCCESS
Definition: btrfs.c:3014
NTSTATUS NTAPI MouHid_FreeResources(IN PDEVICE_OBJECT DeviceObject)
Definition: mouhid.c:974

Referenced by DriverEntry().

◆ MouHid_Power()

NTSTATUS NTAPI MouHid_Power ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 693 of file mouhid.c.

696 {
697  PMOUHID_DEVICE_EXTENSION DeviceExtension;
698 
699  DeviceExtension = DeviceObject->DeviceExtension;
702  return PoCallDriver(DeviceExtension->NextDeviceObject, Irp);
703 }
_In_ PIRP Irp
Definition: csq.h:116
PVOID DeviceExtension
Definition: env_spec_w32.h:418
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
VOID NTAPI PoStartNextPowerIrp(IN PIRP Irp)
Definition: power.c:737
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421

Referenced by DriverEntry().

◆ MouHid_ReadCompletion()

NTSTATUS NTAPI MouHid_ReadCompletion ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Context 
)

Definition at line 303 of file mouhid.c.

307 {
308  PMOUHID_DEVICE_EXTENSION DeviceExtension;
309  USHORT ButtonFlags;
310  LONG UsageValue;
312  LONG LastX, LastY;
313  MOUSE_INPUT_DATA MouseInputData;
314  USHORT Flags;
315 
316  /* get device extension */
317  DeviceExtension = Context;
318 
319  if (Irp->IoStatus.Status == STATUS_PRIVILEGE_NOT_HELD ||
320  Irp->IoStatus.Status == STATUS_DEVICE_NOT_CONNECTED ||
321  Irp->IoStatus.Status == STATUS_CANCELLED ||
322  DeviceExtension->StopReadReport)
323  {
324  /* failed to read or should be stopped*/
325  DPRINT1("[MOUHID] ReadCompletion terminating read Status %x\n", Irp->IoStatus.Status);
326 
327  /* report no longer active */
328  DeviceExtension->ReadReportActive = FALSE;
329 
330  /* request stopping of the report cycle */
331  DeviceExtension->StopReadReport = FALSE;
332 
333  /* signal completion event */
334  KeSetEvent(&DeviceExtension->ReadCompletionEvent, 0, 0);
336  }
337 
338  /* get mouse change */
339  MouHid_GetButtonMove(DeviceExtension, &LastX, &LastY);
340 
341  /* get mouse change flags */
342  MouHid_GetButtonFlags(DeviceExtension, &ButtonFlags, &Flags);
343 
344  /* init input data */
345  RtlZeroMemory(&MouseInputData, sizeof(MOUSE_INPUT_DATA));
346 
347  /* init input data */
348  MouseInputData.ButtonFlags = ButtonFlags;
349  MouseInputData.Flags = Flags;
350  MouseInputData.LastX = LastX;
351  MouseInputData.LastY = LastY;
352 
353  /* detect mouse wheel change */
354  if (DeviceExtension->MouseIdentifier == WHEELMOUSE_HID_HARDWARE)
355  {
356  /* get usage */
357  UsageValue = 0;
362  &UsageValue,
363  DeviceExtension->PreparsedData,
364  DeviceExtension->Report,
365  DeviceExtension->ReportLength);
366  if (Status == HIDP_STATUS_SUCCESS && UsageValue != 0)
367  {
368  /* store wheel status */
369  MouseInputData.ButtonFlags |= MOUSE_WHEEL;
370  MouseInputData.ButtonData = (USHORT)(UsageValue * WHEEL_DELTA);
371  }
372  else
373  {
374  DPRINT("[MOUHID] failed to get wheel status with %x\n", Status);
375  }
376  }
377 
378  DPRINT("[MOUHID] ReportData %02x %02x %02x %02x %02x %02x %02x\n",
379  DeviceExtension->Report[0] & 0xFF,
380  DeviceExtension->Report[1] & 0xFF, DeviceExtension->Report[2] & 0xFF,
381  DeviceExtension->Report[3] & 0xFF, DeviceExtension->Report[4] & 0xFF,
382  DeviceExtension->Report[5] & 0xFF, DeviceExtension->Report[6] & 0xFF);
383 
384  DPRINT("[MOUHID] LastX %ld LastY %ld Flags %x ButtonFlags %x ButtonData %x\n", MouseInputData.LastX, MouseInputData.LastY, MouseInputData.Flags, MouseInputData.ButtonFlags, MouseInputData.ButtonData);
385 
386  /* dispatch mouse action */
387  MouHid_DispatchInputData(DeviceExtension, &MouseInputData);
388 
389  /* re-init read */
390  MouHid_InitiateRead(DeviceExtension);
391 
392  /* stop completion */
394 }
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
_In_ PIRP Irp
Definition: csq.h:116
VOID MouHid_DispatchInputData(IN PMOUHID_DEVICE_EXTENSION DeviceExtension, IN PMOUSE_INPUT_DATA InputData)
Definition: mouhid.c:277
#define WHEELMOUSE_HID_HARDWARE
Definition: ntddmou.h:105
#define MOUSE_WHEEL
Definition: ntddmou.h:56
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ HIDAPI NTSTATUS NTAPI HidP_GetScaledUsageValue(_In_ HIDP_REPORT_TYPE ReportType, _In_ USAGE UsagePage, _In_ USHORT LinkCollection, _In_ USAGE Usage, _Out_ PLONG UsageValue, _In_ PHIDP_PREPARSED_DATA PreparsedData, _In_reads_bytes_(ReportLength) PCHAR Report, _In_ ULONG ReportLength)
KEVENT ReadCompletionEvent
Definition: mouhid.h:30
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
USHORT Flags
Definition: ntddmou.h:78
#define WHEEL_DELTA
Definition: treelist.c:99
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
long LONG
Definition: pedump.c:60
void DPRINT(...)
Definition: polytest.cpp:61
#define STATUS_DEVICE_NOT_CONNECTED
Definition: udferr_usr.h:160
#define HID_USAGE_PAGE_GENERIC
Definition: hidusage.h:176
USHORT MouseIdentifier
Definition: mouhid.h:45
#define HID_USAGE_GENERIC_WHEEL
Definition: hidusage.h:47
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
USHORT ButtonData
Definition: ntddmou.h:83
USHORT ButtonFlags
Definition: ntddmou.h:82
Status
Definition: gdiplustypes.h:24
#define HIDP_LINK_COLLECTION_UNSPECIFIED
Definition: hidpi.h:185
VOID MouHid_GetButtonMove(IN PMOUHID_DEVICE_EXTENSION DeviceExtension, OUT PLONG LastX, OUT PLONG LastY)
Definition: mouhid.c:35
NTSTATUS MouHid_InitiateRead(IN PMOUHID_DEVICE_EXTENSION DeviceExtension)
Definition: mouhid.c:397
unsigned short USHORT
Definition: pedump.c:61
VOID MouHid_GetButtonFlags(IN PMOUHID_DEVICE_EXTENSION DeviceExtension, OUT PUSHORT ButtonFlags, OUT PUSHORT Flags)
Definition: mouhid.c:179
#define DPRINT1
Definition: precomp.h:8
struct tagContext Context
Definition: acpixf.h:1034
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define HIDP_STATUS_SUCCESS
Definition: hidpi.h:248

Referenced by MouHid_InitiateRead().

◆ MouHid_StartDevice()

NTSTATUS NTAPI MouHid_StartDevice ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 770 of file mouhid.c.

772 {
774  ULONG Buttons;
780  PMOUHID_DEVICE_EXTENSION DeviceExtension;
781  PUSAGE Buffer;
782 
783  /* get device extension */
784  DeviceExtension = DeviceObject->DeviceExtension;
785 
786  /* query collection information */
789  0,
790  NULL,
792  &Information);
793  if (!NT_SUCCESS(Status))
794  {
795  /* failed to query collection information */
796  DPRINT1("[MOUHID] failed to obtain collection information with %x\n", Status);
797  return Status;
798  }
799 
800  /* lets allocate space for preparsed data */
802  if (!PreparsedData)
803  {
804  /* no memory */
805  DPRINT1("[MOUHID] no memory size %u\n", Information.DescriptorSize);
807  }
808 
809  /* now obtain the preparsed data */
812  0,
813  NULL,
814  Information.DescriptorSize,
815  PreparsedData);
816  if (!NT_SUCCESS(Status))
817  {
818  /* failed to get preparsed data */
819  DPRINT1("[MOUHID] failed to obtain collection information with %x\n", Status);
821  return Status;
822  }
823 
824  /* lets get the caps */
827  {
828  /* failed to get capabilities */
829  DPRINT1("[MOUHID] failed to obtain caps with %x\n", Status);
831  return Status;
832  }
833 
834  DPRINT("[MOUHID] Usage %x UsagePage %x InputReportLength %lu\n", Capabilities.Usage, Capabilities.UsagePage, Capabilities.InputReportByteLength);
835 
836  /* verify capabilities */
838  {
839  /* not supported */
841  return STATUS_UNSUCCESSFUL;
842  }
843 
844  /* init input report */
846  ASSERT(DeviceExtension->ReportLength);
847  DeviceExtension->Report = ExAllocatePoolWithTag(NonPagedPool, DeviceExtension->ReportLength, MOUHID_TAG);
848  ASSERT(DeviceExtension->Report);
849  RtlZeroMemory(DeviceExtension->Report, DeviceExtension->ReportLength);
850 
851  /* build mdl */
852  DeviceExtension->ReportMDL = IoAllocateMdl(DeviceExtension->Report,
853  DeviceExtension->ReportLength,
854  FALSE,
855  FALSE,
856  NULL);
857  ASSERT(DeviceExtension->ReportMDL);
858 
859  /* init mdl */
860  MmBuildMdlForNonPagedPool(DeviceExtension->ReportMDL);
861 
862  /* get max number of buttons */
865  PreparsedData);
866  DPRINT("[MOUHID] Buttons %lu\n", Buttons);
867  ASSERT(Buttons > 0);
868 
869  /* now allocate an array for those buttons */
871  if (!Buffer)
872  {
873  /* no memory */
876  }
877  DeviceExtension->UsageListBuffer = Buffer;
878 
879  /* init usage lists */
880  RtlZeroMemory(Buffer, sizeof(USAGE) * 4 * Buttons);
881  DeviceExtension->CurrentUsageList = Buffer;
882  Buffer += Buttons;
883  DeviceExtension->PreviousUsageList = Buffer;
884  Buffer += Buttons;
885  DeviceExtension->MakeUsageList = Buffer;
886  Buffer += Buttons;
887  DeviceExtension->BreakUsageList = Buffer;
888 
889  /* store number of buttons */
890  DeviceExtension->UsageListLength = (USHORT)Buttons;
891 
892  /* store preparsed data */
893  DeviceExtension->PreparsedData = PreparsedData;
894 
895  ValueCapsLength = 1;
900  &DeviceExtension->ValueCapsX,
902  PreparsedData);
903 
904  ValueCapsLength = 1;
909  &DeviceExtension->ValueCapsY,
911  PreparsedData);
912 
913  /* now check for wheel mouse support */
914  ValueCapsLength = 1;
919  &ValueCaps,
921  PreparsedData);
922  if (Status == HIDP_STATUS_SUCCESS )
923  {
924  /* mouse has wheel support */
925  DeviceExtension->MouseIdentifier = WHEELMOUSE_HID_HARDWARE;
926  DeviceExtension->WheelUsagePage = ValueCaps.UsagePage;
927  DPRINT("[MOUHID] mouse wheel support detected\n", Status);
928  }
929  else
930  {
931  /* check if the mouse has z-axis */
932  ValueCapsLength = 1;
937  &ValueCaps,
939  PreparsedData);
941  {
942  /* wheel support */
943  DeviceExtension->MouseIdentifier = WHEELMOUSE_HID_HARDWARE;
944  DeviceExtension->WheelUsagePage = ValueCaps.UsagePage;
945  DPRINT("[MOUHID] mouse wheel support detected with z-axis\n", Status);
946  }
947  }
948 
949  /* check if mice is absolute */
950  if (DeviceExtension->ValueCapsY.IsAbsolute &&
951  DeviceExtension->ValueCapsX.IsAbsolute)
952  {
953  /* mice is absolute */
954  DeviceExtension->MouseAbsolute = TRUE;
955  }
956 
957  /* completed successfully */
958  return STATUS_SUCCESS;
959 }
#define TRUE
Definition: types.h:120
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _Out_writes_to_ DataLength PHIDP_DATA _Inout_ PULONG _In_ PHIDP_PREPARSED_DATA PreparsedData
Definition: hidpi.h:333
BOOLEAN IsAbsolute
Definition: hidpi.h:211
#define HID_USAGE_GENERIC_POINTER
Definition: hidusage.h:32
HIDAPI ULONG NTAPI HidP_MaxUsageListLength(IN HIDP_REPORT_TYPE ReportType, IN USAGE UsagePage OPTIONAL, IN PHIDP_PREPARSED_DATA PreparsedData)
Definition: hidp.c:99
HIDP_VALUE_CAPS ValueCapsY
Definition: mouhid.h:130
#define WHEELMOUSE_HID_HARDWARE
Definition: ntddmou.h:105
USAGE UsagePage
Definition: hidpi.h:201
VOID NTAPI MmBuildMdlForNonPagedPool(IN PMDL Mdl)
Definition: mdlsup.c:428
LONG NTSTATUS
Definition: precomp.h:26
PUSAGE PreviousUsageList
Definition: mouhid.h:70
#define HID_USAGE_GENERIC_MOUSE
Definition: hidusage.h:33
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE _Out_ PHIDP_VALUE_CAPS ValueCaps
Definition: hidpi.h:396
#define IOCTL_HID_GET_COLLECTION_DESCRIPTOR
Definition: hidclass.h:58
HIDAPI NTSTATUS NTAPI HidP_GetSpecificValueCaps(IN HIDP_REPORT_TYPE ReportType, IN USAGE UsagePage, IN USHORT LinkCollection, IN USAGE Usage, OUT PHIDP_VALUE_CAPS ValueCaps, IN OUT PUSHORT ValueCapsLength, IN PHIDP_PREPARSED_DATA PreparsedData)
Definition: hidp.c:126
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
USHORT UsageListLength
Definition: mouhid.h:60
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
HIDAPI NTSTATUS NTAPI HidP_GetCaps(IN PHIDP_PREPARSED_DATA PreparsedData, OUT PHIDP_CAPS Capabilities)
Definition: hidp.c:33
#define HID_USAGE_GENERIC_Z
Definition: hidusage.h:41
#define HID_USAGE_PAGE_GENERIC
Definition: hidusage.h:176
static const TBBUTTON Buttons[]
Definition: mplay32.c:41
USHORT * PUSAGE
Definition: hidusage.h:30
#define MOUHID_TAG
Definition: mouhid.h:142
USHORT MouseIdentifier
Definition: mouhid.h:45
USAGE UsagePage
Definition: hidpi.h:151
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define HID_USAGE_GENERIC_WHEEL
Definition: hidusage.h:47
USHORT USAGE
Definition: hidusage.h:30
#define IOCTL_HID_GET_COLLECTION_INFORMATION
Definition: hidclass.h:59
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define HID_USAGE_GENERIC_Y
Definition: hidusage.h:40
Status
Definition: gdiplustypes.h:24
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define HIDP_LINK_COLLECTION_UNSPECIFIED
Definition: hidpi.h:185
#define HID_USAGE_PAGE_BUTTON
Definition: hidusage.h:183
USAGE Usage
Definition: hidpi.h:150
unsigned short USHORT
Definition: pedump.c:61
#define HID_USAGE_GENERIC_X
Definition: hidusage.h:39
NTSTATUS MouHid_SubmitRequest(PDEVICE_OBJECT DeviceObject, ULONG IoControlCode, ULONG InputBufferSize, PVOID InputBuffer, ULONG OutputBufferSize, PVOID OutputBuffer)
Definition: mouhid.c:719
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define HIDP_STATUS_SUCCESS
Definition: hidpi.h:248
HIDP_VALUE_CAPS ValueCapsX
Definition: mouhid.h:125
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:3014
PUSAGE CurrentUsageList
Definition: mouhid.h:65
USHORT InputReportByteLength
Definition: hidpi.h:152
Iosb Information
Definition: create.c:4377
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE _Out_ PHIDP_VALUE_CAPS _Inout_ PUSHORT ValueCapsLength
Definition: hidpi.h:396

Referenced by MouHid_Pnp().

◆ MouHid_StartDeviceCompletion()

NTSTATUS NTAPI MouHid_StartDeviceCompletion ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Context 
)

Definition at line 963 of file mouhid.c.

967 {
968  KeSetEvent(Context, 0, FALSE);
970 }
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159

Referenced by MouHid_Pnp().

◆ MouHid_SubmitRequest()

NTSTATUS MouHid_SubmitRequest ( PDEVICE_OBJECT  DeviceObject,
ULONG  IoControlCode,
ULONG  InputBufferSize,
PVOID  InputBuffer,
ULONG  OutputBufferSize,
PVOID  OutputBuffer 
)

Definition at line 719 of file mouhid.c.

726 {
727  KEVENT Event;
728  PMOUHID_DEVICE_EXTENSION DeviceExtension;
729  PIRP Irp;
732 
733  /* get device extension */
734  DeviceExtension = DeviceObject->DeviceExtension;
735 
736  /* init event */
738 
739  /* build request */
741  DeviceExtension->NextDeviceObject,
742  InputBuffer,
743  InputBufferSize,
744  OutputBuffer,
745  OutputBufferSize,
746  FALSE,
747  &Event,
748  &IoStatus);
749  if (!Irp)
750  {
751  /* no memory */
753  }
754 
755  /* send request */
756  Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
757  if (Status == STATUS_PENDING)
758  {
759  /* wait for request to complete */
761  Status = IoStatus.Status;
762  }
763 
764  /* done */
765  return Status;
766 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG IoControlCode
Definition: fltkernel.h:1383
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
_In_ PIRP Irp
Definition: csq.h:116
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
CHAR InputBuffer[80]
Definition: conmgr.c:33
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:435
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
_Must_inspect_result_ __drv_aliasesMem _In_ PDEVICE_OBJECT _In_opt_ PVOID _In_ ULONG _Out_opt_ PVOID OutputBuffer
Definition: iofuncs.h:713
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
#define STATUS_PENDING
Definition: ntstatus.h:82
Status
Definition: gdiplustypes.h:24
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881

Referenced by MouHid_StartDevice().

◆ MouHid_SystemControl()

NTSTATUS NTAPI MouHid_SystemControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 707 of file mouhid.c.

710 {
711  PMOUHID_DEVICE_EXTENSION DeviceExtension;
712 
713  DeviceExtension = DeviceObject->DeviceExtension;
715  return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
716 }
_In_ PIRP Irp
Definition: csq.h:116
PVOID DeviceExtension
Definition: env_spec_w32.h:418
PDEVICE_OBJECT NextDeviceObject
Definition: mouhid.h:20
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421

Referenced by DriverEntry().

◆ MouHid_Unload()

VOID NTAPI MouHid_Unload ( IN PDRIVER_OBJECT  DriverObject)

Definition at line 1226 of file mouhid.c.

1228 {
1229  UNIMPLEMENTED;
1230 }
#define UNIMPLEMENTED
Definition: debug.h:115

Referenced by DriverEntry().

Variable Documentation

◆ MouHid_ButtonDownFlags

USHORT MouHid_ButtonDownFlags[]
static
Initial value:
=
{
0xFF,
}
#define MOUSE_BUTTON_4_UP
Definition: ntddmou.h:53
#define MOUSE_BUTTON_5_UP
Definition: ntddmou.h:55
#define MOUSE_LEFT_BUTTON_UP
Definition: ntddmou.h:47
#define MOUSE_MIDDLE_BUTTON_UP
Definition: ntddmou.h:51
#define MOUSE_RIGHT_BUTTON_UP
Definition: ntddmou.h:49

Definition at line 23 of file mouhid.c.

Referenced by MouHid_GetButtonFlags().

◆ MouHid_ButtonUpFlags

USHORT MouHid_ButtonUpFlags[]
static
Initial value:
=
{
0xFF,
}
#define MOUSE_MIDDLE_BUTTON_DOWN
Definition: ntddmou.h:50
#define MOUSE_LEFT_BUTTON_DOWN
Definition: ntddmou.h:46
#define MOUSE_BUTTON_4_DOWN
Definition: ntddmou.h:52
#define MOUSE_RIGHT_BUTTON_DOWN
Definition: ntddmou.h:48
#define MOUSE_BUTTON_5_DOWN
Definition: ntddmou.h:54

Definition at line 13 of file mouhid.c.

Referenced by MouHid_GetButtonFlags().