huwcampbell.com
Reactos
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Mouse class driver
4 * FILE: drivers/mouclass/mouclass.c
5 * PURPOSE: Mouse class driver
6 *
7 * PROGRAMMERS: Hervé Poussineau (hpoussin@reactos.org)
8 */
9
10#include "mouclass.h"
11
12#include <stdio.h>
13#include <kbdmou.h>
14#include <pseh/pseh2.h>
15#include <debug.h>
16
17static DRIVER_UNLOAD DriverUnload;
18static DRIVER_DISPATCH ClassCreate;
19static DRIVER_DISPATCH ClassClose;
20static DRIVER_DISPATCH ClassCleanup;
21static DRIVER_DISPATCH ClassRead;
22static DRIVER_DISPATCH ClassDeviceControl;
23static DRIVER_DISPATCH ClassPower;
24static DRIVER_ADD_DEVICE ClassAddDevice;
25static DRIVER_STARTIO ClassStartIo;
26static DRIVER_CANCEL ClassCancelRoutine;
27static NTSTATUS
28HandleReadIrp(
29 IN PDEVICE_OBJECT DeviceObject,
30 IN PIRP Irp,
31 BOOLEAN IsInStartIo);
32
33static VOID NTAPI
34DriverUnload(IN PDRIVER_OBJECT DriverObject)
35{
36 // nothing to do here yet
37}
38
39static NTSTATUS NTAPI
40ClassCreate(
41 IN PDEVICE_OBJECT DeviceObject,
42 IN PIRP Irp)
43{
44 TRACE_(CLASS_NAME, "IRP_MJ_CREATE\n");
45
46 if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
47 return ForwardIrpAndForget(DeviceObject, Irp);
48
49 /* FIXME: open all associated Port devices */
50 Irp->IoStatus.Status = STATUS_SUCCESS;
51 Irp->IoStatus.Information = 0;
52 IoCompleteRequest(Irp, IO_NO_INCREMENT);
53 return STATUS_SUCCESS;
54}
55
56static NTSTATUS NTAPI
57ClassClose(
58 IN PDEVICE_OBJECT DeviceObject,
59 IN PIRP Irp)
60{
61 TRACE_(CLASS_NAME, "IRP_MJ_CLOSE\n");
62
63 if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
64 return ForwardIrpAndForget(DeviceObject, Irp);
65
66 /* FIXME: close all associated Port devices */
67 Irp->IoStatus.Status = STATUS_SUCCESS;
68 Irp->IoStatus.Information = 0;
69 IoCompleteRequest(Irp, IO_NO_INCREMENT);
70 return STATUS_SUCCESS;
71}
72
73static NTSTATUS NTAPI
74ClassCleanup(
75 IN PDEVICE_OBJECT DeviceObject,
76 IN PIRP Irp)
77{
78 TRACE_(CLASS_NAME, "IRP_MJ_CLEANUP\n");
79
80 if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
81 return ForwardIrpAndForget(DeviceObject, Irp);
82
83 /* FIXME: cleanup all associated Port devices */
84 Irp->IoStatus.Status = STATUS_SUCCESS;
85 Irp->IoStatus.Information = 0;
86 IoCompleteRequest(Irp, IO_NO_INCREMENT);
87 return STATUS_SUCCESS;
88}
89
90static NTSTATUS NTAPI
91ClassRead(
92 IN PDEVICE_OBJECT DeviceObject,
93 IN PIRP Irp)
94{
95 PCLASS_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
96 KIRQL OldIrql;
97 NTSTATUS Status;
98
99 TRACE_(CLASS_NAME, "IRP_MJ_READ\n");
100
101 ASSERT(DeviceExtension->Common.IsClassDO);
102
103 if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
104 return ForwardIrpAndForget(DeviceObject, Irp);
105
106 if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length < sizeof(MOUSE_INPUT_DATA))
107 {
108 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
109 Irp->IoStatus.Information = 0;
110 IoCompleteRequest(Irp, IO_NO_INCREMENT);
111
112 return STATUS_BUFFER_TOO_SMALL;
113 }
114
115 KeAcquireSpinLock(&DeviceExtension->SpinLock, &OldIrql);
116 Status = HandleReadIrp(DeviceObject, Irp, FALSE);
117 KeReleaseSpinLock(&DeviceExtension->SpinLock, OldIrql);
118 return Status;
119}
120
121static NTSTATUS NTAPI
122ClassDeviceControl(
123 IN PDEVICE_OBJECT DeviceObject,
124 IN PIRP Irp)
125{
126 //PCLASS_DEVICE_EXTENSION DeviceExtension;
127 NTSTATUS Status = STATUS_NOT_SUPPORTED;
128
129 TRACE_(CLASS_NAME, "IRP_MJ_DEVICE_CONTROL\n");
130
131 if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
132 return ForwardIrpAndForget(DeviceObject, Irp);
133
134 //DeviceExtension = (PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
135
136 switch (IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode)
137 {
138 case IOCTL_MOUSE_QUERY_ATTRIBUTES:
139 {
140 /* FIXME: We hope that all devices will return the same result.
141 * Ask only the first one */
142 PLIST_ENTRY Head = &((PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->ListHead;
143 if (Head->Flink != Head)
144 {
145 /* We have at least one device */
146 PPORT_DEVICE_EXTENSION DevExt = CONTAINING_RECORD(Head->Flink, PORT_DEVICE_EXTENSION, ListEntry);
147 IoGetCurrentIrpStackLocation(Irp)->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
148 IoSkipCurrentIrpStackLocation(Irp);
149 return IoCallDriver(DevExt->DeviceObject, Irp);
150 }
151 break;
152 }
153 default:
154 WARN_(CLASS_NAME, "IRP_MJ_DEVICE_CONTROL / unknown I/O control code 0x%lx\n",
155 IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode);
156 ASSERT(FALSE);
157 break;
158 }
159
160 Irp->IoStatus.Status = Status;
161 Irp->IoStatus.Information = 0;
162 IoCompleteRequest(Irp, IO_NO_INCREMENT);
163
164 return Status;
165}
166
167static NTSTATUS NTAPI
168ClassPower(
169 IN PDEVICE_OBJECT DeviceObject,
170 IN PIRP Irp)
171{
172 NTSTATUS Status;
173 PPORT_DEVICE_EXTENSION DeviceExtension;
174
175 DeviceExtension = DeviceObject->DeviceExtension;
176 if (!DeviceExtension->Common.IsClassDO)
177 {
178 /* Forward port DO IRPs to lower device */
179 PoStartNextPowerIrp(Irp);
180 IoSkipCurrentIrpStackLocation(Irp);
181 return PoCallDriver(DeviceExtension->LowerDevice, Irp);
182 }
183
184 switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
185 {
186 case IRP_MN_SET_POWER:
187 case IRP_MN_QUERY_POWER:
188 Irp->IoStatus.Status = STATUS_SUCCESS;
189 break;
190 }
191 Status = Irp->IoStatus.Status;
192 PoStartNextPowerIrp(Irp);
193 IoCompleteRequest(Irp, IO_NO_INCREMENT);
194 return Status;
195}
196
197static NTSTATUS
198ReadRegistryEntries(
199 IN PUNICODE_STRING RegistryPath,
200 IN PCLASS_DRIVER_EXTENSION DriverExtension)
201{
202 UNICODE_STRING ParametersRegistryKey;
203 RTL_QUERY_REGISTRY_TABLE Parameters[4];
204 NTSTATUS Status;
205
206 ULONG DefaultConnectMultiplePorts = 1;
207 ULONG DefaultDataQueueSize = 0x64;
208 PCWSTR DefaultDeviceBaseName = L"PointerClass";
209
210 ParametersRegistryKey.Length = 0;
211 ParametersRegistryKey.MaximumLength = RegistryPath->Length + sizeof(L"\\Parameters") + sizeof(UNICODE_NULL);
212 ParametersRegistryKey.Buffer = ExAllocatePoolWithTag(PagedPool, ParametersRegistryKey.MaximumLength, CLASS_TAG);
213 if (!ParametersRegistryKey.Buffer)
214 {
215 WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
216 return STATUS_NO_MEMORY;
217 }
218 RtlCopyUnicodeString(&ParametersRegistryKey, RegistryPath);
219 RtlAppendUnicodeToString(&ParametersRegistryKey, L"\\Parameters");
220 ParametersRegistryKey.Buffer[ParametersRegistryKey.Length / sizeof(WCHAR)] = UNICODE_NULL;
221
222 RtlZeroMemory(Parameters, sizeof(Parameters));
223
224 Parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
225 Parameters[0].Name = L"ConnectMultiplePorts";
226 Parameters[0].EntryContext = &DriverExtension->ConnectMultiplePorts;
227 Parameters[0].DefaultType = REG_DWORD;
228 Parameters[0].DefaultData = &DefaultConnectMultiplePorts;
229 Parameters[0].DefaultLength = sizeof(ULONG);
230
231 Parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
232 Parameters[1].Name = L"MouseDataQueueSize";
233 Parameters[1].EntryContext = &DriverExtension->DataQueueSize;
234 Parameters[1].DefaultType = REG_DWORD;
235 Parameters[1].DefaultData = &DefaultDataQueueSize;
236 Parameters[1].DefaultLength = sizeof(ULONG);
237
238 Parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
239 Parameters[2].Name = L"PointerDeviceBaseName";
240 Parameters[2].EntryContext = &DriverExtension->DeviceBaseName;
241 Parameters[2].DefaultType = REG_SZ;
242 Parameters[2].DefaultData = (PVOID)DefaultDeviceBaseName;
243 Parameters[2].DefaultLength = 0;
244
245 Status = RtlQueryRegistryValues(
246 RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
247 ParametersRegistryKey.Buffer,
248 Parameters,
249 NULL,
250 NULL);
251
252 if (NT_SUCCESS(Status))
253 {
254 /* Check values */
255 if (DriverExtension->ConnectMultiplePorts != 0
256 && DriverExtension->ConnectMultiplePorts != 1)
257 {
258 DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
259 }
260 if (DriverExtension->DataQueueSize == 0)
261 {
262 DriverExtension->DataQueueSize = DefaultDataQueueSize;
263 }
264 }
265 else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
266 {
267 /* Registry path doesn't exist. Set defaults */
268 DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
269 DriverExtension->DataQueueSize = DefaultDataQueueSize;
270 if (RtlCreateUnicodeString(&DriverExtension->DeviceBaseName, DefaultDeviceBaseName))
271 Status = STATUS_SUCCESS;
272 else
273 Status = STATUS_NO_MEMORY;
274 }
275
276 ExFreePoolWithTag(ParametersRegistryKey.Buffer, CLASS_TAG);
277 return Status;
278}
279
280static NTSTATUS
281CreateClassDeviceObject(
282 IN PDRIVER_OBJECT DriverObject,
283 OUT PDEVICE_OBJECT *ClassDO OPTIONAL)
284{
285 PCLASS_DRIVER_EXTENSION DriverExtension;
286 ULONG DeviceId = 0;
287 ULONG PrefixLength;
288 UNICODE_STRING DeviceNameU;
289 PWSTR DeviceIdW = NULL; /* Pointer into DeviceNameU.Buffer */
290 PDEVICE_OBJECT Fdo;
291 PCLASS_DEVICE_EXTENSION DeviceExtension;
292 NTSTATUS Status;
293
294 TRACE_(CLASS_NAME, "CreateClassDeviceObject(0x%p)\n", DriverObject);
295
296 /* Create new device object */
297 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
298 DeviceNameU.Length = 0;
299 DeviceNameU.MaximumLength =
300 (USHORT)wcslen(L"\\Device\\") * sizeof(WCHAR) /* "\Device\" */
301 + DriverExtension->DeviceBaseName.Length /* "PointerClass" */
302 + 4 * sizeof(WCHAR) /* Id between 0 and 9999 */
303 + sizeof(UNICODE_NULL); /* Final NULL char */
304 DeviceNameU.Buffer = ExAllocatePoolWithTag(PagedPool, DeviceNameU.MaximumLength, CLASS_TAG);
305 if (!DeviceNameU.Buffer)
306 {
307 WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
308 return STATUS_NO_MEMORY;
309 }
310 Status = RtlAppendUnicodeToString(&DeviceNameU, L"\\Device\\");
311 if (!NT_SUCCESS(Status))
312 {
313 WARN_(CLASS_NAME, "RtlAppendUnicodeToString() failed with status 0x%08lx\n", Status);
314 goto cleanup;
315 }
316 Status = RtlAppendUnicodeStringToString(&DeviceNameU, &DriverExtension->DeviceBaseName);
317 if (!NT_SUCCESS(Status))
318 {
319 WARN_(CLASS_NAME, "RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
320 goto cleanup;
321 }
322 PrefixLength = DeviceNameU.MaximumLength - 4 * sizeof(WCHAR) - sizeof(UNICODE_NULL);
323 DeviceIdW = &DeviceNameU.Buffer[PrefixLength / sizeof(WCHAR)];
324 while (DeviceId < 9999)
325 {
326 DeviceNameU.Length = (USHORT)(PrefixLength + swprintf(DeviceIdW, L"%lu", DeviceId) * sizeof(WCHAR));
327 Status = IoCreateDevice(
328 DriverObject,
329 sizeof(CLASS_DEVICE_EXTENSION),
330 &DeviceNameU,
331 FILE_DEVICE_MOUSE,
332 FILE_DEVICE_SECURE_OPEN,
333 FALSE,
334 &Fdo);
335 if (NT_SUCCESS(Status))
336 goto cleanup;
337 else if (Status != STATUS_OBJECT_NAME_COLLISION)
338 {
339 WARN_(CLASS_NAME, "IoCreateDevice() failed with status 0x%08lx\n", Status);
340 goto cleanup;
341 }
342 DeviceId++;
343 }
344 WARN_(CLASS_NAME, "Too many devices starting with '\\Device\\%wZ'\n", &DriverExtension->DeviceBaseName);
345 Status = STATUS_TOO_MANY_NAMES;
346cleanup:
347 if (!NT_SUCCESS(Status))
348 {
349 ExFreePoolWithTag(DeviceNameU.Buffer, CLASS_TAG);
350 return Status;
351 }
352
353 DeviceExtension = (PCLASS_DEVICE_EXTENSION)Fdo->DeviceExtension;
354 RtlZeroMemory(DeviceExtension, sizeof(CLASS_DEVICE_EXTENSION));
355 DeviceExtension->Common.IsClassDO = TRUE;
356 DeviceExtension->DriverExtension = DriverExtension;
357 InitializeListHead(&DeviceExtension->ListHead);
358 KeInitializeSpinLock(&DeviceExtension->ListSpinLock);
359 KeInitializeSpinLock(&DeviceExtension->SpinLock);
360 DeviceExtension->InputCount = 0;
361 DeviceExtension->PortData = ExAllocatePoolWithTag(NonPagedPool, DeviceExtension->DriverExtension->DataQueueSize * sizeof(MOUSE_INPUT_DATA), CLASS_TAG);
362 if (!DeviceExtension->PortData)
363 {
364 ExFreePoolWithTag(DeviceNameU.Buffer, CLASS_TAG);
365 return STATUS_NO_MEMORY;
366 }
367 DeviceExtension->DeviceName = DeviceNameU.Buffer;
368 Fdo->Flags |= DO_POWER_PAGABLE;
369 Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
370 Fdo->Flags |= DO_BUFFERED_IO;
371
372 /* Add entry entry to HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\[DeviceBaseName] */
373 RtlWriteRegistryValue(
374 RTL_REGISTRY_DEVICEMAP,
375 DriverExtension->DeviceBaseName.Buffer,
376 DeviceExtension->DeviceName,
377 REG_SZ,
378 DriverExtension->RegistryPath.Buffer,
379 DriverExtension->RegistryPath.MaximumLength);
380
381 if (ClassDO)
382 *ClassDO = Fdo;
383
384 return STATUS_SUCCESS;
385}
386
387static NTSTATUS
388FillEntries(
389 IN PDEVICE_OBJECT ClassDeviceObject,
390 IN PIRP Irp,
391 IN PMOUSE_INPUT_DATA DataStart,
392 IN SIZE_T NumberOfEntries)
393{
394 NTSTATUS Status = STATUS_SUCCESS;
395
396 if (ClassDeviceObject->Flags & DO_BUFFERED_IO)
397 {
398 RtlCopyMemory(
399 Irp->AssociatedIrp.SystemBuffer,
400 DataStart,
401 NumberOfEntries * sizeof(MOUSE_INPUT_DATA));
402 }
403 else if (ClassDeviceObject->Flags & DO_DIRECT_IO)
404 {
405 PVOID DestAddress = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
406 if (DestAddress)
407 {
408 RtlCopyMemory(
409 DestAddress,
410 DataStart,
411 NumberOfEntries * sizeof(MOUSE_INPUT_DATA));
412 }
413 else
414 Status = STATUS_UNSUCCESSFUL;
415 }
416 else
417 {
418 _SEH2_TRY
419 {
420 RtlCopyMemory(
421 Irp->UserBuffer,
422 DataStart,
423 NumberOfEntries * sizeof(MOUSE_INPUT_DATA));
424 }
425 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
426 {
427 Status = _SEH2_GetExceptionCode();
428 }
429 _SEH2_END;
430 }
431
432 return Status;
433}
434
435static BOOLEAN NTAPI
436ClassCallback(
437 IN PDEVICE_OBJECT ClassDeviceObject,
438 IN OUT PMOUSE_INPUT_DATA DataStart,
439 IN PMOUSE_INPUT_DATA DataEnd,
440 IN OUT PULONG ConsumedCount)
441{
442 PCLASS_DEVICE_EXTENSION ClassDeviceExtension = ClassDeviceObject->DeviceExtension;
443 KIRQL OldIrql;
444 SIZE_T InputCount = DataEnd - DataStart;
445 SIZE_T ReadSize;
446
447 TRACE_(CLASS_NAME, "ClassCallback()\n");
448
449 ASSERT(ClassDeviceExtension->Common.IsClassDO);
450
451 KeAcquireSpinLock(&ClassDeviceExtension->SpinLock, &OldIrql);
452 if (InputCount > 0)
453 {
454 if (ClassDeviceExtension->InputCount + InputCount > ClassDeviceExtension->DriverExtension->DataQueueSize)
455 {
456 /*
457 * We're exceeding the buffer, and data will be thrown away...
458 * FIXME: What could we do, as we are at DISPATCH_LEVEL?
459 */
460 ReadSize = ClassDeviceExtension->DriverExtension->DataQueueSize - ClassDeviceExtension->InputCount;
461 }
462 else
463 ReadSize = InputCount;
464
465 /*
466 * Move the input data from the port data queue to our class data
467 * queue.
468 */
469 RtlCopyMemory(
470 &ClassDeviceExtension->PortData[ClassDeviceExtension->InputCount],
471 (PCHAR)DataStart,
472 sizeof(MOUSE_INPUT_DATA) * ReadSize);
473
474 /* Move the counter up */
475 ClassDeviceExtension->InputCount += ReadSize;
476
477 (*ConsumedCount) += (ULONG)ReadSize;
478
479 /* Complete pending IRP (if any) */
480 if (ClassDeviceExtension->PendingIrp)
481 HandleReadIrp(ClassDeviceObject, ClassDeviceExtension->PendingIrp, FALSE);
482 }
483 KeReleaseSpinLock(&ClassDeviceExtension->SpinLock, OldIrql);
484
485 TRACE_(CLASS_NAME, "Leaving ClassCallback()\n");
486 return TRUE;
487}
488
489/* Send IOCTL_INTERNAL_*_CONNECT to port */
490static NTSTATUS
491ConnectPortDriver(
492 IN PDEVICE_OBJECT PortDO,
493 IN PDEVICE_OBJECT ClassDO)
494{
495 KEVENT Event;
496 PIRP Irp;
497 IO_STATUS_BLOCK IoStatus;
498 CONNECT_DATA ConnectData;
499 NTSTATUS Status;
500
501 TRACE_(CLASS_NAME, "Connecting PortDO %p to ClassDO %p\n", PortDO, ClassDO);
502
503 KeInitializeEvent(&Event, NotificationEvent, FALSE);
504
505 ConnectData.ClassDeviceObject = ClassDO;
506 ConnectData.ClassService = ClassCallback;
507
508 Irp = IoBuildDeviceIoControlRequest(
509 IOCTL_INTERNAL_MOUSE_CONNECT,
510 PortDO,
511 &ConnectData, sizeof(CONNECT_DATA),
512 NULL, 0,
513 TRUE, &Event, &IoStatus);
514 if (!Irp)
515 return STATUS_INSUFFICIENT_RESOURCES;
516
517 Status = IoCallDriver(PortDO, Irp);
518
519 if (Status == STATUS_PENDING)
520 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
521 else
522 IoStatus.Status = Status;
523
524 if (NT_SUCCESS(IoStatus.Status))
525 {
526 ObReferenceObject(PortDO);
527 ExInterlockedInsertTailList(
528 &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListHead,
529 &((PPORT_DEVICE_EXTENSION)PortDO->DeviceExtension)->ListEntry,
530 &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListSpinLock);
531 if (ClassDO->StackSize <= PortDO->StackSize)
532 {
533 /* Increase the stack size, in case we have to
534 * forward some IRPs to the port device object
535 */
536 ClassDO->StackSize = PortDO->StackSize + 1;
537 }
538 }
539
540 return IoStatus.Status;
541}
542
543/* Send IOCTL_INTERNAL_*_DISCONNECT to port + destroy the Port DO */
544static VOID
545DestroyPortDriver(
546 IN PDEVICE_OBJECT PortDO)
547{
548 PPORT_DEVICE_EXTENSION DeviceExtension;
549 PCLASS_DEVICE_EXTENSION ClassDeviceExtension;
550 PCLASS_DRIVER_EXTENSION DriverExtension;
551 KEVENT Event;
552 PIRP Irp;
553 IO_STATUS_BLOCK IoStatus;
554 KIRQL OldIrql;
555 NTSTATUS Status;
556
557 TRACE_(CLASS_NAME, "Destroying PortDO %p\n", PortDO);
558
559 DeviceExtension = (PPORT_DEVICE_EXTENSION)PortDO->DeviceExtension;
560 ClassDeviceExtension = DeviceExtension->ClassDO->DeviceExtension;
561 DriverExtension = IoGetDriverObjectExtension(PortDO->DriverObject, PortDO->DriverObject);
562
563 /* Send IOCTL_INTERNAL_*_DISCONNECT */
564 KeInitializeEvent(&Event, NotificationEvent, FALSE);
565 Irp = IoBuildDeviceIoControlRequest(
566 IOCTL_INTERNAL_MOUSE_DISCONNECT,
567 PortDO,
568 NULL, 0,
569 NULL, 0,
570 TRUE, &Event, &IoStatus);
571 if (Irp)
572 {
573 Status = IoCallDriver(PortDO, Irp);
574 if (Status == STATUS_PENDING)
575 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
576 }
577
578 /* Remove from ClassDeviceExtension->ListHead list */
579 KeAcquireSpinLock(&ClassDeviceExtension->ListSpinLock, &OldIrql);
580 RemoveEntryList(&DeviceExtension->ListEntry);
581 KeReleaseSpinLock(&ClassDeviceExtension->ListSpinLock, OldIrql);
582
583 /* Remove entry from HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\[DeviceBaseName] */
584 RtlDeleteRegistryValue(
585 RTL_REGISTRY_DEVICEMAP,
586 DriverExtension->DeviceBaseName.Buffer,
587 ClassDeviceExtension->DeviceName);
588
589 if (DeviceExtension->LowerDevice)
590 IoDetachDevice(DeviceExtension->LowerDevice);
591 ObDereferenceObject(PortDO);
592
593 if (!DriverExtension->ConnectMultiplePorts && DeviceExtension->ClassDO)
594 {
595 ExFreePoolWithTag(ClassDeviceExtension->PortData, CLASS_TAG);
596 ExFreePoolWithTag((PVOID)ClassDeviceExtension->DeviceName, CLASS_TAG);
597 IoDeleteDevice(DeviceExtension->ClassDO);
598 }
599
600 IoDeleteDevice(PortDO);
601}
602
603static NTSTATUS NTAPI
604ClassAddDevice(
605 IN PDRIVER_OBJECT DriverObject,
606 IN PDEVICE_OBJECT Pdo)
607{
608 PCLASS_DRIVER_EXTENSION DriverExtension;
609 PDEVICE_OBJECT Fdo = NULL;
610 PPORT_DEVICE_EXTENSION DeviceExtension = NULL;
611 NTSTATUS Status;
612
613 TRACE_(CLASS_NAME, "ClassAddDevice called. Pdo = 0x%p\n", Pdo);
614
615 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
616
617 if (Pdo == NULL)
618 /* We may get a NULL Pdo at the first call as we're a legacy driver. Ignore it */
619 return STATUS_SUCCESS;
620
621 /* Create new device object */
622 Status = IoCreateDevice(
623 DriverObject,
624 sizeof(PORT_DEVICE_EXTENSION),
625 NULL,
626 Pdo->DeviceType,
627 Pdo->Characteristics & FILE_DEVICE_SECURE_OPEN ? FILE_DEVICE_SECURE_OPEN : 0,
628 FALSE,
629 &Fdo);
630 if (!NT_SUCCESS(Status))
631 {
632 WARN_(CLASS_NAME, "IoCreateDevice() failed with status 0x%08lx\n", Status);
633 goto cleanup;
634 }
635 IoSetStartIoAttributes(Fdo, TRUE, TRUE);
636
637 DeviceExtension = (PPORT_DEVICE_EXTENSION)Fdo->DeviceExtension;
638 RtlZeroMemory(DeviceExtension, sizeof(PORT_DEVICE_EXTENSION));
639 DeviceExtension->Common.IsClassDO = FALSE;
640 DeviceExtension->DeviceObject = Fdo;
641 DeviceExtension->PnpState = dsStopped;
642 Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);
643 if (!NT_SUCCESS(Status))
644 {
645 WARN_(CLASS_NAME, "IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
646 goto cleanup;
647 }
648 if (DeviceExtension->LowerDevice->Flags & DO_POWER_PAGABLE)
649 Fdo->Flags |= DO_POWER_PAGABLE;
650 if (DeviceExtension->LowerDevice->Flags & DO_BUFFERED_IO)
651 Fdo->Flags |= DO_BUFFERED_IO;
652 if (DeviceExtension->LowerDevice->Flags & DO_DIRECT_IO)
653 Fdo->Flags |= DO_DIRECT_IO;
654
655 if (DriverExtension->ConnectMultiplePorts)
656 DeviceExtension->ClassDO = DriverExtension->MainClassDeviceObject;
657 else
658 {
659 /* We need a new class device object for this Fdo */
660 Status = CreateClassDeviceObject(
661 DriverObject,
662 &DeviceExtension->ClassDO);
663 if (!NT_SUCCESS(Status))
664 {
665 WARN_(CLASS_NAME, "CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
666 goto cleanup;
667 }
668 }
669 Status = ConnectPortDriver(Fdo, DeviceExtension->ClassDO);
670 if (!NT_SUCCESS(Status))
671 {
672 WARN_(CLASS_NAME, "ConnectPortDriver() failed with status 0x%08lx\n", Status);
673 goto cleanup;
674 }
675 Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
676
677 /* Register interface ; ignore the error (if any) as having
678 * a registered interface is not so important... */
679 Status = IoRegisterDeviceInterface(
680 Pdo,
681 &GUID_DEVINTERFACE_MOUSE,
682 NULL,
683 &DeviceExtension->InterfaceName);
684 if (!NT_SUCCESS(Status))
685 DeviceExtension->InterfaceName.Length = 0;
686
687 return STATUS_SUCCESS;
688
689cleanup:
690 if (Fdo)
691 DestroyPortDriver(Fdo);
692 return Status;
693}
694
695static VOID NTAPI
696ClassCancelRoutine(
697 IN PDEVICE_OBJECT DeviceObject,
698 IN PIRP Irp)
699{
700 PCLASS_DEVICE_EXTENSION ClassDeviceExtension = DeviceObject->DeviceExtension;
701 KIRQL OldIrql;
702 BOOLEAN wasQueued = FALSE;
703
704 TRACE_(CLASS_NAME, "ClassCancelRoutine(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
705
706 ASSERT(ClassDeviceExtension->Common.IsClassDO);
707
708 IoReleaseCancelSpinLock(Irp->CancelIrql);
709
710 KeAcquireSpinLock(&ClassDeviceExtension->SpinLock, &OldIrql);
711
712 if (ClassDeviceExtension->PendingIrp == Irp)
713 {
714 ClassDeviceExtension->PendingIrp = NULL;
715 wasQueued = TRUE;
716 }
717 KeReleaseSpinLock(&ClassDeviceExtension->SpinLock, OldIrql);
718
719 if (wasQueued)
720 {
721 Irp->IoStatus.Status = STATUS_CANCELLED;
722 Irp->IoStatus.Information = 0;
723 IoCompleteRequest(Irp, IO_NO_INCREMENT);
724 }
725 else
726 {
727 DPRINT1("Cancelled IRP is not pending. Race condition?\n");
728 }
729}
730
731static NTSTATUS
732HandleReadIrp(
733 IN PDEVICE_OBJECT DeviceObject,
734 IN PIRP Irp,
735 BOOLEAN IsInStartIo)
736{
737 PCLASS_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
738 NTSTATUS Status;
739 KIRQL OldIrql;
740
741 TRACE_(CLASS_NAME, "HandleReadIrp(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
742
743 ASSERT(DeviceExtension->Common.IsClassDO);
744
745 if (DeviceExtension->InputCount > 0)
746 {
747 SIZE_T NumberOfEntries;
748
749 NumberOfEntries = MIN(
750 DeviceExtension->InputCount,
751 IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length / sizeof(MOUSE_INPUT_DATA));
752
753 Status = FillEntries(
754 DeviceObject,
755 Irp,
756 DeviceExtension->PortData,
757 NumberOfEntries);
758
759 if (NT_SUCCESS(Status))
760 {
761 if (DeviceExtension->InputCount > NumberOfEntries)
762 {
763 RtlMoveMemory(
764 &DeviceExtension->PortData[0],
765 &DeviceExtension->PortData[NumberOfEntries],
766 (DeviceExtension->InputCount - NumberOfEntries) * sizeof(MOUSE_INPUT_DATA));
767 }
768
769 DeviceExtension->InputCount -= NumberOfEntries;
770
771 Irp->IoStatus.Information = NumberOfEntries * sizeof(MOUSE_INPUT_DATA);
772 }
773
774 /* Go to next packet and complete this request */
775 Irp->IoStatus.Status = Status;
776
777 (VOID)IoSetCancelRoutine(Irp, NULL);
778 IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
779 DeviceExtension->PendingIrp = NULL;
780 }
781 else
782 {
783 IoAcquireCancelSpinLock(&OldIrql);
784 if (Irp->Cancel)
785 {
786 DeviceExtension->PendingIrp = NULL;
787 Status = STATUS_CANCELLED;
788 }
789 else
790 {
791 IoMarkIrpPending(Irp);
792 DeviceExtension->PendingIrp = Irp;
793 (VOID)IoSetCancelRoutine(Irp, ClassCancelRoutine);
794 Status = STATUS_PENDING;
795 }
796 IoReleaseCancelSpinLock(OldIrql);
797 }
798 return Status;
799}
800
801static NTSTATUS NTAPI
802ClassPnp(
803 IN PDEVICE_OBJECT DeviceObject,
804 IN PIRP Irp)
805{
806 PPORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
807 PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
808 OBJECT_ATTRIBUTES ObjectAttributes;
809 IO_STATUS_BLOCK Iosb;
810 NTSTATUS Status;
811
812 switch (IrpSp->MinorFunction)
813 {
814 case IRP_MN_START_DEVICE:
815 if (IoForwardIrpSynchronously(DeviceExtension->LowerDevice, Irp))
816 {
817 Status = Irp->IoStatus.Status;
818 }
819 else
820 {
821 Status = STATUS_UNSUCCESSFUL;
822 }
823
824 if (NT_SUCCESS(Status))
825 {
826 InitializeObjectAttributes(&ObjectAttributes,
827 &DeviceExtension->InterfaceName,
828 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
829 NULL,
830 NULL);
831
832 Status = ZwOpenFile(&DeviceExtension->FileHandle,
833 FILE_READ_DATA,
834 &ObjectAttributes,
835 &Iosb,
836 0,
837 0);
838 if (!NT_SUCCESS(Status))
839 DeviceExtension->FileHandle = NULL;
840 }
841 else
842 DeviceExtension->FileHandle = NULL;
843 if (DeviceExtension->InterfaceName.Length != 0)
844 IoSetDeviceInterfaceState(&DeviceExtension->InterfaceName, TRUE);
845 Irp->IoStatus.Status = Status;
846 IoCompleteRequest(Irp, IO_NO_INCREMENT);
847 return Status;
848
849 case IRP_MN_STOP_DEVICE:
850 if (DeviceExtension->FileHandle)
851 {
852 ZwClose(DeviceExtension->FileHandle);
853 DeviceExtension->FileHandle = NULL;
854 }
855 Status = STATUS_SUCCESS;
856 break;
857
858 case IRP_MN_REMOVE_DEVICE:
859 if (DeviceExtension->InterfaceName.Length != 0)
860 IoSetDeviceInterfaceState(&DeviceExtension->InterfaceName, FALSE);
861 if (DeviceExtension->FileHandle)
862 {
863 ZwClose(DeviceExtension->FileHandle);
864 DeviceExtension->FileHandle = NULL;
865 }
866 IoSkipCurrentIrpStackLocation(Irp);
867 Status = IoCallDriver(DeviceExtension->LowerDevice, Irp);
868 DestroyPortDriver(DeviceObject);
869 return Status;
870
871 default:
872 Status = Irp->IoStatus.Status;
873 break;
874 }
875
876 Irp->IoStatus.Status = Status;
877 if (NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED)
878 {
879 IoSkipCurrentIrpStackLocation(Irp);
880 return IoCallDriver(DeviceExtension->LowerDevice, Irp);
881 }
882 else
883 {
884 IoCompleteRequest(Irp, IO_NO_INCREMENT);
885 return Status;
886 }
887}
888
889static VOID NTAPI
890ClassStartIo(
891 IN PDEVICE_OBJECT DeviceObject,
892 IN PIRP Irp)
893{
894 PCLASS_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
895 KIRQL OldIrql;
896
897 TRACE_(CLASS_NAME, "ClassStartIo(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
898
899 ASSERT(DeviceExtension->Common.IsClassDO);
900
901 KeAcquireSpinLock(&DeviceExtension->SpinLock, &OldIrql);
902 HandleReadIrp(DeviceObject, Irp, TRUE);
903 KeReleaseSpinLock(&DeviceExtension->SpinLock, OldIrql);
904}
905
906static VOID NTAPI
907SearchForLegacyDrivers(
908 IN PDRIVER_OBJECT DriverObject,
909 IN PVOID Context, /* PCLASS_DRIVER_EXTENSION */
910 IN ULONG Count)
911{
912 UNICODE_STRING DeviceMapKeyU = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\HARDWARE\\DEVICEMAP");
913 PCLASS_DRIVER_EXTENSION DriverExtension;
914 UNICODE_STRING PortBaseName = { 0, 0, NULL };
915 PKEY_VALUE_BASIC_INFORMATION KeyValueInformation = NULL;
916 OBJECT_ATTRIBUTES ObjectAttributes;
917 HANDLE hDeviceMapKey = (HANDLE)-1;
918 HANDLE hPortKey = (HANDLE)-1;
919 ULONG Index = 0;
920 ULONG Size, ResultLength;
921 NTSTATUS Status;
922
923 TRACE_(CLASS_NAME, "SearchForLegacyDrivers(%p %p %lu)\n",
924 DriverObject, Context, Count);
925
926 if (Count != 1)
927 return;
928 DriverExtension = (PCLASS_DRIVER_EXTENSION)Context;
929
930 /* Create port base name, by replacing Class by Port at the end of the class base name */
931 Status = DuplicateUnicodeString(
932 RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
933 &DriverExtension->DeviceBaseName,
934 &PortBaseName);
935 if (!NT_SUCCESS(Status))
936 {
937 WARN_(CLASS_NAME, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
938 goto cleanup;
939 }
940 PortBaseName.Length -= (sizeof(L"Class") - sizeof(UNICODE_NULL));
941 RtlAppendUnicodeToString(&PortBaseName, L"Port");
942
943 /* Allocate memory */
944 Size = sizeof(KEY_VALUE_BASIC_INFORMATION) + MAX_PATH;
945 KeyValueInformation = ExAllocatePoolWithTag(PagedPool, Size, CLASS_TAG);
946 if (!KeyValueInformation)
947 {
948 WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
949 Status = STATUS_NO_MEMORY;
950 goto cleanup;
951 }
952
953 /* Open HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP */
954 InitializeObjectAttributes(&ObjectAttributes, &DeviceMapKeyU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
955 Status = ZwOpenKey(&hDeviceMapKey, 0, &ObjectAttributes);
956 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
957 {
958 INFO_(CLASS_NAME, "HKLM\\HARDWARE\\DEVICEMAP is non-existent\n");
959 Status = STATUS_SUCCESS;
960 goto cleanup;
961 }
962 else if (!NT_SUCCESS(Status))
963 {
964 WARN_(CLASS_NAME, "ZwOpenKey() failed with status 0x%08lx\n", Status);
965 goto cleanup;
966 }
967
968 /* Open sub key */
969 InitializeObjectAttributes(&ObjectAttributes, &PortBaseName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hDeviceMapKey, NULL);
970 Status = ZwOpenKey(&hPortKey, KEY_QUERY_VALUE, &ObjectAttributes);
971 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
972 {
973 INFO_(CLASS_NAME, "HKLM\\HARDWARE\\DEVICEMAP\\%wZ is non-existent\n", &PortBaseName);
974 Status = STATUS_SUCCESS;
975 goto cleanup;
976 }
977 else if (!NT_SUCCESS(Status))
978 {
979 WARN_(CLASS_NAME, "ZwOpenKey() failed with status 0x%08lx\n", Status);
980 goto cleanup;
981 }
982
983 /* Read each value name */
984 while (ZwEnumerateValueKey(hPortKey, Index++, KeyValueBasicInformation, KeyValueInformation, Size, &ResultLength) == STATUS_SUCCESS)
985 {
986 UNICODE_STRING PortName;
987 PDEVICE_OBJECT PortDeviceObject = NULL;
988 PFILE_OBJECT FileObject = NULL;
989
990 PortName.Length = PortName.MaximumLength = (USHORT)KeyValueInformation->NameLength;
991 PortName.Buffer = KeyValueInformation->Name;
992
993 /* Open the device object pointer */
994 Status = IoGetDeviceObjectPointer(&PortName, FILE_READ_ATTRIBUTES, &FileObject, &PortDeviceObject);
995 if (!NT_SUCCESS(Status))
996 {
997 WARN_(CLASS_NAME, "IoGetDeviceObjectPointer(%wZ) failed with status 0x%08lx\n", &PortName, Status);
998 continue;
999 }
1000 INFO_(CLASS_NAME, "Legacy driver found\n");
1001
1002 Status = ClassAddDevice(DriverObject, PortDeviceObject);
1003 if (!NT_SUCCESS(Status))
1004 {
1005 /* FIXME: Log the error */
1006 WARN_(CLASS_NAME, "ClassAddDevice() failed with status 0x%08lx\n", Status);
1007 }
1008
1009 ObDereferenceObject(FileObject);
1010 }
1011
1012cleanup:
1013 if (KeyValueInformation != NULL)
1014 ExFreePoolWithTag(KeyValueInformation, CLASS_TAG);
1015 if (hDeviceMapKey != (HANDLE)-1)
1016 ZwClose(hDeviceMapKey);
1017 if (hPortKey != (HANDLE)-1)
1018 ZwClose(hPortKey);
1019}
1020
1021/*
1022 * Standard DriverEntry method.
1023 */
1024NTSTATUS NTAPI
1025DriverEntry(
1026 IN PDRIVER_OBJECT DriverObject,
1027 IN PUNICODE_STRING RegistryPath)
1028{
1029 PCLASS_DRIVER_EXTENSION DriverExtension;
1030 NTSTATUS Status;
1031
1032 Status = IoAllocateDriverObjectExtension(
1033 DriverObject,
1034 DriverObject,
1035 sizeof(CLASS_DRIVER_EXTENSION),
1036 (PVOID*)&DriverExtension);
1037 if (!NT_SUCCESS(Status))
1038 {
1039 WARN_(CLASS_NAME, "IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
1040 return Status;
1041 }
1042 RtlZeroMemory(DriverExtension, sizeof(CLASS_DRIVER_EXTENSION));
1043
1044 Status = DuplicateUnicodeString(
1045 RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
1046 RegistryPath,
1047 &DriverExtension->RegistryPath);
1048 if (!NT_SUCCESS(Status))
1049 {
1050 WARN_(CLASS_NAME, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
1051 return Status;
1052 }
1053
1054 Status = ReadRegistryEntries(RegistryPath, DriverExtension);
1055 if (!NT_SUCCESS(Status))
1056 {
1057 WARN_(CLASS_NAME, "ReadRegistryEntries() failed with status 0x%08lx\n", Status);
1058 return Status;
1059 }
1060
1061 if (DriverExtension->ConnectMultiplePorts == 1)
1062 {
1063 Status = CreateClassDeviceObject(
1064 DriverObject,
1065 &DriverExtension->MainClassDeviceObject);
1066 if (!NT_SUCCESS(Status))
1067 {
1068 WARN_(CLASS_NAME, "CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
1069 return Status;
1070 }
1071 }
1072
1073 DriverObject->DriverExtension->AddDevice = ClassAddDevice;
1074 DriverObject->DriverUnload = DriverUnload;
1075
1076 DriverObject->MajorFunction[IRP_MJ_CREATE] = ClassCreate;
1077 DriverObject->MajorFunction[IRP_MJ_CLOSE] = ClassClose;
1078 DriverObject->MajorFunction[IRP_MJ_CLEANUP] = ClassCleanup;
1079 DriverObject->MajorFunction[IRP_MJ_READ] = ClassRead;
1080 DriverObject->MajorFunction[IRP_MJ_POWER] = ClassPower;
1081 DriverObject->MajorFunction[IRP_MJ_PNP] = ClassPnp;
1082 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ClassDeviceControl;
1083 DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = ForwardIrpAndForget;
1084 DriverObject->DriverStartIo = ClassStartIo;
1085
1086 /* We will detect the legacy devices later */
1087 IoRegisterDriverReinitialization(
1088 DriverObject,
1089 SearchForLegacyDrivers,
1090 DriverExtension);
1091
1092 return STATUS_SUCCESS;
1093}