![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mouclass.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / input / mouclass|
Return to mouclass.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / input / mouclass |
1.1 root 1:
2: /*++
3:
4: Copyright (c) 1990, 1991, 1992, 1993 Microsoft Corporation
5:
6: Module Name:
7:
8: mouclass.c
9:
10: Abstract:
11:
12: Mouse class driver.
13:
14: Environment:
15:
16: Kernel mode only.
17:
18: Notes:
19:
20: NOTES: (Future/outstanding issues)
21:
22: - Powerfail not implemented.
23:
24: - Consolidate duplicate code, where possible and appropriate.
25:
26: - Unload not implemented. We don't want to allow this driver
27: to unload.
28:
29: Revision History:
30:
31: --*/
32:
33: #include "stdarg.h"
34: #include "stdio.h"
35: #include "ntddk.h"
36: #include "mouclass.h"
37: #include "kbdmou.h"
38: #include "moulog.h"
39:
40:
41: NTSTATUS
42: DriverEntry(
43: IN PDRIVER_OBJECT DriverObject,
44: IN PUNICODE_STRING RegistryPath
45: );
46:
47: VOID
48: MouseClassCancel(
49: IN PDEVICE_OBJECT DeviceObject,
50: IN PIRP Irp
51: );
52:
53: NTSTATUS
54: MouseClassCleanup(
55: IN PDEVICE_OBJECT DeviceObject,
56: IN PIRP Irp
57: );
58:
59: NTSTATUS
60: MouseClassDeviceControl(
61: IN PDEVICE_OBJECT DeviceObject,
62: IN PIRP Irp
63: );
64:
65: NTSTATUS
66: MouseClassFlush(
67: IN PDEVICE_OBJECT DeviceObject,
68: IN PIRP Irp
69: );
70:
71: NTSTATUS
72: MouseClassOpenClose(
73: IN PDEVICE_OBJECT DeviceObject,
74: IN PIRP Irp
75: );
76:
77: NTSTATUS
78: MouseClassRead(
79: IN PDEVICE_OBJECT DeviceObject,
80: IN PIRP Irp
81: );
82:
83: VOID
84: MouseClassServiceCallback(
85: IN PDEVICE_OBJECT DeviceObject,
86: IN PMOUSE_INPUT_DATA InputDataStart,
87: IN PMOUSE_INPUT_DATA InputDataEnd,
88: IN OUT PULONG InputDataConsumed
89: );
90:
91: VOID
92: MouseClassStartIo(
93: IN PDEVICE_OBJECT DeviceObject,
94: IN PIRP Irp
95: );
96:
97: VOID
98: MouseClassUnload(
99: IN PDRIVER_OBJECT DriverObject
100: );
101:
102: BOOLEAN
103: MouCancelRequest(
104: IN PVOID Context
105: );
106:
107: VOID
108: MouConfiguration(
109: IN PDEVICE_EXTENSION DeviceExtension,
110: IN PUNICODE_STRING RegistryPath,
111: IN PUNICODE_STRING DeviceName
112: );
113:
114: NTSTATUS
115: MouConnectToPort(
116: IN PDEVICE_OBJECT ClassDeviceObject,
117: IN PUNICODE_STRING FullPortName,
118: IN ULONG PortIndex
119: );
120:
121: NTSTATUS
122: MouCreateClassObject(
123: IN PDRIVER_OBJECT DriverObject,
124: IN PDEVICE_EXTENSION TmpDeviceExtension,
125: IN PUNICODE_STRING RegistryPath,
126: IN PUNICODE_STRING FullDeviceName,
127: IN PUNICODE_STRING BaseDeviceName,
128: IN PDEVICE_OBJECT *ClassDeviceObject
129: );
130:
131: #if DBG
132:
133: VOID
134: MouDebugPrint(
135: ULONG DebugPrintLevel,
136: PCCHAR DebugMessage,
137: ...
138: );
139:
140: //
141: // Declare the global debug flag for this driver.
142: //
143:
144: ULONG MouseDebug = 0;
145: #define MouPrint(x) MouDebugPrint x
146: #else
147: #define MouPrint(x)
148: #endif
149:
150: NTSTATUS
151: MouDeterminePortsServiced(
152: IN PUNICODE_STRING BasePortName,
153: IN OUT PULONG NumberPortsServiced
154: );
155:
156: NTSTATUS
157: MouDeviceMapQueryCallback(
158: IN PWSTR ValueName,
159: IN ULONG ValueType,
160: IN PVOID ValueData,
161: IN ULONG ValueLength,
162: IN PVOID Context,
163: IN PVOID EntryContext
164: );
165:
166: NTSTATUS
167: MouEnableDisablePort(
168: IN PDEVICE_OBJECT DeviceObject,
169: IN BOOLEAN EnableFlag,
170: IN ULONG PortIndex
171: );
172:
173: VOID
174: MouInitializeDataQueue(
175: IN PVOID Context
176: );
177:
178: NTSTATUS
179: MouSendConnectRequest(
180: IN PDEVICE_OBJECT DeviceObject,
181: IN PVOID ServiceCallback,
182: IN ULONG PortIndex
183: );
184:
185: //
186: // Use the alloc_text pragma to specify the driver initialization routines
187: // (they can be paged out).
188: //
189:
190: #ifdef ALLOC_PRAGMA
191: #pragma alloc_text(init,DriverEntry)
192: #pragma alloc_text(init,MouConfiguration)
193: #pragma alloc_text(init,MouCreateClassObject)
194: #pragma alloc_text(init,MouDeterminePortsServiced)
195: #pragma alloc_text(init,MouDeviceMapQueryCallback)
196: #pragma alloc_text(init,MouConnectToPort)
197: #pragma alloc_text(init,MouSendConnectRequest)
198: #endif
199:
200:
201: NTSTATUS
202: DriverEntry(
203: IN PDRIVER_OBJECT DriverObject,
204: IN PUNICODE_STRING RegistryPath
205: )
206:
207: /*++
208:
209: Routine Description:
210:
211: This routine initializes the mouse class driver.
212:
213: Arguments:
214:
215: DriverObject - Pointer to driver object created by system.
216:
217: RegistryPath - Pointer to the Unicode name of the registry path
218: for this driver.
219:
220: Return Value:
221:
222: The function value is the final status from the initialization operation.
223:
224: --*/
225:
226: {
227: DEVICE_EXTENSION tmpDeviceExtension;
228: PDEVICE_OBJECT classDeviceObject = NULL;
229: PDEVICE_EXTENSION deviceExtension = NULL;
230: NTSTATUS status;
231: ULONG i;
232: ULONG portConnectionSuccessful;
233: UNICODE_STRING fullClassName;
234: UNICODE_STRING fullPortName;
235: UNICODE_STRING baseClassName;
236: UNICODE_STRING basePortName;
237: UNICODE_STRING deviceNameSuffix;
238: UNICODE_STRING registryPath;
239: PIO_ERROR_LOG_PACKET errorLogEntry;
240: ULONG uniqueErrorValue;
241: ULONG dumpCount = 0;
242: NTSTATUS errorCode = STATUS_SUCCESS;
243:
244: #define NAME_MAX 256
245: WCHAR baseClassBuffer[NAME_MAX];
246: WCHAR basePortBuffer[NAME_MAX];
247:
248: #define DUMP_COUNT 4
249: ULONG dumpData[DUMP_COUNT];
250:
251: MouPrint((1,"\n\nMOUCLASS-MouseClassInitialize: enter\n"));
252:
253: //
254: // Zero-initialize various structures.
255: //
256:
257: RtlZeroMemory(&tmpDeviceExtension, sizeof(DEVICE_EXTENSION));
258:
259: fullClassName.MaximumLength = 0;
260: fullPortName.MaximumLength = 0;
261: deviceNameSuffix.MaximumLength = 0;
262: registryPath.MaximumLength = 0;
263:
264: RtlZeroMemory(baseClassBuffer, NAME_MAX * sizeof(WCHAR));
265: baseClassName.Buffer = baseClassBuffer;
266: baseClassName.Length = 0;
267: baseClassName.MaximumLength = NAME_MAX * sizeof(WCHAR);
268:
269: RtlZeroMemory(basePortBuffer, NAME_MAX * sizeof(WCHAR));
270: basePortName.Buffer = basePortBuffer;
271: basePortName.Length = 0;
272: basePortName.MaximumLength = NAME_MAX * sizeof(WCHAR);
273:
274: //
275: // Need to ensure that the registry path is null-terminated.
276: // Allocate pool to hold a null-terminated copy of the path.
277: //
278:
279: registryPath.Buffer = ExAllocatePool(
280: PagedPool,
281: RegistryPath->Length + sizeof(UNICODE_NULL)
282: );
283:
284: if (!registryPath.Buffer) {
285: MouPrint((
286: 1,
287: "MOUCLASS-MouseClassInitialize: Couldn't allocate pool for registry path\n"
288: ));
289:
290: status = STATUS_UNSUCCESSFUL;
291: errorCode = MOUCLASS_INSUFFICIENT_RESOURCES;
292: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 2;
293: dumpData[0] = (ULONG) RegistryPath->Length + sizeof(UNICODE_NULL);
294: dumpCount = 1;
295: goto MouseClassInitializeExit;
296:
297: } else {
298:
299: registryPath.Length = RegistryPath->Length;
300: registryPath.MaximumLength =
301: registryPath.Length + sizeof(UNICODE_NULL);
302:
303: RtlZeroMemory(
304: registryPath.Buffer,
305: registryPath.MaximumLength
306: );
307:
308: RtlMoveMemory(
309: registryPath.Buffer,
310: RegistryPath->Buffer,
311: RegistryPath->Length
312: );
313:
314: }
315:
316: //
317: // Get the configuration information for this driver.
318: //
319:
320: MouConfiguration(&tmpDeviceExtension, ®istryPath, &baseClassName);
321:
322: //
323: // Set up space for the class's device object suffix. Note that
324: // we overallocate space for the suffix string because it is much
325: // easier than figuring out exactly how much space is required.
326: // The storage gets freed at the end of driver initialization, so
327: // who cares...
328: //
329:
330: RtlInitUnicodeString(&deviceNameSuffix, NULL);
331:
332: deviceNameSuffix.MaximumLength = POINTER_PORTS_MAXIMUM * sizeof(WCHAR);
333: deviceNameSuffix.MaximumLength += sizeof(UNICODE_NULL);
334:
335: deviceNameSuffix.Buffer = ExAllocatePool(
336: PagedPool,
337: deviceNameSuffix.MaximumLength
338: );
339:
340: if (!deviceNameSuffix.Buffer) {
341:
342: MouPrint((
343: 1,
344: "MOUCLASS-MouseClassInitialize: Couldn't allocate string for device object suffix\n"
345: ));
346:
347: status = STATUS_UNSUCCESSFUL;
348: errorCode = MOUCLASS_INSUFFICIENT_RESOURCES;
349: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 4;
350: dumpData[0] = (ULONG) deviceNameSuffix.MaximumLength;
351: dumpCount = 1;
352: goto MouseClassInitializeExit;
353:
354: }
355:
356: RtlZeroMemory(deviceNameSuffix.Buffer, deviceNameSuffix.MaximumLength);
357:
358: //
359: // Set up space for the class's full device object name.
360: //
361:
362: RtlInitUnicodeString(&fullClassName, NULL);
363:
364: fullClassName.MaximumLength = sizeof(L"\\Device\\") +
365: baseClassName.Length +
366: deviceNameSuffix.MaximumLength;
367:
368:
369: fullClassName.Buffer = ExAllocatePool(
370: PagedPool,
371: fullClassName.MaximumLength
372: );
373:
374: if (!fullClassName.Buffer) {
375:
376: MouPrint((
377: 1,
378: "MOUCLASS-MouseClassInitialize: Couldn't allocate string for device object name\n"
379: ));
380:
381: status = STATUS_UNSUCCESSFUL;
382: errorCode = MOUCLASS_INSUFFICIENT_RESOURCES;
383: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 6;
384: dumpData[0] = (ULONG) fullClassName.MaximumLength;
385: dumpCount = 1;
386: goto MouseClassInitializeExit;
387:
388: }
389:
390: RtlZeroMemory(fullClassName.Buffer, fullClassName.MaximumLength);
391: RtlAppendUnicodeToString(&fullClassName, L"\\Device\\");
392: RtlAppendUnicodeToString(&fullClassName, baseClassName.Buffer);
393:
394: //
395: // Set up the base device name for the associated port device.
396: // It is the same as the base class name, with "Class" replaced
397: // by "Port".
398: //
399:
400: RtlCopyUnicodeString(&basePortName, &baseClassName);
401:
402: basePortName.Length -= (sizeof(L"Class") - sizeof(UNICODE_NULL));
403:
404: RtlAppendUnicodeToString(&basePortName, L"Port");
405:
406: //
407: // Determine how many ports this class driver is to service.
408: //
409:
410: status = MouDeterminePortsServiced(&basePortName, &i);
411:
412: if (NT_SUCCESS(status)) {
413: if (i < tmpDeviceExtension.MaximumPortsServiced)
414: tmpDeviceExtension.MaximumPortsServiced = i;
415: }
416:
417: status = STATUS_SUCCESS;
418:
419: MouPrint((
420: 1,
421: "MOUCLASS-MouseClassInitialize: Will service %d port devices\n",
422: tmpDeviceExtension.MaximumPortsServiced
423: ));
424:
425: //
426: // Set up space for the full device object name for the ports.
427: //
428:
429: RtlInitUnicodeString(&fullPortName, NULL);
430:
431: fullPortName.MaximumLength = sizeof(L"\\Device\\") +
432: basePortName.Length +
433: deviceNameSuffix.MaximumLength;
434:
435: fullPortName.Buffer = ExAllocatePool(
436: PagedPool,
437: fullPortName.MaximumLength
438: );
439:
440: if (!fullPortName.Buffer) {
441:
442: MouPrint((
443: 1,
444: "MOUCLASS-MouseClassInitialize: Couldn't allocate string for port device object name\n"
445: ));
446:
447: status = STATUS_UNSUCCESSFUL;
448: errorCode = MOUCLASS_INSUFFICIENT_RESOURCES;
449: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 8;
450: dumpData[0] = (ULONG) fullPortName.MaximumLength;
451: dumpCount = 1;
452: goto MouseClassInitializeExit;
453:
454: }
455:
456: RtlZeroMemory(fullPortName.Buffer, fullPortName.MaximumLength);
457: RtlAppendUnicodeToString(&fullPortName, L"\\Device\\");
458: RtlAppendUnicodeToString(&fullPortName, basePortName.Buffer);
459:
460: //
461: // Allocate memory for the port device object pointer list.
462: //
463:
464: (PDEVICE_OBJECT *) tmpDeviceExtension.PortDeviceObjectList =
465: ExAllocatePool(
466: NonPagedPool,
467: sizeof(PDEVICE_OBJECT) * tmpDeviceExtension.MaximumPortsServiced
468: );
469:
470: if (!tmpDeviceExtension.PortDeviceObjectList) {
471:
472: //
473: // Could not allocate memory for the port device object pointers.
474: //
475:
476: MouPrint((
477: 1,
478: "MOUCLASS-MouseClassInitialize: Could not allocate PortDeviceObjectList for %ws\n",
479: fullClassName.Buffer
480: ));
481:
482: status = STATUS_INSUFFICIENT_RESOURCES;
483: errorCode = MOUCLASS_INSUFFICIENT_RESOURCES;
484: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 10;
485: dumpData[0] = (ULONG) (sizeof(PDEVICE_OBJECT) * tmpDeviceExtension.MaximumPortsServiced);
486: dumpData[1] = (ULONG) tmpDeviceExtension.MaximumPortsServiced;
487: dumpCount = 2;
488:
489: goto MouseClassInitializeExit;
490: }
491:
492: //
493: // Set up the class device object(s) to handle the associated
494: // port devices.
495: //
496:
497: portConnectionSuccessful = 0;
498:
499:
500: for (i = 0; i < tmpDeviceExtension.MaximumPortsServiced; i++) {
501:
502: //
503: // Append the suffix to the device object name string. E.g., turn
504: // \Device\PointerClass into \Device\PointerClass0. Then attempt
505: // to create the device object. If the device object already
506: // exists increment the suffix and try again.
507: //
508:
509: status = RtlIntegerToUnicodeString(
510: i,
511: 10,
512: &deviceNameSuffix
513: );
514:
515: if (!NT_SUCCESS(status)) {
516: continue;
517: }
518:
519: RtlAppendUnicodeStringToString(
520: &fullClassName,
521: &deviceNameSuffix
522: );
523:
524: RtlAppendUnicodeStringToString(
525: &fullPortName,
526: &deviceNameSuffix
527: );
528:
529: //
530: // Create the class device object.
531: //
532:
533: if (tmpDeviceExtension.ConnectOneClassToOnePort
534: || (classDeviceObject == NULL)) {
535: classDeviceObject = NULL;
536: status = MouCreateClassObject(
537: DriverObject,
538: &tmpDeviceExtension,
539: ®istryPath,
540: &fullClassName,
541: &baseClassName,
542: &classDeviceObject
543: );
544: }
545:
546: //
547: // Connect to the port device.
548: //
549:
550: if (NT_SUCCESS(status)) {
551: status = MouConnectToPort(
552: classDeviceObject,
553: &fullPortName,
554: i
555: );
556: }
557:
558: if (NT_SUCCESS(status)) {
559:
560: portConnectionSuccessful += 1;
561:
562: if (tmpDeviceExtension.ConnectOneClassToOnePort
563: || (portConnectionSuccessful == 1)) {
564:
565: //
566: // Load the device map information into the registry so
567: // that setup can determine which mouse class driver is active.
568: //
569:
570: status = RtlWriteRegistryValue(
571: RTL_REGISTRY_DEVICEMAP,
572: baseClassName.Buffer,
573: fullClassName.Buffer,
574: REG_SZ,
575: registryPath.Buffer,
576: registryPath.Length + sizeof(UNICODE_NULL)
577: );
578:
579: if (!NT_SUCCESS(status)) {
580:
581: MouPrint((
582: 1,
583: "MOUCLASS-MouseClassInitialize: Could not store %ws in DeviceMap\n",
584: fullClassName.Buffer
585: ));
586:
587:
588: //
589: // Stop making connections, and log an error.
590: //
591:
592: errorCode = MOUCLASS_NO_DEVICEMAP_CREATED;
593: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 14;
594: dumpCount = 0;
595:
596: //
597: // N.B. 'break' should cause execution to
598: // go to KeyboardClassInitializeExit (otherwise
599: // do an explicit 'goto').
600: //
601:
602: break;
603:
604: } else {
605:
606: MouPrint((
607: 1,
608: "MOUCLASS-MouseClassInitialize: Stored %ws in DeviceMap\n",
609: fullClassName.Buffer
610: ));
611: }
612: }
613:
614: //
615: // Try the next one.
616: //
617:
618: fullClassName.Length -= deviceNameSuffix.Length;
619: fullPortName.Length -= deviceNameSuffix.Length;
620:
621: } else if (tmpDeviceExtension.ConnectOneClassToOnePort) {
622:
623: //
624: // Stop doing 1:1 class-port connections if there is
625: // a failure.
626: //
627: // Note that if we are doing 1:many class-port connections
628: // and we encounter an error, we continue to try to connect
629: // to port devices.
630: //
631:
632: break;
633: }
634:
635: }
636:
637: if (!portConnectionSuccessful) {
638:
639: //
640: // The class driver was unable to connect to any port devices.
641: // Log a warning message.
642: //
643:
644: errorCode = MOUCLASS_NO_PORT_DEVICE_OBJECT;
645: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 18;
646:
647: }
648:
649: MouseClassInitializeExit:
650:
651: if (errorCode != STATUS_SUCCESS) {
652:
653: //
654: // The initialization failed in some way. Log an error.
655: //
656:
657: errorLogEntry = (PIO_ERROR_LOG_PACKET)
658: IoAllocateErrorLogEntry(
659: (classDeviceObject == NULL) ?
660: (PVOID) DriverObject : (PVOID) classDeviceObject,
661: (UCHAR) (sizeof(IO_ERROR_LOG_PACKET)
662: + (dumpCount * sizeof(ULONG)))
663: );
664:
665: if (errorLogEntry != NULL) {
666:
667: errorLogEntry->ErrorCode = errorCode;
668: errorLogEntry->DumpDataSize = dumpCount * sizeof(ULONG);
669: errorLogEntry->SequenceNumber = 0;
670: errorLogEntry->MajorFunctionCode = 0;
671: errorLogEntry->IoControlCode = 0;
672: errorLogEntry->RetryCount = 0;
673: errorLogEntry->UniqueErrorValue = uniqueErrorValue;
674: errorLogEntry->FinalStatus = status;
675: for (i = 0; i < dumpCount; i++)
676: errorLogEntry->DumpData[i] = dumpData[i];
677:
678: IoWriteErrorLogEntry(errorLogEntry);
679: }
680: }
681:
682: //
683: // Free the unicode strings.
684: //
685:
686: if (deviceNameSuffix.MaximumLength != 0)
687: ExFreePool(deviceNameSuffix.Buffer);
688: if (fullClassName.MaximumLength != 0)
689: ExFreePool(fullClassName.Buffer);
690: if (fullPortName.MaximumLength != 0)
691: ExFreePool(fullPortName.Buffer);
692: if (registryPath.MaximumLength != 0)
693: ExFreePool(registryPath.Buffer);
694:
695: if ((tmpDeviceExtension.ConnectOneClassToOnePort
696: && (!NT_SUCCESS(status))) ||
697: !portConnectionSuccessful) {
698:
699: //
700: // Clean up leftover resources. If we're doing 1:1 class-port
701: // connections, then we may have created a class device object
702: // for which the connect failed. If we're doing 1:many
703: // connections, we may have created a class device object but
704: // failed to make ANY connections. In either case, we
705: // free the ring buffer and delete the class device object.
706: //
707:
708: if (classDeviceObject) {
709: deviceExtension =
710: (PDEVICE_EXTENSION) classDeviceObject->DeviceExtension;
711: if ((deviceExtension) && (deviceExtension->InputData))
712: ExFreePool(deviceExtension->InputData);
713: IoDeleteDevice(classDeviceObject);
714: }
715: }
716:
717: //
718: // If we successfully connected to at least one pointer port device,
719: // this driver's initialization was successful.
720: //
721:
722: if (portConnectionSuccessful) {
723:
724: //
725: // Set up the device driver entry points.
726: //
727:
728: DriverObject->DriverStartIo = MouseClassStartIo;
729: DriverObject->MajorFunction[IRP_MJ_CREATE] = MouseClassOpenClose;
730: DriverObject->MajorFunction[IRP_MJ_CLOSE] = MouseClassOpenClose;
731: DriverObject->MajorFunction[IRP_MJ_READ] = MouseClassRead;
732: DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] =
733: MouseClassFlush;
734: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
735: MouseClassDeviceControl;
736: DriverObject->MajorFunction[IRP_MJ_CLEANUP] = MouseClassCleanup;
737:
738: //
739: // NOTE: Don't allow this driver to unload. Otherwise, we would set
740: // DriverObject->DriverUnload = MouseClassUnload.
741: //
742:
743: status = STATUS_SUCCESS;
744: }
745:
746: MouPrint((1,"MOUCLASS-MouseClassInitialize: exit\n"));
747:
748: return(status);
749:
750: }
751:
752: VOID
753: MouseClassCancel(
754: IN PDEVICE_OBJECT DeviceObject,
755: IN PIRP Irp
756: )
757:
758: /*++
759:
760: Routine Description:
761:
762: This routine is the class cancellation routine. It is
763: called from the I/O system when a request is cancelled. Read requests
764: are currently the only cancellable requests.
765:
766: N.B. The cancel spinlock is already held upon entry to this routine.
767:
768: Arguments:
769:
770: DeviceObject - Pointer to class device object.
771:
772: Irp - Pointer to the request packet to be cancelled.
773:
774: Return Value:
775:
776: None.
777:
778: --*/
779:
780: {
781: PDEVICE_EXTENSION deviceExtension;
782: KIRQL currentIrql;
783: KIRQL cancelIrql;
784:
785: MouPrint((2,"MOUCLASS-MouseClassCancel: enter\n"));
786:
787: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
788:
789: //
790: // Release the cancel spinlock and grab the mouse class spinlock (it
791: // protects the RequestIsPending flag).
792: //
793:
794: IoReleaseCancelSpinLock(Irp->CancelIrql);
795: KeAcquireSpinLock(&deviceExtension->SpinLock, ¤tIrql);
796:
797: if ((deviceExtension->RequestIsPending)
798: && (Irp == DeviceObject->CurrentIrp)) {
799:
800: //
801: // The current request is being cancelled. Set the CurrentIrp to
802: // null, clear the RequestIsPending flag, and release the mouse class
803: // spinlock before starting the next packet.
804: //
805:
806: DeviceObject->CurrentIrp = NULL;
807: deviceExtension->RequestIsPending = FALSE;
808: KeReleaseSpinLock(&deviceExtension->SpinLock, currentIrql);
809: IoStartNextPacket(DeviceObject, TRUE);
810: } else {
811:
812: //
813: // Cancel a request in the device queue. Reacquire the cancel
814: // spinlock, remove the request from the queue, and release the
815: // cancel spinlock. Release the mouse class spinlock.
816: //
817:
818: IoAcquireCancelSpinLock(&cancelIrql);
819: if (TRUE != KeRemoveEntryDeviceQueue(
820: &DeviceObject->DeviceQueue,
821: &Irp->Tail.Overlay.DeviceQueueEntry
822: )) {
823: MouPrint((
824: 1,
825: "MOUCLASS-MouseClassCancel: Irp 0x%x not in device queue?!?\n",
826: Irp
827: ));
828: }
829: IoReleaseCancelSpinLock(cancelIrql);
830: KeReleaseSpinLock(&deviceExtension->SpinLock, currentIrql);
831: }
832:
833: //
834: // Complete the request with STATUS_CANCELLED.
835: //
836:
837: Irp->IoStatus.Status = STATUS_CANCELLED;
838: Irp->IoStatus.Information = 0;
839: IoCompleteRequest (Irp, IO_MOUSE_INCREMENT);
840:
841: MouPrint((2,"MOUCLASS-MouseClassCancel: exit\n"));
842:
843: return;
844: }
845:
846: NTSTATUS
847: MouseClassCleanup(
848: IN PDEVICE_OBJECT DeviceObject,
849: IN PIRP Irp
850: )
851:
852: /*++
853:
854: Routine Description:
855:
856: This routine is the dispatch routine for cleanup requests.
857: All requests queued to the mouse class device (on behalf of
858: the thread for whom the cleanup request was generated) are
859: completed with STATUS_CANCELLED.
860:
861: Arguments:
862:
863: DeviceObject - Pointer to class device object.
864:
865: Irp - Pointer to the request packet.
866:
867: Return Value:
868:
869: Status is returned.
870:
871: --*/
872:
873: {
874: KIRQL spinlockIrql;
875: KIRQL cancelIrql;
876: PDEVICE_EXTENSION deviceExtension;
877: PKDEVICE_QUEUE_ENTRY packet;
878: PIRP currentIrp = NULL;
879: PIO_STACK_LOCATION irpSp;
880:
881: MouPrint((2,"MOUCLASS-MouseClassCleanup: enter\n"));
882:
883: deviceExtension = DeviceObject->DeviceExtension;
884:
885: //
886: // Acquire the mouse class spinlock and the cancel spinlock.
887: //
888:
889: KeAcquireSpinLock(&deviceExtension->SpinLock, &spinlockIrql);
890: IoAcquireCancelSpinLock(&cancelIrql);
891:
892: //
893: // Get a pointer to the current stack location for this request.
894: //
895:
896: irpSp = IoGetCurrentIrpStackLocation(Irp);
897:
898: //
899: // If the file object's FsContext is non-null, then the cleanup
900: // request is being executed by the trusted subsystem. Since the
901: // trusted subsystem is the only one with sufficient privilege to make
902: // Read requests to the driver, and since only Read requests get queued
903: // to the device queue, a cleanup request from the trusted subsystem is
904: // handled by cancelling all queued requests.
905: //
906: // If the FsContext is null, there is no cleanup work to perform
907: // (only read requests can be cancelled).
908: //
909: // NOTE: If this driver is to allow more than one trusted subsystem
910: // to make read requests to the same device object some day in
911: // the future, then there needs to be a mechanism that
912: // allows Cleanup to remove only those queued requests that
913: // were made by threads using the same FileObject as the
914: // file object in the Cleanup request.
915: //
916:
917: if (irpSp->FileObject->FsContext) {
918:
919: //
920: // Indicate that the cleanup routine has been called (StartIo cares
921: // about this).
922: //
923:
924: deviceExtension->CleanupWasInitiated = TRUE;
925:
926: //
927: // Complete all requests queued by this thread with STATUS_CANCELLED.
928: // Start with the real CurrentIrp, and run down the list of requests
929: // in the device queue. Be sure to set the real CurrentIrp to NULL
930: // and the RequestIsPending flag to FALSE, so that the class
931: // service callback routine won't attempt to complete CurrentIrp.
932: // Note that we can really only trust CurrentIrp when RequestIsPending.
933: //
934:
935: currentIrp = DeviceObject->CurrentIrp;
936: DeviceObject->CurrentIrp = NULL;
937: deviceExtension->RequestIsPending = FALSE;
938:
939: while (currentIrp != NULL) {
940:
941: //
942: // Remove the CurrentIrp from the cancellable state.
943: //
944: //
945:
946: IoSetCancelRoutine(currentIrp, NULL);
947:
948: //
949: // Set Status to CANCELLED, release the spinlocks,
950: // and complete the request. Note that the IRQL is reset to
951: // DISPATCH_LEVEL when we release the spinlocks.
952: //
953:
954: currentIrp->IoStatus.Status = STATUS_CANCELLED;
955: currentIrp->IoStatus.Information = 0;
956:
957: IoReleaseCancelSpinLock(cancelIrql);
958: KeReleaseSpinLock(&deviceExtension->SpinLock, spinlockIrql);
959: IoCompleteRequest(currentIrp, IO_MOUSE_INCREMENT);
960:
961: //
962: // Reacquire the spinlocks.
963: //
964:
965: KeAcquireSpinLock(&deviceExtension->SpinLock, &spinlockIrql);
966: IoAcquireCancelSpinLock(&cancelIrql);
967:
968: //
969: // Dequeue the next packet (IRP) from the device work queue.
970: //
971:
972: packet = KeRemoveDeviceQueue(&DeviceObject->DeviceQueue);
973: if (packet != NULL) {
974: currentIrp =
975: CONTAINING_RECORD(packet, IRP, Tail.Overlay.DeviceQueueEntry);
976: } else {
977: currentIrp = (PIRP) NULL;
978: }
979:
980: } // end while
981: }
982:
983: //
984: // Release the spinlocks and lower IRQL.
985: //
986:
987: IoReleaseCancelSpinLock(cancelIrql);
988: KeReleaseSpinLock(&deviceExtension->SpinLock, spinlockIrql);
989:
990: //
991: // Complete the cleanup request with STATUS_SUCCESS.
992: //
993:
994: Irp->IoStatus.Status = STATUS_SUCCESS;
995: Irp->IoStatus.Information = 0;
996: IoCompleteRequest (Irp, IO_NO_INCREMENT);
997:
998: MouPrint((2,"MOUCLASS-MouseClassCleanup: exit\n"));
999:
1000: return(STATUS_SUCCESS);
1001:
1002: }
1003:
1004: NTSTATUS
1005: MouseClassDeviceControl(
1006: IN PDEVICE_OBJECT DeviceObject,
1007: IN PIRP Irp
1008: )
1009:
1010: /*++
1011:
1012: Routine Description:
1013:
1014: This routine is the dispatch routine for device control requests.
1015: All device control subfunctions are passed, asynchronously, to the
1016: connected port driver for processing and completion.
1017:
1018: Arguments:
1019:
1020: DeviceObject - Pointer to class device object.
1021:
1022: Irp - Pointer to the request packet.
1023:
1024: Return Value:
1025:
1026: Status is returned.
1027:
1028: --*/
1029:
1030: {
1031: PIO_STACK_LOCATION irpSp;
1032: PIO_STACK_LOCATION nextSp;
1033: PDEVICE_EXTENSION deviceExtension;
1034: NTSTATUS status = STATUS_SUCCESS;
1035: ULONG unitId;
1036:
1037: MouPrint((2,"MOUCLASS-MouseClassDeviceControl: enter\n"));
1038:
1039: //
1040: // Get a pointer to the device extension.
1041: //
1042:
1043: deviceExtension = DeviceObject->DeviceExtension;
1044:
1045: //
1046: // Get a pointer to the current parameters for this request. The
1047: // information is contained in the current stack location.
1048: //
1049:
1050: irpSp = IoGetCurrentIrpStackLocation(Irp);
1051:
1052: //
1053: // Check for adequate input buffer length. The input buffer
1054: // should, at a minimum, contain the unit ID specifying one of
1055: // the connected port devices. If there is no input buffer (i.e.,
1056: // the input buffer length is zero), then we assume the unit ID
1057: // is zero (for backwards compatibility).
1058: //
1059:
1060: if (irpSp->Parameters.DeviceIoControl.InputBufferLength == 0) {
1061: unitId = 0;
1062: } else if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
1063: sizeof(MOUSE_UNIT_ID_PARAMETER)) {
1064: status = STATUS_BUFFER_TOO_SMALL;
1065:
1066: } else {
1067: unitId = ((PMOUSE_UNIT_ID_PARAMETER)
1068: Irp->AssociatedIrp.SystemBuffer)->UnitId;
1069: if (unitId >= deviceExtension->MaximumPortsServiced) {
1070: status = STATUS_INVALID_PARAMETER;
1071: }
1072: }
1073:
1074: if (NT_SUCCESS(status)) {
1075:
1076: //
1077: // Pass the device control request on to the port driver,
1078: // asynchronously. Get the next IRP stack location and copy the
1079: // input parameters to the next stack location. Change the major
1080: // function to internal device control.
1081: //
1082:
1083: nextSp = IoGetNextIrpStackLocation(Irp);
1084: ASSERT(nextSp != NULL);
1085: nextSp->Parameters.DeviceIoControl =
1086: irpSp->Parameters.DeviceIoControl;
1087: nextSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
1088:
1089: //
1090: // Mark the packet pending.
1091: //
1092:
1093: IoMarkIrpPending(Irp);
1094:
1095: //
1096: // Pass the IRP on to the connected port device (specified by
1097: // the unit ID). The port device driver will process the request.
1098: //
1099:
1100: status = IoCallDriver(
1101: deviceExtension->PortDeviceObjectList[unitId],
1102: Irp
1103: );
1104: } else {
1105:
1106: //
1107: // Complete the request.
1108: //
1109:
1110: Irp->IoStatus.Status = status;
1111: Irp->IoStatus.Information = 0;
1112: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1113: }
1114:
1115: MouPrint((2,"MOUCLASS-MouseClassDeviceControl: exit\n"));
1116:
1117: return(status);
1118:
1119: }
1120:
1121: NTSTATUS
1122: MouseClassFlush(
1123: IN PDEVICE_OBJECT DeviceObject,
1124: IN PIRP Irp
1125: )
1126:
1127: /*++
1128:
1129: Routine Description:
1130:
1131: This routine is the dispatch routine for flush requests. The class
1132: input data queue is reinitialized.
1133:
1134: Arguments:
1135:
1136: DeviceObject - Pointer to class device object.
1137:
1138: Irp - Pointer to the request packet.
1139:
1140: Return Value:
1141:
1142: Status is returned.
1143:
1144: --*/
1145:
1146: {
1147: PDEVICE_EXTENSION deviceExtension;
1148: NTSTATUS status = STATUS_SUCCESS;
1149:
1150: MouPrint((2,"MOUCLASS-MouseClassFlush: enter\n"));
1151:
1152: //
1153: // Get a pointer to the device extension.
1154: //
1155:
1156: deviceExtension = DeviceObject->DeviceExtension;
1157:
1158: //
1159: // Initialize mouse class input data queue.
1160: //
1161:
1162: MouInitializeDataQueue((PVOID)deviceExtension);
1163:
1164: //
1165: // Complete the request and return status.
1166: //
1167:
1168: Irp->IoStatus.Status = status;
1169: Irp->IoStatus.Information = 0;
1170: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1171:
1172: MouPrint((2,"MOUCLASS-MouseClassFlush: exit\n"));
1173:
1174: return(status);
1175:
1176: } // end MouseClassFlush
1177:
1178: NTSTATUS
1179: MouseClassOpenClose(
1180: IN PDEVICE_OBJECT DeviceObject,
1181: IN PIRP Irp
1182: )
1183:
1184: /*++
1185:
1186: Routine Description:
1187:
1188: This routine is the dispatch routine for create/open and close requests.
1189: Open/close requests are completed here.
1190:
1191: Arguments:
1192:
1193: DeviceObject - Pointer to class device object.
1194:
1195: Irp - Pointer to the request packet.
1196:
1197: Return Value:
1198:
1199: Status is returned.
1200:
1201: --*/
1202:
1203: {
1204: PIO_STACK_LOCATION irpSp;
1205: PDEVICE_EXTENSION deviceExtension;
1206: KIRQL oldIrql;
1207: BOOLEAN enableFlag = FALSE;
1208: NTSTATUS status = STATUS_SUCCESS;
1209: PIO_ERROR_LOG_PACKET errorLogEntry;
1210: BOOLEAN SomeEnableDisableSucceeded = FALSE;
1211: ULONG i;
1212:
1213: MouPrint((2,"MOUCLASS-MouseClassOpenClose: enter\n"));
1214:
1215: //
1216: // Get a pointer to the device extension.
1217: //
1218:
1219: deviceExtension = DeviceObject->DeviceExtension;
1220:
1221: //
1222: // Get a pointer to the current parameters for this request. The
1223: // information is contained in the current stack location.
1224: //
1225:
1226: irpSp = IoGetCurrentIrpStackLocation(Irp);
1227:
1228: //
1229: // Case on the function that is being performed by the requestor.
1230: //
1231:
1232: switch (irpSp->MajorFunction) {
1233:
1234: //
1235: // For the create/open operation, send a MOUSE_ENABLE internal
1236: // device control request to the port driver to enable interrupts.
1237: //
1238:
1239: case IRP_MJ_CREATE:
1240:
1241: //
1242: // First, if the requestor is the trusted subsystem (the single
1243: // reader), reset the the cleanup indicator and set the file
1244: // object's FsContext to non-null (MouseClassRead uses
1245: // FsContext to determine if the requestor has sufficient
1246: // privilege to perform the read operation).
1247: //
1248:
1249: if (SeSinglePrivilegeCheck(RtlConvertLongToLargeInteger(
1250: SE_TCB_PRIVILEGE),
1251: Irp->RequestorMode
1252: )) {
1253:
1254: KeAcquireSpinLock(&deviceExtension->SpinLock, &oldIrql);
1255: deviceExtension->CleanupWasInitiated = FALSE;
1256: irpSp->FileObject->FsContext = (PVOID) 1;
1257: KeReleaseSpinLock(&deviceExtension->SpinLock, oldIrql);
1258: }
1259:
1260: enableFlag = TRUE;
1261:
1262: break;
1263:
1264: //
1265: // For the close operation, send a MOUSE_DISABLE internal device
1266: // control request to the port driver to disable interrupts.
1267: //
1268:
1269: case IRP_MJ_CLOSE:
1270:
1271: break;
1272: }
1273:
1274: //
1275: // Enable/disable interrupts via port driver.
1276: //
1277:
1278: for (i = 0; i < deviceExtension->MaximumPortsServiced; i++) {
1279:
1280: status = MouEnableDisablePort(DeviceObject, enableFlag, i);
1281:
1282: if (status != STATUS_SUCCESS) {
1283:
1284: MouPrint((
1285: 0,
1286: "MOUCLASS-MouseClassOpenClose: Could not enable/disable interrupts for port device object @ 0x%x\n",
1287: deviceExtension->PortDeviceObjectList[i]
1288: ));
1289:
1290: //
1291: // Log an error.
1292: //
1293:
1294: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1295: DeviceObject,
1296: sizeof(IO_ERROR_LOG_PACKET)
1297: );
1298:
1299: if (errorLogEntry != NULL) {
1300:
1301: errorLogEntry->ErrorCode =
1302: enableFlag? MOUCLASS_PORT_INTERRUPTS_NOT_ENABLED:
1303: MOUCLASS_PORT_INTERRUPTS_NOT_DISABLED;
1304: errorLogEntry->SequenceNumber = 0;
1305: errorLogEntry->MajorFunctionCode = irpSp->MajorFunction;
1306: errorLogEntry->IoControlCode = 0;
1307: errorLogEntry->RetryCount = 0;
1308: errorLogEntry->UniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 120;
1309: errorLogEntry->FinalStatus = status;
1310:
1311: IoWriteErrorLogEntry(errorLogEntry);
1312: }
1313:
1314: } else {
1315: SomeEnableDisableSucceeded = TRUE;
1316: }
1317: }
1318:
1319: //
1320: // Complete the request and return status.
1321: //
1322: // NOTE: We complete the request successfully if any one of the
1323: // connected port devices successfully handled the request.
1324: // The RIT only knows about one pointing device.
1325: //
1326:
1327: if (SomeEnableDisableSucceeded) {
1328: status = STATUS_SUCCESS;
1329: }
1330:
1331: Irp->IoStatus.Status = status;
1332: Irp->IoStatus.Information = 0;
1333: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1334:
1335: MouPrint((2,"MOUCLASS-MouseClassOpenClose: exit\n"));
1336:
1337: return(status);
1338: }
1339:
1340: NTSTATUS
1341: MouseClassRead(
1342: IN PDEVICE_OBJECT DeviceObject,
1343: IN PIRP Irp
1344: )
1345:
1346: /*++
1347:
1348: Routine Description:
1349:
1350: This routine is the dispatch routine for read requests. Valid read
1351: requests are marked pending, and started via IoStartPacket.
1352:
1353: Arguments:
1354:
1355: DeviceObject - Pointer to class device object.
1356:
1357: Irp - Pointer to the request packet.
1358:
1359: Return Value:
1360:
1361: Status is returned.
1362:
1363: --*/
1364:
1365: {
1366: NTSTATUS status;
1367: PIO_STACK_LOCATION irpSp;
1368:
1369: MouPrint((2,"MOUCLASS-MouseClassRead: enter\n"));
1370:
1371: irpSp = IoGetCurrentIrpStackLocation(Irp);
1372:
1373: //
1374: // Validate the read request parameters. The read length should be an
1375: // integral number of MOUSE_INPUT_DATA structures.
1376: //
1377:
1378:
1379: if (irpSp->Parameters.Read.Length == 0) {
1380: status = STATUS_SUCCESS;
1381: }
1382: else if (irpSp->Parameters.Read.Length % sizeof(MOUSE_INPUT_DATA)) {
1383: status = STATUS_BUFFER_TOO_SMALL;
1384: }
1385: else if (irpSp->FileObject->FsContext) {
1386:
1387: //
1388: // If the file object's FsContext is non-null, then we've already
1389: // done the Read privilege check once before for this thread. Skip
1390: // the privilege check.
1391: //
1392:
1393: status = STATUS_PENDING;
1394: }
1395: else {
1396:
1397: //
1398: // We only allow a trusted subsystem with the appropriate privilege
1399: // level to execute a Read call.
1400: //
1401:
1402: status = STATUS_PRIVILEGE_NOT_HELD;
1403:
1404:
1405: }
1406:
1407: //
1408: // If status is pending, mark the packet pending and start the packet
1409: // in a cancellable state. Otherwise, complete the request.
1410: //
1411:
1412: Irp->IoStatus.Status = status;
1413: Irp->IoStatus.Information = 0;
1414: if (status == STATUS_PENDING) {
1415: IoMarkIrpPending(Irp);
1416: IoStartPacket(DeviceObject, Irp, (PULONG)NULL, MouseClassCancel);
1417: } else {
1418: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1419: }
1420:
1421: MouPrint((2,"MOUCLASS-MouseClassRead: exit\n"));
1422:
1423: return(status);
1424:
1425: }
1426:
1427: VOID
1428: MouseClassServiceCallback(
1429: IN PDEVICE_OBJECT DeviceObject,
1430: IN PMOUSE_INPUT_DATA InputDataStart,
1431: IN PMOUSE_INPUT_DATA InputDataEnd,
1432: IN OUT PULONG InputDataConsumed
1433: )
1434:
1435: /*++
1436:
1437: Routine Description:
1438:
1439: This routine is the class service callback routine. It is
1440: called from the port driver's interrupt service DPC. If there is an
1441: outstanding read request, the request is satisfied from the port input
1442: data queue. Unsolicited mouse input is moved from the port input
1443: data queue to the class input data queue.
1444:
1445: N.B. This routine is entered at DISPATCH_LEVEL IRQL from the port
1446: driver's ISR DPC routine.
1447:
1448: Arguments:
1449:
1450: DeviceObject - Pointer to class device object.
1451:
1452: InputDataStart - Pointer to the start of the data in the port input
1453: data queue.
1454:
1455: InputDataEnd - Points one input data structure past the end of the
1456: valid port input data.
1457:
1458: InputDataConsumed - Pointer to storage in which the number of input
1459: data structures consumed by this call is returned.
1460:
1461: NOTE: Could pull the duplicate code out into a called procedure.
1462:
1463: Return Value:
1464:
1465: None.
1466:
1467: --*/
1468:
1469: {
1470: PDEVICE_EXTENSION deviceExtension;
1471: PIO_STACK_LOCATION irpSp;
1472: PIRP irp;
1473: KIRQL cancelIrql;
1474: ULONG bytesInQueue;
1475: ULONG bytesToMove;
1476: ULONG moveSize;
1477: BOOLEAN satisfiedPendingReadRequest = FALSE;
1478: PIO_ERROR_LOG_PACKET errorLogEntry;
1479:
1480: MouPrint((2,"MOUCLASS-MouseClassServiceCallback: enter\n"));
1481:
1482: deviceExtension = DeviceObject->DeviceExtension;
1483: bytesInQueue = (PCHAR) InputDataEnd - (PCHAR) InputDataStart;
1484: moveSize = 0;
1485: *InputDataConsumed = 0;
1486:
1487: //
1488: // Acquire the spinlock that protects the class device extension
1489: // (so we can look at RequestIsPending synchronously). If there is
1490: // a pending read request, satisfy it.
1491: //
1492: // N.B. We can use KeAcquireSpinLockAtDpcLevel, instead of
1493: // KeAcquireSpinLock, because this routine is already running
1494: // at DISPATCH_IRQL.
1495: //
1496:
1497: KeAcquireSpinLockAtDpcLevel(&deviceExtension->SpinLock);
1498:
1499: if (deviceExtension->RequestIsPending) {
1500:
1501: //
1502: // Acquire the cancel spinlock, remove the request from the
1503: // cancellable state, and free the cancel spinlock.
1504: //
1505:
1506: IoAcquireCancelSpinLock(&cancelIrql);
1507: irp = DeviceObject->CurrentIrp;
1508: IoSetCancelRoutine(irp, NULL);
1509: DeviceObject->CurrentIrp = NULL;
1510: IoReleaseCancelSpinLock(cancelIrql);
1511:
1512: //
1513: // An outstanding read request exists. Clear the RequestIsPending
1514: // flag to indicate there is no longer an outstanding read request
1515: // pending.
1516: //
1517:
1518: deviceExtension->RequestIsPending = FALSE;
1519:
1520: //
1521: // Copy as much of the input data possible from the port input
1522: // data queue to the SystemBuffer to satisfy the read.
1523: //
1524:
1525: irpSp = IoGetCurrentIrpStackLocation(irp);
1526: bytesToMove = irpSp->Parameters.Read.Length;
1527: moveSize = (bytesInQueue < bytesToMove) ?
1528: bytesInQueue:bytesToMove;
1529: *InputDataConsumed += (moveSize / sizeof(MOUSE_INPUT_DATA));
1530:
1531: MouPrint((
1532: 3,
1533: "MOUCLASS-MouseClassServiceCallback: port queue length 0x%lx, read length 0x%lx\n",
1534: bytesInQueue,
1535: bytesToMove
1536: ));
1537: MouPrint((
1538: 3,
1539: "MOUCLASS-MouseClassServiceCallback: number of bytes to move from port to SystemBuffer 0x%lx\n",
1540: moveSize
1541: ));
1542: MouPrint((
1543: 3,
1544: "MOUCLASS-MouseClassServiceCallback: move bytes from 0x%lx to 0x%lx\n",
1545: (PCHAR) InputDataStart,
1546: irp->AssociatedIrp.SystemBuffer
1547: ));
1548:
1549: RtlMoveMemory(
1550: irp->AssociatedIrp.SystemBuffer,
1551: (PCHAR) InputDataStart,
1552: moveSize
1553: );
1554:
1555: //
1556: // Set the flag so that we start the next packet and complete
1557: // this read request (with STATUS_SUCCESS) prior to return.
1558: //
1559:
1560: irp->IoStatus.Status = STATUS_SUCCESS;
1561: irp->IoStatus.Information = moveSize;
1562: irpSp->Parameters.Read.Length = moveSize;
1563: satisfiedPendingReadRequest = TRUE;
1564:
1565: }
1566:
1567: //
1568: // If there is still data in the port input data queue, move it to the class
1569: // input data queue.
1570: //
1571:
1572: InputDataStart = (PMOUSE_INPUT_DATA) ((PCHAR) InputDataStart + moveSize);
1573: moveSize = bytesInQueue - moveSize;
1574:
1575: MouPrint((
1576: 3,
1577: "MOUCLASS-MouseClassServiceCallback: bytes remaining after move to SystemBuffer 0x%lx\n",
1578: moveSize
1579: ));
1580:
1581: if (moveSize > 0) {
1582:
1583: //
1584: // Move the remaining data from the port input data queue to
1585: // the class input data queue. The move will happen in two
1586: // parts in the case where the class input data buffer wraps.
1587: //
1588:
1589: bytesInQueue =
1590: deviceExtension->MouseAttributes.InputDataQueueLength -
1591: (deviceExtension->InputCount * sizeof(MOUSE_INPUT_DATA));
1592: bytesToMove = moveSize;
1593:
1594: MouPrint((
1595: 3,
1596: "MOUCLASS-MouseClassServiceCallback: unused bytes in class queue 0x%lx, remaining bytes in port queue 0x%lx\n",
1597: bytesInQueue,
1598: bytesToMove
1599: ));
1600:
1601: if (bytesInQueue == 0) {
1602:
1603: //
1604: // Refuse to move any bytes that would cause a class input data
1605: // queue overflow. Just drop the bytes on the floor, and
1606: // log an overrun error.
1607: //
1608:
1609: MouPrint((
1610: 1,
1611: "MOUCLASS-MouseClassServiceCallback: Class input data queue OVERRUN\n"
1612: ));
1613:
1614: if (deviceExtension->OkayToLogOverflow) {
1615:
1616: //
1617: // Log an error.
1618: //
1619:
1620: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1621: DeviceObject,
1622: sizeof(IO_ERROR_LOG_PACKET)
1623: + (2 * sizeof(ULONG))
1624: );
1625:
1626: if (errorLogEntry != NULL) {
1627:
1628: errorLogEntry->ErrorCode = MOUCLASS_MOU_BUFFER_OVERFLOW;
1629: errorLogEntry->DumpDataSize = 2 * sizeof(ULONG);
1630: errorLogEntry->SequenceNumber = 0;
1631: errorLogEntry->MajorFunctionCode = 0;
1632: errorLogEntry->IoControlCode = 0;
1633: errorLogEntry->RetryCount = 0;
1634: errorLogEntry->UniqueErrorValue =
1635: MOUSE_ERROR_VALUE_BASE + 210;
1636: errorLogEntry->FinalStatus = 0;
1637: errorLogEntry->DumpData[0] = bytesToMove;
1638: errorLogEntry->DumpData[1] =
1639: deviceExtension->MouseAttributes.InputDataQueueLength;
1640:
1641: IoWriteErrorLogEntry(errorLogEntry);
1642: }
1643:
1644: deviceExtension->OkayToLogOverflow = FALSE;
1645: }
1646:
1647: } else {
1648:
1649: //
1650: // There is room in the class input data queue, so move
1651: // the remaining port input data to it.
1652: //
1653: // bytesToMove <- MIN(Number of unused bytes in class input data
1654: // queue, Number of bytes remaining in port
1655: // input queue).
1656: // This is the total number of bytes that actually will move from
1657: // the port input data queue to the class input data queue.
1658: //
1659:
1660:
1661: bytesToMove = (bytesInQueue < bytesToMove) ?
1662: bytesInQueue:bytesToMove;
1663:
1664: //
1665: // bytesInQueue <- Number of unused bytes from insertion pointer to
1666: // the end of the class input data queue (i.e., until the buffer
1667: // wraps).
1668: //
1669:
1670: bytesInQueue = ((PCHAR) deviceExtension->InputData +
1671: deviceExtension->MouseAttributes.InputDataQueueLength) -
1672: (PCHAR) deviceExtension->DataIn;
1673: MouPrint((
1674: 3,
1675: "MOUCLASS-MouseClassServiceCallback: total number of bytes to move to class queue 0x%lx\n",
1676: bytesToMove
1677: ));
1678:
1679: MouPrint((
1680: 3,
1681: "MOUCLASS-MouseClassServiceCallback: number of bytes to end of class buffer 0x%lx\n",
1682: bytesInQueue
1683: ));
1684:
1685: //
1686: // moveSize <- Number of bytes to handle in the first move.
1687: //
1688:
1689: moveSize = (bytesToMove < bytesInQueue) ?
1690: bytesToMove:bytesInQueue;
1691: MouPrint((
1692: 3,
1693: "MOUCLASS-MouseClassServiceCallback: number of bytes in first move to class 0x%lx\n",
1694: moveSize
1695: ));
1696:
1697: //
1698: // Do the move from the port data queue to the class data queue.
1699: //
1700:
1701: MouPrint((
1702: 3,
1703: "MOUCLASS-MouseClassServiceCallback: move bytes from 0x%lx to 0x%lx\n",
1704: (PCHAR) InputDataStart,
1705: (PCHAR) deviceExtension->DataIn
1706: ));
1707:
1708: RtlMoveMemory(
1709: (PCHAR) deviceExtension->DataIn,
1710: (PCHAR) InputDataStart,
1711: moveSize
1712: );
1713:
1714: //
1715: // Increment the port data queue pointer and the class input
1716: // data queue insertion pointer. Wrap the insertion pointer,
1717: // if necessary.
1718: //
1719:
1720: InputDataStart = (PMOUSE_INPUT_DATA)
1721: (((PCHAR) InputDataStart) + moveSize);
1722: deviceExtension->DataIn = (PMOUSE_INPUT_DATA)
1723: (((PCHAR) deviceExtension->DataIn) + moveSize);
1724: if ((PCHAR) deviceExtension->DataIn >=
1725: ((PCHAR) deviceExtension->InputData +
1726: deviceExtension->MouseAttributes.InputDataQueueLength)) {
1727: deviceExtension->DataIn = deviceExtension->InputData;
1728: }
1729:
1730: if ((bytesToMove - moveSize) > 0) {
1731:
1732: //
1733: // Special case. The data must wrap in the class input data buffer.
1734: // Copy the rest of the port input data into the beginning of the
1735: // class input data queue.
1736: //
1737:
1738: //
1739: // moveSize <- Number of bytes to handle in the second move.
1740: //
1741:
1742: moveSize = bytesToMove - moveSize;
1743:
1744: //
1745: // Do the move from the port data queue to the class data queue.
1746: //
1747:
1748: MouPrint((
1749: 3,
1750: "MOUCLASS-MouseClassServiceCallback: number of bytes in second move to class 0x%lx\n",
1751: moveSize
1752: ));
1753: MouPrint((
1754: 3,
1755: "MOUCLASS-MouseClassServiceCallback: move bytes from 0x%lx to 0x%lx\n",
1756: (PCHAR) InputDataStart,
1757: (PCHAR) deviceExtension->DataIn
1758: ));
1759:
1760: RtlMoveMemory(
1761: (PCHAR) deviceExtension->DataIn,
1762: (PCHAR) InputDataStart,
1763: moveSize
1764: );
1765:
1766: //
1767: // Update the class input data queue insertion pointer.
1768: //
1769:
1770: deviceExtension->DataIn = (PMOUSE_INPUT_DATA)
1771: (((PCHAR) deviceExtension->DataIn) + moveSize);
1772: }
1773:
1774: //
1775: // Update the input data queue counter.
1776: //
1777:
1778: deviceExtension->InputCount +=
1779: (bytesToMove / sizeof(MOUSE_INPUT_DATA));
1780: *InputDataConsumed += (bytesToMove / sizeof(MOUSE_INPUT_DATA));
1781:
1782: MouPrint((
1783: 3,
1784: "MOUCLASS-MouseClassServiceCallback: changed InputCount to %ld entries in the class queue\n",
1785: deviceExtension->InputCount
1786: ));
1787: MouPrint((
1788: 3,
1789: "MOUCLASS-MouseClassServiceCallback: DataIn 0x%lx, DataOut 0x%lx\n",
1790: deviceExtension->DataIn,
1791: deviceExtension->DataOut
1792: ));
1793: MouPrint((
1794: 3,
1795: "MOUCLASS-MouseClassServiceCallback: Input data items consumed = %d\n",
1796: *InputDataConsumed
1797: ));
1798: }
1799: }
1800:
1801: //
1802: // Release the class input data queue spinlock.
1803: //
1804:
1805: KeReleaseSpinLockFromDpcLevel(&deviceExtension->SpinLock);
1806:
1807: //
1808: // If we satisfied an outstanding read request, start the next
1809: // packet and complete the request.
1810: //
1811:
1812: if (satisfiedPendingReadRequest) {
1813:
1814: IoStartNextPacket(DeviceObject, TRUE);
1815: IoCompleteRequest(irp, IO_MOUSE_INCREMENT);
1816: }
1817:
1818: MouPrint((2,"MOUCLASS-MouseClassServiceCallback: exit\n"));
1819:
1820: return;
1821:
1822: }
1823:
1824: VOID
1825: MouseClassStartIo(
1826: IN PDEVICE_OBJECT DeviceObject,
1827: IN PIRP Irp
1828: )
1829:
1830: /*++
1831:
1832: Routine Description:
1833:
1834: This routine is the StartIo routine. It is invoked to start a Read
1835: request. If the class input data queue contains input data, the input
1836: data is copied to the SystemBuffer to satisfy the read.
1837:
1838: N.B. Requests enter MouseClassStartIo in a cancellable state. Also,
1839: there is an implicit assumption that only read requests are
1840: queued to the device queue (and handled by StartIo). If this
1841: changes in the future, the MouseClassCleanup routine will
1842: be impacted.
1843:
1844: NOTE: Could pull the duplicate code out into a called procedure.
1845:
1846: Arguments:
1847:
1848: DeviceObject - Pointer to class device object.
1849:
1850: Irp - Pointer to the request packet.
1851:
1852: Return Value:
1853:
1854: None.
1855:
1856: --*/
1857:
1858: {
1859: PDEVICE_EXTENSION deviceExtension;
1860: PIO_STACK_LOCATION irpSp;
1861: KIRQL cancelIrql;
1862: PCHAR destination;
1863: ULONG bytesInQueue;
1864: ULONG bytesToMove;
1865: ULONG moveSize;
1866:
1867: MouPrint((2,"MOUCLASS-MouseClassStartIo: enter\n"));
1868:
1869: deviceExtension = DeviceObject->DeviceExtension;
1870:
1871: //
1872: // Bump the error log sequence number.
1873: //
1874:
1875: deviceExtension->SequenceNumber += 1;
1876:
1877: //
1878: // Acquire the spinlock to protect the input data queue and associated
1879: // pointers. Note that StartIo is already running at DISPATCH_LEVEL
1880: // IRQL, so we can use KeAcquireSpinLockAtDpcLevel instead of
1881: // KeAcquireSpinLock.
1882: //
1883:
1884: KeAcquireSpinLockAtDpcLevel(&deviceExtension->SpinLock);
1885:
1886: //
1887: // Acquire the cancel spinlock and verify that the Irp has not been
1888: // cancelled and that cleanup is not in progress.
1889: //
1890:
1891: IoAcquireCancelSpinLock(&cancelIrql);
1892: if (Irp->Cancel || deviceExtension->CleanupWasInitiated) {
1893: IoReleaseCancelSpinLock(cancelIrql);
1894: KeReleaseSpinLockFromDpcLevel(&deviceExtension->SpinLock);
1895: return;
1896: }
1897:
1898: MouPrint((
1899: 3,
1900: "MOUCLASS-MouseClassStartIo: DataIn 0x%lx, DataOut 0x%lx\n",
1901: deviceExtension->DataIn, deviceExtension->DataOut
1902: ));
1903:
1904: MouPrint((
1905: 3,
1906: "MOUCLASS-MouseClassStartIo: entries in queue %ld\n",
1907: deviceExtension->InputCount
1908: ));
1909:
1910: //
1911: // If the input data queue is non-empty, satisfy the read request.
1912: // Otherwise, hold the request pending.
1913: //
1914:
1915: if (deviceExtension->InputCount != 0) {
1916:
1917: //
1918: // Copy as much of the input data as possible from the class input
1919: // data queue to the SystemBuffer to satisfy the read. It may be
1920: // necessary to copy the data in two chunks (i.e., if the circular
1921: // queue wraps).
1922: // First, remove the request from the cancellable state, and free the
1923: // cancel spinlock.
1924: //
1925:
1926: IoSetCancelRoutine(Irp, NULL);
1927: DeviceObject->CurrentIrp = NULL;
1928: IoReleaseCancelSpinLock(cancelIrql);
1929:
1930: irpSp = IoGetCurrentIrpStackLocation(Irp);
1931:
1932: //
1933: // bytesToMove <- MIN(Number of filled bytes in class input data queue,
1934: // Requested read length).
1935: //
1936:
1937: bytesInQueue = deviceExtension->InputCount *
1938: sizeof(MOUSE_INPUT_DATA);
1939: bytesToMove = irpSp->Parameters.Read.Length;
1940: MouPrint((
1941: 3,
1942: "MOUCLASS-MouseClassStartIo: queue size 0x%lx, read length 0x%lx\n",
1943: bytesInQueue,
1944: bytesToMove
1945: ));
1946: bytesToMove = (bytesInQueue < bytesToMove) ?
1947: bytesInQueue:bytesToMove;
1948:
1949: //
1950: // moveSize <- MIN(Number of bytes to be moved from the class queue,
1951: // Number of bytes to end of class input data queue).
1952: //
1953:
1954: bytesInQueue = ((PCHAR) deviceExtension->InputData +
1955: deviceExtension->MouseAttributes.InputDataQueueLength) -
1956: (PCHAR) deviceExtension->DataOut;
1957: moveSize = (bytesToMove < bytesInQueue) ?
1958: bytesToMove:bytesInQueue;
1959: MouPrint((
1960: 3,
1961: "MOUCLASS-MouseClassStartIo: bytes to end of queue 0x%lx\n",
1962: bytesInQueue
1963: ));
1964:
1965: //
1966: // Move bytes from the class input data queue to SystemBuffer, until
1967: // the request is satisfied or we wrap the class input data buffer.
1968: //
1969:
1970: destination = Irp->AssociatedIrp.SystemBuffer;
1971: MouPrint((
1972: 3,
1973: "MOUCLASS-MouseClassStartIo: number of bytes in first move 0x%lx\n",
1974: moveSize
1975: ));
1976: MouPrint((
1977: 3,
1978: "MOUCLASS-MouseClassStartIo: move bytes from 0x%lx to 0x%lx\n",
1979: (PCHAR) deviceExtension->DataOut,
1980: destination
1981: ));
1982:
1983: RtlMoveMemory(
1984: destination,
1985: (PCHAR) deviceExtension->DataOut,
1986: moveSize
1987: );
1988: destination += moveSize;
1989:
1990: //
1991: // If the data wraps in the class input data buffer, copy the rest
1992: // of the data from the start of the input data queue
1993: // buffer through the end of the queued data.
1994: //
1995:
1996: if ((bytesToMove - moveSize) > 0) {
1997:
1998: //
1999: // moveSize <- Remaining number bytes to move.
2000: //
2001:
2002: moveSize = bytesToMove - moveSize;
2003:
2004: //
2005: // Move the bytes from the class input data queue to SystemBuffer.
2006: //
2007:
2008: MouPrint((
2009: 3,
2010: "MOUCLASS-MouseClassStartIo: number of bytes in second move 0x%lx\n",
2011: moveSize
2012: ));
2013: MouPrint((
2014: 3,
2015: "MOUCLASS-MouseClassStartIo: move bytes from 0x%lx to 0x%lx\n",
2016: (PCHAR) deviceExtension->InputData,
2017: destination
2018: ));
2019:
2020: RtlMoveMemory(
2021: destination,
2022: (PCHAR) deviceExtension->InputData,
2023: moveSize
2024: );
2025:
2026: //
2027: // Update the class input data queue removal pointer.
2028: //
2029:
2030: deviceExtension->DataOut = (PMOUSE_INPUT_DATA)
2031: (((PCHAR) deviceExtension->InputData) + moveSize);
2032: } else {
2033:
2034: //
2035: // Update the input data queue removal pointer.
2036: //
2037:
2038: deviceExtension->DataOut = (PMOUSE_INPUT_DATA)
2039: (((PCHAR) deviceExtension->DataOut) + moveSize);
2040: }
2041:
2042: //
2043: // Update the class input data queue InputCount.
2044: //
2045:
2046: deviceExtension->InputCount -=
2047: (bytesToMove / sizeof(MOUSE_INPUT_DATA));
2048:
2049: if (deviceExtension->InputCount == 0) {
2050:
2051: //
2052: // Reset the flag that determines whether it is time to log
2053: // queue overflow errors. We don't want to log errors too often.
2054: // Instead, log an error on the first overflow that occurs after
2055: // the ring buffer has been emptied, and then stop logging errors
2056: // until it gets cleared out and overflows again.
2057: //
2058:
2059: MouPrint((
2060: 1,
2061: "MOUCLASS-MouseClassStartIo: Okay to log overflow\n"
2062: ));
2063: deviceExtension->OkayToLogOverflow = TRUE;
2064: }
2065:
2066: MouPrint((
2067: 3,
2068: "MOUCLASS-MouseClassStartIo: new DataIn 0x%lx, DataOut 0x%lx\n",
2069: deviceExtension->DataIn,
2070: deviceExtension->DataOut
2071: ));
2072: MouPrint((
2073: 3,
2074: "MOUCLASS-MouseClassStartIo: new InputCount %ld\n",
2075: deviceExtension->InputCount
2076: ));
2077:
2078: //
2079: // Clear the RequestIsPending flag to indicate this request is
2080: // not held pending.
2081: //
2082:
2083: deviceExtension->RequestIsPending = FALSE;
2084:
2085: //
2086: // Release the class input data queue spinlock.
2087: //
2088:
2089: KeReleaseSpinLockFromDpcLevel(&deviceExtension->SpinLock);
2090:
2091: //
2092: // Start the next packet, and complete this read request
2093: // with STATUS_SUCCESS.
2094: //
2095:
2096: Irp->IoStatus.Status = STATUS_SUCCESS;
2097: Irp->IoStatus.Information = bytesToMove;
2098: irpSp->Parameters.Read.Length = bytesToMove;
2099:
2100: IoStartNextPacket(DeviceObject, TRUE);
2101: IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
2102:
2103: } else {
2104:
2105: //
2106: // Set the RequestIsPending flag to indicate this request is
2107: // held pending for the callback routine to complete.
2108: //
2109:
2110: deviceExtension->RequestIsPending = TRUE;
2111:
2112: //
2113: // Hold the read request pending. It remains in the cancellable
2114: // state. When new input is received, the class service
2115: // callback routine will eventually complete the request. For now,
2116: // merely free the cancel spinlock and the class input data queue
2117: // spinlock.
2118: //
2119:
2120: IoReleaseCancelSpinLock(cancelIrql);
2121: KeReleaseSpinLockFromDpcLevel(&deviceExtension->SpinLock);
2122: }
2123:
2124: MouPrint((2,"MOUCLASS-MouseClassStartIo: exit\n"));
2125:
2126: return;
2127:
2128: }
2129:
2130: VOID
2131: MouseClassUnload(
2132: IN PDRIVER_OBJECT DriverObject
2133: )
2134:
2135: /*++
2136:
2137: Routine Description:
2138:
2139: This routine is the class driver unload routine.
2140:
2141: NOTE: Not currently implemented.
2142:
2143: Arguments:
2144:
2145: DeviceObject - Pointer to class device object.
2146:
2147: Return Value:
2148:
2149: None.
2150:
2151: --*/
2152:
2153: {
2154: UNREFERENCED_PARAMETER(DriverObject);
2155:
2156: MouPrint((2,"MOUCLASS-MouseClassUnload: enter\n"));
2157: MouPrint((2,"MOUCLASS-MouseClassUnload: exit\n"));
2158:
2159: return;
2160: }
2161:
2162: VOID
2163: MouConfiguration(
2164: IN PDEVICE_EXTENSION DeviceExtension,
2165: IN PUNICODE_STRING RegistryPath,
2166: IN PUNICODE_STRING DeviceName
2167: )
2168:
2169: /*++
2170:
2171: Routine Description:
2172:
2173: This routine stores the configuration information for this device.
2174:
2175: Arguments:
2176:
2177: DeviceExtension - Pointer to the device extension.
2178:
2179: RegistryPath - Pointer to the null-terminated Unicode name of the
2180: registry path for this driver.
2181:
2182: DeviceName - Pointer to the Unicode string that will receive
2183: the port device name.
2184:
2185: Return Value:
2186:
2187: None. As a side-effect, sets fields in DeviceExtension->MouseAttributes.
2188:
2189: --*/
2190:
2191: {
2192: PRTL_QUERY_REGISTRY_TABLE parameters = NULL;
2193: UNICODE_STRING parametersPath;
2194: ULONG defaultDataQueueSize = DATA_QUEUE_SIZE;
2195: ULONG defaultMaximumPortsServiced = 1;
2196: ULONG defaultConnectMultiplePorts = 0;
2197: NTSTATUS status = STATUS_SUCCESS;
2198: UNICODE_STRING defaultUnicodeName;
2199: PWSTR path = NULL;
2200: USHORT queriesPlusOne = 5;
2201:
2202: parametersPath.Buffer = NULL;
2203:
2204: //
2205: // Registry path is already null-terminated, so just use it.
2206: //
2207:
2208: path = RegistryPath->Buffer;
2209:
2210: if (NT_SUCCESS(status)) {
2211:
2212: //
2213: // Allocate the Rtl query table.
2214: //
2215:
2216: parameters = ExAllocatePool(
2217: PagedPool,
2218: sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne
2219: );
2220:
2221: if (!parameters) {
2222:
2223: MouPrint((
2224: 1,
2225: "MOUCLASS-MouConfiguration: Couldn't allocate table for Rtl query to parameters for %ws\n",
2226: path
2227: ));
2228:
2229: status = STATUS_UNSUCCESSFUL;
2230:
2231: } else {
2232:
2233: RtlZeroMemory(
2234: parameters,
2235: sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne
2236: );
2237:
2238: //
2239: // Form a path to this driver's Parameters subkey.
2240: //
2241:
2242: RtlInitUnicodeString(
2243: ¶metersPath,
2244: NULL
2245: );
2246:
2247: parametersPath.MaximumLength = RegistryPath->Length +
2248: sizeof(L"\\Parameters");
2249:
2250: parametersPath.Buffer = ExAllocatePool(
2251: PagedPool,
2252: parametersPath.MaximumLength
2253: );
2254:
2255: if (!parametersPath.Buffer) {
2256:
2257: MouPrint((
2258: 1,
2259: "MOUCLASS-MouConfiguration: Couldn't allocate string for path to parameters for %ws\n",
2260: path
2261: ));
2262:
2263: status = STATUS_UNSUCCESSFUL;
2264:
2265: }
2266: }
2267: }
2268:
2269: if (NT_SUCCESS(status)) {
2270:
2271: //
2272: // Form the parameters path.
2273: //
2274:
2275: RtlZeroMemory(
2276: parametersPath.Buffer,
2277: parametersPath.MaximumLength
2278: );
2279: RtlAppendUnicodeToString(
2280: ¶metersPath,
2281: path
2282: );
2283: RtlAppendUnicodeToString(
2284: ¶metersPath,
2285: L"\\Parameters"
2286: );
2287:
2288: MouPrint((
2289: 1,
2290: "MOUCLASS-MouConfiguration: parameters path is %ws\n",
2291: parametersPath.Buffer
2292: ));
2293:
2294: //
2295: // Form the default pointer class device name, in case it is not
2296: // specified in the registry.
2297: //
2298:
2299: RtlInitUnicodeString(
2300: &defaultUnicodeName,
2301: DD_POINTER_CLASS_BASE_NAME_U
2302: );
2303:
2304: //
2305: // Gather all of the "user specified" information from
2306: // the registry.
2307: //
2308:
2309: parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
2310: parameters[0].Name = L"MouseDataQueueSize";
2311: parameters[0].EntryContext =
2312: &DeviceExtension->MouseAttributes.InputDataQueueLength;
2313: parameters[0].DefaultType = REG_DWORD;
2314: parameters[0].DefaultData = &defaultDataQueueSize;
2315: parameters[0].DefaultLength = sizeof(ULONG);
2316:
2317: parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
2318: parameters[1].Name = L"MaximumPortsServiced";
2319: parameters[1].EntryContext =
2320: &DeviceExtension->MaximumPortsServiced;
2321: parameters[1].DefaultType = REG_DWORD;
2322: parameters[1].DefaultData = &defaultMaximumPortsServiced;
2323: parameters[1].DefaultLength = sizeof(ULONG);
2324:
2325: parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
2326: parameters[2].Name = L"PointerDeviceBaseName";
2327: parameters[2].EntryContext = DeviceName;
2328: parameters[2].DefaultType = REG_SZ;
2329: parameters[2].DefaultData = defaultUnicodeName.Buffer;
2330: parameters[2].DefaultLength = 0;
2331:
2332: parameters[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
2333: parameters[3].Name = L"ConnectMultiplePorts";
2334: parameters[3].EntryContext =
2335: &DeviceExtension->ConnectOneClassToOnePort;
2336: parameters[3].DefaultType = REG_DWORD;
2337: parameters[3].DefaultData = &defaultConnectMultiplePorts;
2338: parameters[3].DefaultLength = sizeof(ULONG);
2339:
2340: status = RtlQueryRegistryValues(
2341: RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
2342: parametersPath.Buffer,
2343: parameters,
2344: NULL,
2345: NULL
2346: );
2347:
2348: if (!NT_SUCCESS(status)) {
2349: MouPrint((
2350: 1,
2351: "MOUCLASS-MouConfiguration: RtlQueryRegistryValues failed with 0x%x\n",
2352: status
2353: ));
2354: }
2355: }
2356:
2357: if (!NT_SUCCESS(status)) {
2358:
2359: //
2360: // Go ahead and assign driver defaults.
2361: //
2362:
2363: DeviceExtension->MouseAttributes.InputDataQueueLength =
2364: defaultDataQueueSize;
2365: DeviceExtension->MaximumPortsServiced = defaultMaximumPortsServiced;
2366: DeviceExtension->ConnectOneClassToOnePort =
2367: !defaultConnectMultiplePorts;
2368: RtlCopyUnicodeString(DeviceName, &defaultUnicodeName);
2369: }
2370:
2371: MouPrint((
2372: 1,
2373: "MOUCLASS-MouConfiguration: Mouse class base name = %ws\n",
2374: DeviceName->Buffer
2375: ));
2376:
2377: if (DeviceExtension->MouseAttributes.InputDataQueueLength == 0) {
2378:
2379: MouPrint((
2380: 1,
2381: "MOUCLASS-MouConfiguration: overriding MouseInputDataQueueLength = 0x%x\n",
2382: DeviceExtension->MouseAttributes.InputDataQueueLength
2383: ));
2384:
2385: DeviceExtension->MouseAttributes.InputDataQueueLength =
2386: defaultDataQueueSize;
2387: }
2388:
2389: DeviceExtension->MouseAttributes.InputDataQueueLength *=
2390: sizeof(MOUSE_INPUT_DATA);
2391:
2392: MouPrint((
2393: 1,
2394: "MOUCLASS-MouConfiguration: MouseInputDataQueueLength = 0x%x\n",
2395: DeviceExtension->MouseAttributes.InputDataQueueLength
2396: ));
2397:
2398: MouPrint((
2399: 1,
2400: "MOUCLASS-MouConfiguration: MaximumPortsServiced = %d\n",
2401: DeviceExtension->MaximumPortsServiced
2402: ));
2403:
2404: //
2405: // Invert the flag that specifies the type of class/port connections.
2406: // We used it in the RtlQuery call in an inverted fashion.
2407: //
2408:
2409: DeviceExtension->ConnectOneClassToOnePort =
2410: !DeviceExtension->ConnectOneClassToOnePort;
2411:
2412: MouPrint((
2413: 1,
2414: "MOUCLASS-MouConfiguration: Connection Type = %d\n",
2415: DeviceExtension->ConnectOneClassToOnePort
2416: ));
2417:
2418: //
2419: // Free the allocated memory before returning.
2420: //
2421:
2422: if (parametersPath.Buffer)
2423: ExFreePool(parametersPath.Buffer);
2424: if (parameters)
2425: ExFreePool(parameters);
2426:
2427: }
2428:
2429: NTSTATUS
2430: MouConnectToPort(
2431: IN PDEVICE_OBJECT ClassDeviceObject,
2432: IN PUNICODE_STRING FullPortName,
2433: IN ULONG PortIndex
2434: )
2435:
2436: /*++
2437:
2438: Routine Description:
2439:
2440: This routine creates the mouse class device object and connects
2441: to the port device.
2442:
2443:
2444: Arguments:
2445:
2446: ClassDeviceObject - Pointer to the device object for the class device.
2447:
2448: FullPortName - Pointer to the Unicode string that is the full path name
2449: for the port device object.
2450:
2451: PortIndex - The index into the PortDeviceObjectList[] for the
2452: current connection.
2453:
2454: Return Value:
2455:
2456: The function value is the final status from the operation.
2457:
2458: --*/
2459:
2460: {
2461: PDEVICE_EXTENSION deviceExtension = NULL;
2462: NTSTATUS status;
2463: PFILE_OBJECT fileObject = NULL;
2464: PDEVICE_OBJECT portDeviceObject = NULL;
2465: PIO_ERROR_LOG_PACKET errorLogEntry;
2466: ULONG uniqueErrorValue;
2467: NTSTATUS errorCode = STATUS_SUCCESS;
2468:
2469: MouPrint((1,"\n\nMOUCLASS-MouConnectToPort: enter\n"));
2470:
2471: //
2472: // Get a pointer to the port device object.
2473: //
2474:
2475: MouPrint((
2476: 2,
2477: "MOUCLASS-MouConnectToPort: Pointer port name %ws\n",
2478: FullPortName->Buffer
2479: ));
2480:
2481: status = IoGetDeviceObjectPointer(
2482: FullPortName,
2483: FILE_READ_ATTRIBUTES,
2484: &fileObject,
2485: &portDeviceObject
2486: );
2487:
2488: if (status != STATUS_SUCCESS) {
2489: MouPrint((
2490: 1,
2491: "MOUCLASS-MouConnectToPort: Could not get port device object %ws\n",
2492: FullPortName->Buffer
2493: ));
2494:
2495: goto MouConnectToPortExit;
2496: }
2497:
2498: deviceExtension =
2499: (PDEVICE_EXTENSION) ClassDeviceObject->DeviceExtension;
2500: deviceExtension->PortDeviceObjectList[PortIndex] = portDeviceObject;
2501:
2502: //
2503: // Set the IRP stack size (add 1 for the class layer).
2504: //
2505: // NOTE: This is a bit funky for 1:many connections (we end up setting
2506: // StackSize each time through this routine). Note also that
2507: // there is an assumption that the number of layers in the
2508: // class/port driver model is always the same (i.e., if there is
2509: // a layer between the class and the port driver for one device,
2510: // that is true for every device).
2511: //
2512:
2513: ClassDeviceObject->StackSize =
2514: (CCHAR) deviceExtension->PortDeviceObjectList[PortIndex]->StackSize + 1;
2515:
2516: //
2517: // Connect to port device.
2518: //
2519:
2520: status = MouSendConnectRequest(
2521: ClassDeviceObject,
2522: (PVOID)MouseClassServiceCallback,
2523: PortIndex
2524: );
2525:
2526: if (status != STATUS_SUCCESS) {
2527: MouPrint((
2528: 1,
2529: "MOUCLASS-MouConnectToPort: Could not connect to port device %ws\n",
2530: FullPortName->Buffer
2531: ));
2532:
2533: //
2534: // Log an error.
2535: //
2536:
2537: errorCode = MOUCLASS_NO_PORT_CONNECT;
2538: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 30;
2539: goto MouConnectToPortExit;
2540: }
2541:
2542: MouConnectToPortExit:
2543:
2544: if (status != STATUS_SUCCESS) {
2545:
2546: //
2547: // Some part of the initialization failed. Log an error, and
2548: // clean up the resources for the failed part of the initialization.
2549: //
2550:
2551: if (errorCode != STATUS_SUCCESS) {
2552: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
2553: ClassDeviceObject,
2554: sizeof(IO_ERROR_LOG_PACKET)
2555: );
2556:
2557: if (errorLogEntry != NULL) {
2558:
2559: errorLogEntry->ErrorCode = errorCode;
2560: errorLogEntry->SequenceNumber = 0;
2561: errorLogEntry->MajorFunctionCode = 0;
2562: errorLogEntry->IoControlCode = 0;
2563: errorLogEntry->RetryCount = 0;
2564: errorLogEntry->UniqueErrorValue = uniqueErrorValue;
2565: errorLogEntry->FinalStatus = status;
2566:
2567: IoWriteErrorLogEntry(errorLogEntry);
2568: }
2569: }
2570:
2571: if (fileObject) {
2572: ObDereferenceObject(fileObject);
2573: }
2574:
2575: //
2576: // We count on the caller to free the ring buffer and delete
2577: // the class device object.
2578: //
2579: }
2580:
2581: MouPrint((1,"MOUCLASS-MouConnectToPort: exit\n"));
2582:
2583: return(status);
2584:
2585: }
2586:
2587: NTSTATUS
2588: MouCreateClassObject(
2589: IN PDRIVER_OBJECT DriverObject,
2590: IN PDEVICE_EXTENSION TmpDeviceExtension,
2591: IN PUNICODE_STRING RegistryPath,
2592: IN PUNICODE_STRING FullDeviceName,
2593: IN PUNICODE_STRING BaseDeviceName,
2594: IN PDEVICE_OBJECT *ClassDeviceObject
2595: )
2596:
2597: /*++
2598:
2599: Routine Description:
2600:
2601: This routine creates the mouse class device object.
2602:
2603:
2604: Arguments:
2605:
2606: DriverObject - Pointer to driver object created by system.
2607:
2608: TmpDeviceExtension - Pointer to the template device extension.
2609:
2610: RegistryPath - Pointer to the null-terminated Unicode name of the
2611: registry path for this driver.
2612:
2613: FullDeviceName - Pointer to the Unicode string that is the full path name
2614: for the class device object.
2615:
2616: BaseDeviceName - Pointer to the Unicode string that is the base path name
2617: for the class device.
2618:
2619: ClassDeviceObject - Pointer to a pointer to the class device object.
2620:
2621: Return Value:
2622:
2623: The function value is the final status from the operation.
2624:
2625: --*/
2626:
2627: {
2628: PDEVICE_EXTENSION deviceExtension = NULL;
2629: NTSTATUS status;
2630: PIO_ERROR_LOG_PACKET errorLogEntry;
2631: ULONG uniqueErrorValue;
2632: NTSTATUS errorCode = STATUS_SUCCESS;
2633:
2634: MouPrint((1,"\n\nMOUCLASS-MouCreateClassObject: enter\n"));
2635:
2636: //
2637: // Create a non-exclusive device object for the mouse class device.
2638: //
2639:
2640: MouPrint((
2641: 1,
2642: "MOUCLASS-MouCreateClassObject: Creating device object named %ws\n",
2643: FullDeviceName->Buffer
2644: ));
2645:
2646: status = IoCreateDevice(
2647: DriverObject,
2648: sizeof(DEVICE_EXTENSION),
2649: FullDeviceName,
2650: FILE_DEVICE_MOUSE,
2651: 0,
2652: FALSE,
2653: ClassDeviceObject
2654: );
2655:
2656: if (!NT_SUCCESS(status)) {
2657: MouPrint((
2658: 1,
2659: "MOUCLASS-MouCreateClassObject: Could not create class device object = %ws\n",
2660: FullDeviceName->Buffer
2661: ));
2662: goto MouCreateClassObjectExit;
2663:
2664: }
2665:
2666: //
2667: // Do buffered I/O. I.e., the I/O system will copy to/from user data
2668: // from/to a system buffer.
2669: //
2670:
2671: (*ClassDeviceObject)->Flags |= DO_BUFFERED_IO;
2672: deviceExtension =
2673: (PDEVICE_EXTENSION)(*ClassDeviceObject)->DeviceExtension;
2674: *deviceExtension = *TmpDeviceExtension;
2675:
2676: //
2677: // Initialize spin lock for critical sections.
2678: //
2679:
2680: KeInitializeSpinLock(&deviceExtension->SpinLock);
2681:
2682: //
2683: // Initialize mouse class flags to indicate there is no outstanding
2684: // read request pending and cleanup has not been initiated.
2685: //
2686:
2687: deviceExtension->RequestIsPending = FALSE;
2688: deviceExtension->CleanupWasInitiated = FALSE;
2689:
2690: //
2691: // Allocate the ring buffer for the mouse class input data.
2692: //
2693:
2694: deviceExtension->InputData =
2695: ExAllocatePool(
2696: NonPagedPool,
2697: deviceExtension->MouseAttributes.InputDataQueueLength
2698: );
2699:
2700: if (!deviceExtension->InputData) {
2701:
2702: //
2703: // Could not allocate memory for the mouse class data queue.
2704: //
2705:
2706: MouPrint((
2707: 1,
2708: "MOUCLASS-MouCreateClassObject: Could not allocate input data queue for %ws\n",
2709: FullDeviceName->Buffer
2710: ));
2711:
2712: status = STATUS_INSUFFICIENT_RESOURCES;
2713:
2714: //
2715: // Log an error.
2716: //
2717:
2718: errorCode = MOUCLASS_NO_BUFFER_ALLOCATED;
2719: uniqueErrorValue = MOUSE_ERROR_VALUE_BASE + 20;
2720: goto MouCreateClassObjectExit;
2721: }
2722:
2723: //
2724: // Initialize mouse class input data queue.
2725: //
2726:
2727: MouInitializeDataQueue((PVOID)deviceExtension);
2728:
2729: MouCreateClassObjectExit:
2730:
2731: if (status != STATUS_SUCCESS) {
2732:
2733: //
2734: // Some part of the initialization failed. Log an error, and
2735: // clean up the resources for the failed part of the initialization.
2736: //
2737:
2738: if (errorCode != STATUS_SUCCESS) {
2739: errorLogEntry = (PIO_ERROR_LOG_PACKET)
2740: IoAllocateErrorLogEntry(
2741: (*ClassDeviceObject == NULL) ?
2742: (PVOID) DriverObject : (PVOID) *ClassDeviceObject,
2743: sizeof(IO_ERROR_LOG_PACKET)
2744: );
2745:
2746: if (errorLogEntry != NULL) {
2747:
2748: errorLogEntry->ErrorCode = errorCode;
2749: errorLogEntry->SequenceNumber = 0;
2750: errorLogEntry->MajorFunctionCode = 0;
2751: errorLogEntry->IoControlCode = 0;
2752: errorLogEntry->RetryCount = 0;
2753: errorLogEntry->UniqueErrorValue = uniqueErrorValue;
2754: errorLogEntry->FinalStatus = status;
2755:
2756: IoWriteErrorLogEntry(errorLogEntry);
2757: }
2758: }
2759:
2760: if ((deviceExtension) && (deviceExtension->InputData))
2761: ExFreePool(deviceExtension->InputData);
2762: if (*ClassDeviceObject) {
2763: IoDeleteDevice(*ClassDeviceObject);
2764: *ClassDeviceObject = NULL;
2765: }
2766: }
2767:
2768: MouPrint((1,"MOUCLASS-MouCreateClassObject: exit\n"));
2769:
2770: return(status);
2771:
2772: }
2773:
2774: #if DBG
2775:
2776: VOID
2777: MouDebugPrint(
2778: ULONG DebugPrintLevel,
2779: PCCHAR DebugMessage,
2780: ...
2781: )
2782:
2783: /*++
2784:
2785: Routine Description:
2786:
2787: Debug print routine.
2788:
2789: Arguments:
2790:
2791: Debug print level between 0 and 3, with 3 being the most verbose.
2792:
2793: Return Value:
2794:
2795: None.
2796:
2797: --*/
2798:
2799: {
2800: va_list ap;
2801:
2802: va_start(ap, DebugMessage);
2803:
2804: if (DebugPrintLevel <= MouseDebug) {
2805:
2806: char buffer[256];
2807:
2808: (VOID) vsprintf(buffer, DebugMessage, ap);
2809:
2810: DbgPrint(buffer);
2811: }
2812:
2813: va_end(ap);
2814:
2815: }
2816: #endif
2817:
2818: NTSTATUS
2819: MouDeterminePortsServiced(
2820: IN PUNICODE_STRING BasePortName,
2821: IN OUT PULONG NumberPortsServiced
2822: )
2823:
2824: /*++
2825:
2826: Routine Description:
2827:
2828: This routine reads the DEVICEMAP portion of the registry to determine
2829: how many ports the class driver is to service. Depending on the
2830: value of DeviceExtension->ConnectOneClassToOnePort, the class driver
2831: will eventually create one device object per port device serviced, or
2832: one class device object that connects to multiple port device objects.
2833:
2834: Assumptions:
2835:
2836: 1. If the base device name for the class driver is "PointerClass",
2837: ^^^^^
2838: then the port drivers it can service are found under the
2839: "PointerPort" subkey in the DEVICEMAP portion of the registry.
2840: ^^^^
2841:
2842: 2. The port device objects are created with suffixes in strictly
2843: ascending order, starting with suffix 0. E.g.,
2844: \Device\PointerPort0 indicates the first pointer port device,
2845: \Device\PointerPort1 the second, and so on. There are no gaps
2846: in the list.
2847:
2848: 3. If ConnectOneClassToOnePort is non-zero, there is a 1:1
2849: correspondence between class device objects and port device
2850: objects. I.e., \Device\PointerClass0 will connect to
2851: \Device\PointerPort0, \Device\PointerClass1 to
2852: \Device\PointerPort1, and so on.
2853:
2854: 4. If ConnectOneClassToOnePort is zero, there is a 1:many
2855: correspondence between class device objects and port device
2856: objects. I.e., \Device\PointerClass0 will connect to
2857: \Device\PointerPort0, and \Device\PointerPort1, and so on.
2858:
2859:
2860: Note that for Product 1, the Raw Input Thread (Windows USER) will
2861: only deign to open and read from one pointing device. Hence, it is
2862: safe to make simplifying assumptions because the driver is basically
2863: providing much more functionality than the RIT will use.
2864:
2865: Arguments:
2866:
2867: BasePortName - Pointer to the Unicode string that is the base path name
2868: for the port device.
2869:
2870: NumberPortsServiced - Pointer to storage that will receive the
2871: number of ports this class driver should service.
2872:
2873: Return Value:
2874:
2875: The function value is the final status from the operation.
2876:
2877: --*/
2878:
2879: {
2880:
2881: NTSTATUS status;
2882: PRTL_QUERY_REGISTRY_TABLE registryTable = NULL;
2883: USHORT queriesPlusOne = 2;
2884:
2885: //
2886: // Initialize the result.
2887: //
2888:
2889: *NumberPortsServiced = 0;
2890:
2891: //
2892: // Allocate the Rtl query table.
2893: //
2894:
2895: registryTable = ExAllocatePool(
2896: PagedPool,
2897: sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne
2898: );
2899:
2900: if (!registryTable) {
2901:
2902: MouPrint((
2903: 1,
2904: "MOUCLASS-MouDeterminePortsServiced: Couldn't allocate table for Rtl query\n"
2905: ));
2906:
2907: status = STATUS_UNSUCCESSFUL;
2908:
2909: } else {
2910:
2911: RtlZeroMemory(
2912: registryTable,
2913: sizeof(RTL_QUERY_REGISTRY_TABLE) * queriesPlusOne
2914: );
2915:
2916: //
2917: // Set things up so that MouDeviceMapQueryCallback will be
2918: // called once for every value in the pointer port section
2919: // of the registry's hardware devicemap.
2920: //
2921:
2922: registryTable[0].QueryRoutine = MouDeviceMapQueryCallback;
2923: registryTable[0].Name = NULL;
2924:
2925: status = RtlQueryRegistryValues(
2926: RTL_REGISTRY_DEVICEMAP | RTL_REGISTRY_OPTIONAL,
2927: BasePortName->Buffer,
2928: registryTable,
2929: NumberPortsServiced,
2930: NULL
2931: );
2932:
2933: if (!NT_SUCCESS(status)) {
2934: MouPrint((
2935: 1,
2936: "MOUCLASS-MouDeterminePortsServiced: RtlQueryRegistryValues failed with 0x%x\n",
2937: status
2938: ));
2939: }
2940:
2941: ExFreePool(registryTable);
2942: }
2943:
2944: return(status);
2945: }
2946:
2947: NTSTATUS
2948: MouDeviceMapQueryCallback(
2949: IN PWSTR ValueName,
2950: IN ULONG ValueType,
2951: IN PVOID ValueData,
2952: IN ULONG ValueLength,
2953: IN PVOID Context,
2954: IN PVOID EntryContext
2955: )
2956:
2957: /*++
2958:
2959: Routine Description:
2960:
2961: This is the callout routine specified in a call to
2962: RtlQueryRegistryValues. It increments the value pointed
2963: to by the Context parameter.
2964:
2965: Arguments:
2966:
2967: ValueName - Unused.
2968:
2969: ValueType - Unused.
2970:
2971: ValueData - Unused.
2972:
2973: ValueLength - Unused.
2974:
2975: Context - Pointer to a count of the number of times this
2976: routine has been called. This is the number of ports
2977: the class driver needs to service.
2978:
2979: EntryContext - Unused.
2980:
2981: Return Value:
2982:
2983: The function value is the final status from the operation.
2984:
2985: --*/
2986:
2987: {
2988: *(PULONG)Context += 1;
2989:
2990: return(STATUS_SUCCESS);
2991: }
2992:
2993: NTSTATUS
2994: MouEnableDisablePort(
2995: IN PDEVICE_OBJECT DeviceObject,
2996: IN BOOLEAN EnableFlag,
2997: IN ULONG PortIndex
2998: )
2999:
3000: /*++
3001:
3002: Routine Description:
3003:
3004: This routine sends an enable or a disable request to the port driver.
3005:
3006: Arguments:
3007:
3008: DeviceObject - Pointer to class device object.
3009:
3010: EnableFlag - If TRUE, send an ENABLE request; otherwise, send DISABLE.
3011:
3012: PortIndex - Index into the PortDeviceObjectList[] for the current
3013: enable/disable request.
3014:
3015: Return Value:
3016:
3017: Status is returned.
3018:
3019: --*/
3020:
3021: {
3022: PIRP irp;
3023: IO_STATUS_BLOCK ioStatus;
3024: NTSTATUS status;
3025: KEVENT event;
3026: PDEVICE_EXTENSION deviceExtension;
3027:
3028: MouPrint((2,"MOUCLASS-MouEnableDisablePort: enter\n"));
3029:
3030: //
3031: // Get a pointer to the device extension.
3032: //
3033:
3034: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
3035:
3036: //
3037: // Create notification event object to be used to signal the
3038: // request completion.
3039: //
3040:
3041: KeInitializeEvent(&event, NotificationEvent, FALSE);
3042:
3043: //
3044: // Build the synchronous request to be sent to the port driver
3045: // to perform the request. Allocate an IRP to issue the port internal
3046: // device control Enable/Disable call.
3047: //
3048:
3049: irp = IoBuildDeviceIoControlRequest(
3050: EnableFlag? IOCTL_INTERNAL_MOUSE_ENABLE:
3051: IOCTL_INTERNAL_MOUSE_DISABLE,
3052: deviceExtension->PortDeviceObjectList[PortIndex],
3053: NULL,
3054: 0,
3055: NULL,
3056: 0,
3057: TRUE,
3058: &event,
3059: &ioStatus
3060: );
3061:
3062: //
3063: // Call the port driver to perform the operation. If the returned status
3064: // is PENDING, wait for the request to complete.
3065: //
3066:
3067: status = IoCallDriver(
3068: deviceExtension->PortDeviceObjectList[PortIndex],
3069: irp
3070: );
3071:
3072: if (status == STATUS_PENDING) {
3073: (VOID) KeWaitForSingleObject(
3074: &event,
3075: Suspended,
3076: KernelMode,
3077: FALSE,
3078: NULL
3079: );
3080: } else {
3081:
3082: //
3083: // Ensure that the proper status value gets picked up.
3084: //
3085:
3086: ioStatus.Status = status;
3087: }
3088:
3089: MouPrint((2,"MOUCLASS-MouEnableDisablePort: exit\n"));
3090:
3091: return(ioStatus.Status);
3092:
3093: }
3094:
3095: VOID
3096: MouInitializeDataQueue (
3097: IN PVOID Context
3098: )
3099:
3100: /*++
3101:
3102: Routine Description:
3103:
3104: This routine initializes the input data queue. IRQL is raised to
3105: DISPATCH_LEVEL to synchronize with StartIo, and the device object
3106: spinlock is acquired.
3107:
3108: Arguments:
3109:
3110: Context - Supplies a pointer to the device extension.
3111:
3112: Return Value:
3113:
3114: None.
3115:
3116: --*/
3117:
3118: {
3119:
3120: KIRQL oldIrql;
3121: PDEVICE_EXTENSION deviceExtension;
3122:
3123: MouPrint((3,"MOUCLASS-MouInitializeDataQueue: enter\n"));
3124:
3125: //
3126: // Get address of device extension.
3127: //
3128:
3129: deviceExtension = (PDEVICE_EXTENSION)Context;
3130:
3131: //
3132: // Acquire the spinlock to protect the input data
3133: // queue and associated pointers.
3134: //
3135:
3136: KeAcquireSpinLock(&deviceExtension->SpinLock, &oldIrql);
3137:
3138: //
3139: // Initialize the input data queue.
3140: //
3141:
3142: deviceExtension->InputCount = 0;
3143: deviceExtension->DataIn = deviceExtension->InputData;
3144: deviceExtension->DataOut = deviceExtension->InputData;
3145:
3146: deviceExtension->OkayToLogOverflow = TRUE;
3147:
3148: //
3149: // Release the spinlock and return to the old IRQL.
3150: //
3151:
3152: KeReleaseSpinLock(&deviceExtension->SpinLock, oldIrql);
3153:
3154: MouPrint((3,"MOUCLASS-MouInitializeDataQueue: exit\n"));
3155:
3156: } // end MouInitializeDataQueue
3157:
3158: NTSTATUS
3159: MouSendConnectRequest(
3160: IN PDEVICE_OBJECT DeviceObject,
3161: IN PVOID ServiceCallback,
3162: IN ULONG PortIndex
3163: )
3164:
3165: /*++
3166:
3167: Routine Description:
3168:
3169: This routine sends a connect request to the port driver.
3170:
3171: Arguments:
3172:
3173: DeviceObject - Pointer to class device object.
3174:
3175: ServiceCallback - Pointer to the class service callback routine.
3176:
3177: PortIndex - The index into the PortDeviceObjectList[] for the current
3178: connect request.
3179:
3180: Return Value:
3181:
3182: Status is returned.
3183:
3184: --*/
3185:
3186: {
3187: PIRP irp;
3188: IO_STATUS_BLOCK ioStatus;
3189: NTSTATUS status;
3190: KEVENT event;
3191: PDEVICE_EXTENSION deviceExtension;
3192: CONNECT_DATA connectData;
3193:
3194: MouPrint((2,"MOUCLASS-MouSendConnectRequest: enter\n"));
3195:
3196: //
3197: // Get a pointer to the device extension.
3198: //
3199:
3200: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
3201:
3202: //
3203: // Create notification event object to be used to signal the
3204: // request completion.
3205: //
3206:
3207: KeInitializeEvent(&event, NotificationEvent, FALSE);
3208:
3209: //
3210: // Build the synchronous request to be sent to the port driver
3211: // to perform the request. Allocate an IRP to issue the port internal
3212: // device control connect call. The connect parameters are passed in
3213: // the input buffer.
3214: //
3215:
3216: connectData.ClassDeviceObject = DeviceObject;
3217: connectData.ClassService = ServiceCallback;
3218:
3219: irp = IoBuildDeviceIoControlRequest(
3220: IOCTL_INTERNAL_MOUSE_CONNECT,
3221: deviceExtension->PortDeviceObjectList[PortIndex],
3222: &connectData,
3223: sizeof(CONNECT_DATA),
3224: NULL,
3225: 0,
3226: TRUE,
3227: &event,
3228: &ioStatus
3229: );
3230:
3231: //
3232: // Call the port driver to perform the operation. If the returned status
3233: // is PENDING, wait for the request to complete.
3234: //
3235:
3236: status = IoCallDriver(
3237: deviceExtension->PortDeviceObjectList[PortIndex],
3238: irp
3239: );
3240:
3241: if (status == STATUS_PENDING) {
3242: (VOID) KeWaitForSingleObject(
3243: &event,
3244: Suspended,
3245: KernelMode,
3246: FALSE,
3247: NULL
3248: );
3249: } else {
3250:
3251: //
3252: // Ensure that the proper status value gets picked up.
3253: //
3254:
3255: ioStatus.Status = status;
3256: }
3257:
3258: MouPrint((2,"MOUCLASS-MouSendConnectRequest: exit\n"));
3259:
3260: return(ioStatus.Status);
3261:
3262: } // end MouSendConnectRequest()
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.