![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sermcmn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / input / sermouse|
Return to sermcmn.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / input / sermouse |
1.1 root 1: /*++
2:
3: Copyright (c) 1990, 1991, 1992, 1993 Microsoft Corporation
4: Copyright (c) 1993 Logitech Inc.
5:
6: Module Name:
7:
8: sermcmn.c
9:
10: Abstract:
11:
12: The common portions of the Microsoft serial (i8250) mouse port driver.
13: This file should not require modification to support new mice
14: that are similar to the serial mouse.
15:
16: Environment:
17:
18: Kernel mode only.
19:
20: Notes:
21:
22: NOTES: (Future/outstanding issues)
23:
24: - Powerfail not implemented.
25:
26: - IOCTL_INTERNAL_MOUSE_DISCONNECT has not been implemented. It's not
27: needed until the class unload routine is implemented. Right now,
28: we don't want to allow the mouse class driver to unload.
29:
30: - Consolidate duplicate code, where possible and appropriate.
31:
32: Revision History:
33:
34:
35: --*/
36:
37: #include "stdarg.h"
38: #include "stdio.h"
39: #include "string.h"
40: #include "ntddk.h"
41: #include "sermouse.h"
42: #include "sermlog.h"
43: #include "debug.h"
44:
45:
46: VOID
47: SerialMouseErrorLogDpc(
48: IN PKDPC Dpc,
49: IN PDEVICE_OBJECT DeviceObject,
50: IN PIRP Irp,
51: IN PVOID Context
52: )
53:
54: /*++
55:
56: Routine Description:
57:
58: This routine runs at DISPATCH_LEVEL IRQL to log errors that are
59: discovered at IRQL > DISPATCH_LEVEL (e.g., in the ISR routine or
60: in a routine that is executed via KeSynchronizeExecution). There
61: is not necessarily a current request associated with this condition.
62:
63: Arguments:
64:
65: Dpc - Pointer to the DPC object.
66:
67: DeviceObject - Pointer to the device object.
68:
69: Irp - Not used.
70:
71: Context - Indicates type of error to log.
72:
73: Return Value:
74:
75: None.
76:
77: --*/
78:
79: {
80: PDEVICE_EXTENSION deviceExtension;
81: PIO_ERROR_LOG_PACKET errorLogEntry;
82:
83: UNREFERENCED_PARAMETER(Dpc);
84: UNREFERENCED_PARAMETER(Irp);
85:
86: SerMouPrint((2, "SERMOUSE-SerialMouseErrorLogDpc: enter\n"));
87:
88: deviceExtension = DeviceObject->DeviceExtension;
89:
90: //
91: // Log an error packet.
92: //
93:
94: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
95: DeviceObject,
96: sizeof(IO_ERROR_LOG_PACKET)
97: + (2 * sizeof(ULONG))
98: );
99: if (errorLogEntry != NULL) {
100:
101: errorLogEntry->DumpDataSize = 2 * sizeof(ULONG);
102:
103: if ((ULONG) Context == SERMOUSE_MOU_BUFFER_OVERFLOW) {
104: errorLogEntry->UniqueErrorValue = SERIAL_MOUSE_ERROR_VALUE_BASE + 210;
105: errorLogEntry->DumpData[0] = sizeof(MOUSE_INPUT_DATA);
106: errorLogEntry->DumpData[1] =
107: deviceExtension->Configuration.MouseAttributes.InputDataQueueLength;
108: } else {
109: errorLogEntry->UniqueErrorValue = SERIAL_MOUSE_ERROR_VALUE_BASE + 220;
110: errorLogEntry->DumpData[0] = 0;
111: errorLogEntry->DumpData[1] = 0;
112: }
113:
114: errorLogEntry->ErrorCode = (ULONG) Context;
115: errorLogEntry->SequenceNumber = 0;
116: errorLogEntry->MajorFunctionCode = 0;
117: errorLogEntry->IoControlCode = 0;
118: errorLogEntry->RetryCount = 0;
119: errorLogEntry->FinalStatus = 0;
120:
121: IoWriteErrorLogEntry(errorLogEntry);
122: }
123:
124: SerMouPrint((2, "SERMOUSE-SerialMouseErrorLogDpc: exit\n"));
125:
126: }
127:
128: NTSTATUS
129: SerialMouseFlush(
130: IN PDEVICE_OBJECT DeviceObject,
131: IN PIRP Irp
132: )
133: {
134: UNREFERENCED_PARAMETER(DeviceObject);
135: UNREFERENCED_PARAMETER(Irp);
136:
137: SerMouPrint((2,"SERMOUSE-SerialMouseFlush: enter\n"));
138: SerMouPrint((2,"SERMOUSE-SerialMouseFlush: exit\n"));
139:
140: return(STATUS_NOT_IMPLEMENTED);
141: }
142:
143: NTSTATUS
144: SerialMouseInternalDeviceControl(
145: IN PDEVICE_OBJECT DeviceObject,
146: IN PIRP Irp
147: )
148:
149: /*++
150:
151: Routine Description:
152:
153: This routine is the dispatch routine for internal device control requests.
154:
155: Arguments:
156:
157: DeviceObject - Pointer to the device object.
158:
159: Irp - Pointer to the request packet.
160:
161: Return Value:
162:
163: Status is returned.
164:
165: --*/
166:
167: {
168:
169: PIO_STACK_LOCATION irpSp;
170: PDEVICE_EXTENSION deviceExtension;
171: NTSTATUS status;
172:
173: SerMouPrint((2,"SERMOUSE-SerialMouseInternalDeviceControl: enter\n"));
174:
175: //
176: // Get a pointer to the device extension.
177: //
178:
179: deviceExtension = DeviceObject->DeviceExtension;
180:
181: //
182: // Initialize the returned Information field.
183: //
184:
185: Irp->IoStatus.Information = 0;
186:
187: //
188: // Get a pointer to the current parameters for this request. The
189: // information is contained in the current stack location.
190: //
191:
192: irpSp = IoGetCurrentIrpStackLocation(Irp);
193:
194: //
195: // Case on the device control subfunction that is being performed by the
196: // requestor.
197: //
198:
199: switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {
200:
201: //
202: // Connect a mouse class device driver to the port driver.
203: //
204:
205: case IOCTL_INTERNAL_MOUSE_CONNECT:
206:
207: SerMouPrint((
208: 2,
209: "SERMOUSE-SerialMouseInternalDeviceControl: mouse connect\n"
210: ));
211:
212: //
213: // Only allow one connection.
214: //
215: // FUTURE: Consider allowing multiple connections, just for
216: // the sake of generality?
217: //
218:
219: if (deviceExtension->ConnectData.ClassService
220: != NULL) {
221:
222: SerMouPrint((
223: 2,
224: "SERMOUSE-SerialMouseInternalDeviceControl: error - already connected\n"
225: ));
226:
227: status = STATUS_SHARING_VIOLATION;
228: break;
229:
230: } else
231: if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
232: sizeof(CONNECT_DATA)) {
233:
234: SerMouPrint((
235: 2,
236: "SERMOUSE-SerialMouseInternalDeviceControl: error - invalid buffer length\n"
237: ));
238:
239: status = STATUS_INVALID_PARAMETER;
240: break;
241: }
242:
243: //
244: // Copy the connection parameters to the device extension.
245: //
246:
247: deviceExtension->ConnectData =
248: *((PCONNECT_DATA) (irpSp->Parameters.DeviceIoControl.Type3InputBuffer));
249:
250: //
251: // Reinitialize the port input data queue synchronously.
252: //
253:
254: KeSynchronizeExecution(
255: deviceExtension->InterruptObject,
256: (PKSYNCHRONIZE_ROUTINE) SerMouInitializeDataQueue,
257: (PVOID) deviceExtension
258: );
259:
260: //
261: // Set the completion status.
262: //
263:
264: status = STATUS_SUCCESS;
265: break;
266:
267: //
268: // Disconnect a mouse class device driver from the port driver.
269: //
270: // NOTE: Not implemented.
271: //
272:
273: case IOCTL_INTERNAL_MOUSE_DISCONNECT:
274:
275: SerMouPrint((
276: 2,
277: "SERMOUSE-SerialMouseInternalDeviceControl: mouse disconnect\n"
278: ));
279:
280: //
281: // Perform a mouse interrupt disable call.
282: //
283:
284: //
285: // Clear the connection parameters in the device extension.
286: // NOTE: Must synchronize this with the mouse ISR.
287: //
288: //
289: //deviceExtension->ConnectData.ClassDeviceObject =
290: // Null;
291: //deviceExtension->ConnectData.ClassService =
292: // Null;
293:
294: //
295: // Set the completion status.
296: //
297:
298: status = STATUS_NOT_IMPLEMENTED;
299: break;
300:
301: //
302: // Enable mouse interrupts (mark the request pending and handle
303: // it in StartIo).
304: //
305:
306: case IOCTL_INTERNAL_MOUSE_ENABLE:
307:
308: SerMouPrint((
309: 2,
310: "SERMOUSE-SerialMouseInternalDeviceControl: mouse enable\n"
311: ));
312:
313: status = STATUS_PENDING;
314: break;
315:
316: //
317: // Disable mouse interrupts (mark the request pending and handle
318: // it in StartIo).
319: //
320:
321: case IOCTL_INTERNAL_MOUSE_DISABLE:
322:
323: SerMouPrint((
324: 2,
325: "SERMOUSE-SerialMouseInternalDeviceControl: mouse disable\n"
326: ));
327:
328: status = STATUS_PENDING;
329: break;
330:
331: //
332: // Query the mouse attributes. First check for adequate buffer
333: // length. Then, copy the mouse attributes from the device
334: // extension to the output buffer.
335: //
336:
337: case IOCTL_MOUSE_QUERY_ATTRIBUTES:
338:
339: SerMouPrint((
340: 2,
341: "SERMOUSE-SerialMouseInternalDeviceControl: mouse query attributes\n"
342: ));
343:
344: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
345: sizeof(MOUSE_ATTRIBUTES)) {
346: status = STATUS_BUFFER_TOO_SMALL;
347: } else {
348:
349: //
350: // Copy the attributes from the DeviceExtension to the
351: // buffer.
352: //
353:
354: *(PMOUSE_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer =
355: deviceExtension->Configuration.MouseAttributes;
356:
357: Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
358: status = STATUS_SUCCESS;
359: }
360:
361: break;
362:
363: default:
364:
365: SerMouPrint((
366: 2,
367: "SERMOUSE-SerialMouseInternalDeviceControl: INVALID REQUEST\n"
368: ));
369:
370: status = STATUS_INVALID_DEVICE_REQUEST;
371: break;
372: }
373:
374: Irp->IoStatus.Status = status;
375: if (status == STATUS_PENDING) {
376: IoMarkIrpPending(Irp);
377: IoStartPacket(DeviceObject, Irp, (PULONG)NULL, NULL);
378: } else {
379: IoCompleteRequest(Irp, IO_NO_INCREMENT);
380: }
381:
382: SerMouPrint((2,"SERMOUSE-SerialMouseInternalDeviceControl: exit\n"));
383:
384: return(status);
385:
386: }
387:
388: BOOLEAN
389: SerialMouseInterruptService(
390: IN PKINTERRUPT Interrupt,
391: IN PVOID Context
392: )
393:
394: /*++
395:
396: Routine Description:
397:
398: This is the interrupt service routine for the mouse device.
399:
400: Arguments:
401:
402: Interrupt - A pointer to the interrupt object for this interrupt.
403:
404: Context - A pointer to the device object.
405:
406: Return Value:
407:
408: Returns TRUE if the interrupt was expected (and therefore processed);
409: otherwise, FALSE is returned.
410:
411: --*/
412:
413: {
414: PDEVICE_EXTENSION deviceExtension;
415: PDEVICE_OBJECT deviceObject;
416: PMOUSE_INPUT_DATA currentInput;
417: PUCHAR port;
418: UCHAR value;
419: UCHAR lineState;
420: ULONG buttonsDelta;
421:
422: UNREFERENCED_PARAMETER(Interrupt);
423:
424: SerMouPrint((2, "SERMOUSE-SerialMouseInterruptService: enter\n"));
425:
426: //
427: // Get the device extension.
428: //
429:
430: deviceObject = (PDEVICE_OBJECT) Context;
431: deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
432:
433: //
434: // Get the serial mouse port address.
435: //
436:
437: port = deviceExtension->Configuration.DeviceRegisters[0];
438:
439: //
440: // Verify that the interrupt really belongs to this driver.
441: //
442:
443: if ((READ_PORT_UCHAR((PUCHAR) (port + ACE_IIDR)) & ACE_IIP) == ACE_IIP) {
444:
445: //
446: // Not our interrupt.
447: //
448:
449: SerMouPrint((
450: 2,
451: "SERMOUSE-SerialMouseInterruptService: not our interrupt\n"
452: ));
453: return(FALSE);
454: }
455:
456: //
457: // Get the line state byte. This value can be checked by the
458: // protocol handler for errors.
459: //
460:
461: lineState = READ_PORT_UCHAR((PUCHAR) (port + ACE_LSR));
462: SerMouPrint((
463: 2,
464: "SERMOUSE-Line status: 0x%x\n", lineState
465: ));
466:
467: //
468: // Read the byte from the serial mouse port. If the mouse has not
469: // been enabled, don't process the byte further.
470: //
471:
472: value = READ_PORT_UCHAR((PUCHAR) port + ACE_RBR);
473:
474: SerMouPrint((
475: 2,
476: "SERMOUSE-SerialMouseInterruptService: byte 0x%x\n", value
477: ));
478:
479: if (deviceExtension->MouseEnableCount == 0) {
480: SerMouPrint((
481: 2,
482: "SERMOUSE-SerialMouseInterruptService: not enabled\n"
483: ));
484: return(TRUE);
485: }
486:
487: //
488: // At this point, the protocol handler should already be set because
489: // the hardware is enabled.
490: //
491:
492: ASSERT(deviceExtension->ProtocolHandler);
493:
494: currentInput = &deviceExtension->CurrentInput;
495:
496: //
497: // Call the current protocol handler for this device
498: //
499:
500: if ((*deviceExtension->ProtocolHandler)(
501: currentInput,
502: &deviceExtension->HandlerData,
503: value,
504: lineState
505: )){
506:
507: //
508: // The report is complete, compute the button deltas and queue it.
509: //
510:
511: currentInput->UnitId = deviceExtension->UnitId;
512: currentInput->Buttons = 0;
513:
514: //
515: // Do we have a button state change?
516: //
517:
518: if (deviceExtension->HandlerData.PreviousButtons ^ currentInput->RawButtons) {
519:
520:
521: //
522: // The state of the buttons changed. Make some calculations...
523: //
524:
525: buttonsDelta = deviceExtension->HandlerData.PreviousButtons ^
526: currentInput->RawButtons;
527:
528: //
529: // Button 1.
530: //
531:
532: if (buttonsDelta & MOUSE_BUTTON_1) {
533: if (currentInput->RawButtons & MOUSE_BUTTON_1) {
534: currentInput->Buttons |= MOUSE_BUTTON_1_DOWN;
535: }
536: else {
537: currentInput->Buttons |= MOUSE_BUTTON_1_UP;
538: }
539: }
540:
541: //
542: // Button 2.
543: //
544:
545: if (buttonsDelta & MOUSE_BUTTON_2) {
546: if (currentInput->RawButtons & MOUSE_BUTTON_2) {
547: currentInput->Buttons |= MOUSE_BUTTON_2_DOWN;
548: }
549: else {
550: currentInput->Buttons |= MOUSE_BUTTON_2_UP;
551: }
552: }
553:
554: //
555: // Button 3.
556: //
557:
558: if (buttonsDelta & MOUSE_BUTTON_3) {
559: if (currentInput->RawButtons & MOUSE_BUTTON_3) {
560: currentInput->Buttons |= MOUSE_BUTTON_3_DOWN;
561: }
562: else {
563: currentInput->Buttons |= MOUSE_BUTTON_3_UP;
564: }
565: }
566:
567: deviceExtension->HandlerData.PreviousButtons =
568: currentInput->RawButtons;
569:
570: }
571:
572: SerMouPrint((1, "SERMOUSE-Buttons: %0lx\n", currentInput->Buttons));
573:
574: SerMouSendReport(deviceObject);
575: }
576:
577: SerMouPrint((2, "SERMOUSE-SerialMouseInterruptService: exit\n"));
578:
579: return TRUE;
580: }
581:
582: VOID
583: SerialMouseIsrDpc(
584: IN PKDPC Dpc,
585: IN PDEVICE_OBJECT DeviceObject,
586: IN PIRP Irp,
587: IN PVOID Context
588: )
589:
590: /*++
591:
592: Routine Description:
593:
594: This routine runs at DISPATCH_LEVEL IRQL to finish processing
595: mouse interrupts. It is queued in the mouse ISR. The real
596: work is done via a callback to the connected mouse class driver.
597:
598: Arguments:
599:
600: Dpc - Pointer to the DPC object.
601:
602: DeviceObject - Pointer to the device object.
603:
604: Irp - Pointer to the Irp.
605:
606: Context - Not used.
607:
608: Return Value:
609:
610: None.
611:
612: --*/
613:
614: {
615:
616: PDEVICE_EXTENSION deviceExtension;
617: GET_DATA_POINTER_CONTEXT getPointerContext;
618: SET_DATA_POINTER_CONTEXT setPointerContext;
619: VARIABLE_OPERATION_CONTEXT operationContext;
620: PVOID classService;
621: PVOID classDeviceObject;
622: LONG interlockedResult;
623: BOOLEAN moreDpcProcessing;
624: ULONG dataNotConsumed = 0;
625: ULONG inputDataConsumed = 0;
626: LARGE_INTEGER deltaTime;
627:
628: UNREFERENCED_PARAMETER(Dpc);
629: UNREFERENCED_PARAMETER(Irp);
630: UNREFERENCED_PARAMETER(Context);
631:
632: SerMouPrint((2, "SERMOUSE-SerialMouseIsrDpc: enter\n"));
633:
634: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
635:
636: //
637: // Use DpcInterlockVariable to determine whether the DPC is running
638: // concurrently on another processor. We only want one instantiation
639: // of the DPC to actually do any work. DpcInterlockVariable is -1
640: // when no DPC is executing. We increment it, and if the result is
641: // zero then the current instantiation is the only one executing, and it
642: // is okay to proceed. Otherwise, we just return.
643: //
644: //
645:
646: operationContext.VariableAddress =
647: &deviceExtension->DpcInterlockVariable;
648: operationContext.Operation = IncrementOperation;
649: operationContext.NewValue = &interlockedResult;
650:
651: KeSynchronizeExecution(
652: deviceExtension->InterruptObject,
653: (PKSYNCHRONIZE_ROUTINE) SerMouDpcVariableOperation,
654: (PVOID) &operationContext
655: );
656:
657: moreDpcProcessing = (interlockedResult == 0)? TRUE:FALSE;
658:
659: while (moreDpcProcessing) {
660:
661: dataNotConsumed = 0;
662: inputDataConsumed = 0;
663:
664: //
665: // Get the port InputData queue pointers synchronously.
666: //
667:
668: getPointerContext.DeviceExtension = deviceExtension;
669: setPointerContext.DeviceExtension = deviceExtension;
670: setPointerContext.InputCount = 0;
671:
672: KeSynchronizeExecution(
673: deviceExtension->InterruptObject,
674: (PKSYNCHRONIZE_ROUTINE) SerMouGetDataQueuePointer,
675: (PVOID) &getPointerContext
676: );
677:
678: if (getPointerContext.InputCount != 0) {
679:
680: //
681: // Call the connected class driver's callback ISR with the
682: // port InputData queue pointers. If we have to wrap the queue,
683: // break the operation into two pieces, and call the class callback
684: // ISR once for each piece.
685: //
686:
687: classDeviceObject =
688: deviceExtension->ConnectData.ClassDeviceObject;
689: classService =
690: deviceExtension->ConnectData.ClassService;
691: ASSERT(classService != NULL);
692:
693: if (getPointerContext.DataOut >= getPointerContext.DataIn) {
694:
695: //
696: // We'll have to wrap the InputData circular buffer. Call
697: // the class callback ISR with the chunk of data starting at
698: // DataOut and ending at the end of the queue.
699: //
700:
701: SerMouPrint((
702: 2,
703: "SERMOUSE-SerialMouseIsrDpc: calling class callback\n"
704: ));
705: SerMouPrint((
706: 2,
707: "SERMOUSE-SerialMouseIsrDpc: with Start 0x%x and End 0x%x\n",
708: getPointerContext.DataOut,
709: deviceExtension->DataEnd
710: ));
711:
712: (*(PSERVICE_CALLBACK_ROUTINE) classService)(
713: classDeviceObject,
714: getPointerContext.DataOut,
715: deviceExtension->DataEnd,
716: &inputDataConsumed
717: );
718:
719: dataNotConsumed = (((PUCHAR)
720: deviceExtension->DataEnd -
721: (PUCHAR) getPointerContext.DataOut)
722: / sizeof(MOUSE_INPUT_DATA)) - inputDataConsumed;
723:
724: SerMouPrint((
725: 2,
726: "SERMOUSE-SerialMouseIsrDpc: (Wrap) Call callback consumed %d items, left %d\n",
727: inputDataConsumed,
728: dataNotConsumed
729: ));
730:
731: setPointerContext.InputCount += inputDataConsumed;
732:
733: if (dataNotConsumed) {
734: setPointerContext.DataOut =
735: ((PUCHAR)getPointerContext.DataOut) +
736: (inputDataConsumed * sizeof(MOUSE_INPUT_DATA));
737: } else {
738: setPointerContext.DataOut =
739: deviceExtension->InputData;
740: getPointerContext.DataOut = setPointerContext.DataOut;
741: }
742: }
743:
744: //
745: // Call the class callback ISR with data remaining in the queue.
746: //
747:
748: if ((dataNotConsumed == 0) &&
749: (inputDataConsumed < getPointerContext.InputCount)){
750: SerMouPrint((
751: 2,
752: "SERMOUSE-SerialMouseIsrDpc: calling class callback\n"
753: ));
754: SerMouPrint((
755: 2,
756: "SERMOUSE-SerialMouseIsrDpc: with Start 0x%x and End 0x%x\n",
757: getPointerContext.DataOut,
758: getPointerContext.DataIn
759: ));
760:
761: (*(PSERVICE_CALLBACK_ROUTINE) classService)(
762: classDeviceObject,
763: getPointerContext.DataOut,
764: getPointerContext.DataIn,
765: &inputDataConsumed
766: );
767:
768: dataNotConsumed = (((PUCHAR) getPointerContext.DataIn -
769: (PUCHAR) getPointerContext.DataOut)
770: / sizeof(MOUSE_INPUT_DATA)) - inputDataConsumed;
771:
772: SerMouPrint((
773: 2,
774: "SERMOUSE-SerialMouseIsrDpc: Call callback consumed %d items, left %d\n",
775: inputDataConsumed,
776: dataNotConsumed
777: ));
778:
779: setPointerContext.DataOut =
780: ((PUCHAR)getPointerContext.DataOut) +
781: (inputDataConsumed * sizeof(MOUSE_INPUT_DATA));
782: setPointerContext.InputCount += inputDataConsumed;
783:
784: }
785:
786: //
787: // Update the port InputData queue DataOut pointer and InputCount
788: // synchronously.
789: //
790:
791: KeSynchronizeExecution(
792: deviceExtension->InterruptObject,
793: (PKSYNCHRONIZE_ROUTINE) SerMouSetDataQueuePointer,
794: (PVOID) &setPointerContext
795: );
796:
797: }
798:
799: if (dataNotConsumed) {
800:
801: //
802: // The class driver was unable to consume all the data.
803: // Reset the interlocked variable to -1. We do not want
804: // to attempt to move more data to the class driver at this
805: // point, because it is already overloaded. Need to wait a
806: // while to give the Raw Input Thread a chance to read some
807: // of the data out of the class driver's queue. We accomplish
808: // this "wait" via a timer.
809: //
810:
811: SerMouPrint((2, "SERMOUSE-SerialMouseIsrDpc: set timer in DPC\n"));
812:
813: operationContext.Operation = WriteOperation;
814: interlockedResult = -1;
815: operationContext.NewValue = &interlockedResult;
816:
817: KeSynchronizeExecution(
818: deviceExtension->InterruptObject,
819: (PKSYNCHRONIZE_ROUTINE) SerMouDpcVariableOperation,
820: (PVOID) &operationContext
821: );
822:
823: deltaTime.LowPart = (ULONG)(-10 * 1000 * 1000);
824: deltaTime.HighPart = -1;
825:
826: (VOID) KeSetTimer(
827: &deviceExtension->DataConsumptionTimer,
828: deltaTime,
829: &deviceExtension->IsrDpcRetry
830: );
831:
832: moreDpcProcessing = FALSE;
833:
834: } else {
835:
836: //
837: // Decrement DpcInterlockVariable. If the result goes negative,
838: // then we're all finished processing the DPC. Otherwise, either
839: // the ISR incremented DpcInterlockVariable because it has more
840: // work for the ISR DPC to do, or a concurrent DPC executed on
841: // some processor while the current DPC was running (the
842: // concurrent DPC wouldn't have done any work). Make sure that
843: // the current DPC handles any extra work that is ready to be
844: // done.
845: //
846:
847: operationContext.Operation = DecrementOperation;
848: operationContext.NewValue = &interlockedResult;
849:
850: KeSynchronizeExecution(
851: deviceExtension->InterruptObject,
852: (PKSYNCHRONIZE_ROUTINE) SerMouDpcVariableOperation,
853: (PVOID) &operationContext
854: );
855:
856: if (interlockedResult != -1) {
857:
858: //
859: // The interlocked variable is still greater than or equal to
860: // zero. Reset it to zero, so that we execute the loop one
861: // more time (assuming no more DPCs execute and bump the
862: // variable up again).
863: //
864:
865: operationContext.Operation = WriteOperation;
866: interlockedResult = 0;
867: operationContext.NewValue = &interlockedResult;
868:
869: KeSynchronizeExecution(
870: deviceExtension->InterruptObject,
871: (PKSYNCHRONIZE_ROUTINE) SerMouDpcVariableOperation,
872: (PVOID) &operationContext
873: );
874:
875: SerMouPrint((2, "SERMOUSE-SerialMouseIsrDpc: loop in DPC\n"));
876: } else {
877: moreDpcProcessing = FALSE;
878: }
879: }
880: }
881:
882: SerMouPrint((2, "SERMOUSE-SerialMouseIsrDpc: exit\n"));
883:
884: }
885:
886: NTSTATUS
887: SerialMouseOpenClose(
888: IN PDEVICE_OBJECT DeviceObject,
889: IN PIRP Irp
890: )
891:
892: /*++
893:
894: Routine Description:
895:
896: This is the dispatch routine for create/open and close requests.
897: These requests complete successfully.
898:
899: Arguments:
900:
901: DeviceObject - Pointer to the device object.
902:
903: Irp - Pointer to the request packet.
904:
905: Return Value:
906:
907: Status is returned.
908:
909: --*/
910:
911: {
912:
913: UNREFERENCED_PARAMETER(DeviceObject);
914:
915: SerMouPrint((3,"SERMOUSE-SerialMouseOpenClose: enter\n"));
916:
917: //
918: // Complete the request with successful status.
919: //
920:
921: Irp->IoStatus.Status = STATUS_SUCCESS;
922: Irp->IoStatus.Information = 0;
923: IoCompleteRequest(Irp, IO_NO_INCREMENT);
924:
925: SerMouPrint((3,"SERMOUSE-SerialMouseOpenClose: exit\n"));
926:
927: return(STATUS_SUCCESS);
928:
929: } // end SerialMouseOpenClose
930:
931: VOID
932: SerialMouseStartIo(
933: IN PDEVICE_OBJECT DeviceObject,
934: IN PIRP Irp
935: )
936:
937: /*++
938:
939: Routine Description:
940:
941: This routine starts an I/O operation for the device.
942:
943: Arguments:
944:
945: DeviceObject - Pointer to the device object.
946:
947: Irp - Pointer to the request packet.
948:
949: Return Value:
950:
951: None.
952:
953: --*/
954:
955: {
956: PDEVICE_EXTENSION deviceExtension;
957: PIO_STACK_LOCATION irpSp;
958:
959: SerMouPrint((2, "SERMOUSE-SerialMouseStartIo: enter\n"));
960:
961: deviceExtension = DeviceObject->DeviceExtension;
962:
963: //
964: // Bump the error log sequence number.
965: //
966:
967: deviceExtension->SequenceNumber += 1;
968:
969: //
970: // Get a pointer to the current parameters for this request. The
971: // information is contained in the current stack location.
972: //
973:
974: irpSp = IoGetCurrentIrpStackLocation(Irp);
975:
976: //
977: // We know we got here with an internal device control request. Switch
978: // on IoControlCode.
979: //
980:
981: switch(irpSp->Parameters.DeviceIoControl.IoControlCode) {
982:
983: //
984: // Enable mouse interrupts, by calling SerMouEnableInterrupts
985: // synchronously.
986: //
987:
988: case IOCTL_INTERNAL_MOUSE_ENABLE:
989:
990: KeSynchronizeExecution(
991: deviceExtension->InterruptObject,
992: (PKSYNCHRONIZE_ROUTINE) SerMouEnableInterrupts,
993: (PVOID) deviceExtension
994: );
995:
996: SerMouPrint((
997: 2,
998: "SERMOUSE-SerialMouseStartIo: mouse enable (count %d)\n",
999: deviceExtension->MouseEnableCount
1000: ));
1001:
1002: Irp->IoStatus.Status = STATUS_SUCCESS;
1003:
1004: //
1005: // Complete the request.
1006: //
1007:
1008: IoStartNextPacket(DeviceObject, FALSE);
1009: IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
1010:
1011: break;
1012:
1013: //
1014: // Disable mouse interrupts, by calling SerMouDisableInterrupts
1015: // synchronously.
1016: //
1017:
1018: case IOCTL_INTERNAL_MOUSE_DISABLE:
1019:
1020: SerMouPrint((2, "SERMOUSE-SerialMouseStartIo: mouse disable"));
1021:
1022: if (deviceExtension->MouseEnableCount == 0) {
1023:
1024: //
1025: // Mouse already disabled.
1026: //
1027:
1028: SerMouPrint((2, " - error\n"));
1029:
1030: Irp->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
1031:
1032: } else {
1033:
1034: //
1035: // Disable mouse by calling SerMouDisableInterrupts.
1036: //
1037:
1038: KeSynchronizeExecution(
1039: deviceExtension->InterruptObject,
1040: (PKSYNCHRONIZE_ROUTINE) SerMouDisableInterrupts,
1041: (PVOID) deviceExtension
1042: );
1043:
1044: SerMouPrint((
1045: 2,
1046: " (count %d)\n",
1047: deviceExtension->MouseEnableCount
1048: ));
1049:
1050: Irp->IoStatus.Status = STATUS_SUCCESS;
1051: }
1052:
1053: //
1054: // Complete the request.
1055: //
1056:
1057: IoStartNextPacket(DeviceObject, FALSE);
1058: IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
1059:
1060: break;
1061:
1062: default:
1063:
1064: SerMouPrint((2, "SERMOUSE-SerialMouseStartIo: INVALID REQUEST\n"));
1065:
1066: //
1067: // Log an internal error. Note that we're calling the
1068: // error log DPC routine directly, rather than duplicating
1069: // code.
1070: //
1071:
1072: SerialMouseErrorLogDpc(
1073: (PKDPC) NULL,
1074: DeviceObject,
1075: Irp,
1076: (PVOID) (ULONG) SERMOUSE_INVALID_STARTIO_REQUEST
1077: );
1078:
1079:
1080: ASSERT(FALSE);
1081: break;
1082: }
1083:
1084: SerMouPrint((2, "SERMOUSE-SerialMouseStartIo: exit\n"));
1085:
1086: return;
1087: }
1088:
1089: VOID
1090: SerMouDpcVariableOperation(
1091: IN PVOID Context
1092: )
1093:
1094: /*++
1095:
1096: Routine Description:
1097:
1098: This routine is called synchronously by the ISR DPC to perform an
1099: operation on the InterlockedDpcVariable. The operations that can be
1100: performed include increment, decrement, write, and read. The ISR
1101: itself reads and writes the InterlockedDpcVariable without calling this
1102: routine.
1103:
1104: Arguments:
1105:
1106: Context - Pointer to a structure containing the address of the variable
1107: to be operated on, the operation to perform, and the address at
1108: which to copy the resulting value of the variable (the latter is also
1109: used to pass in the value to write to the variable, on a write
1110: operation).
1111:
1112: Return Value:
1113:
1114: None.
1115:
1116: --*/
1117:
1118: {
1119: PVARIABLE_OPERATION_CONTEXT operationContext = Context;
1120:
1121: SerMouPrint((3,"SERMOUSE-SerMouDpcVariableOperation: enter\n"));
1122: SerMouPrint((
1123: 3,
1124: "\tPerforming %s at 0x%x (current value 0x%x)\n",
1125: (operationContext->Operation == IncrementOperation)? "increment":
1126: (operationContext->Operation == DecrementOperation)? "decrement":
1127: (operationContext->Operation == WriteOperation)? "write":
1128: (operationContext->Operation == ReadOperation)? "read":"",
1129: operationContext->VariableAddress,
1130: *(operationContext->VariableAddress)
1131: ));
1132:
1133: //
1134: // Perform the specified operation at the specified address.
1135: //
1136:
1137: switch(operationContext->Operation) {
1138: case IncrementOperation:
1139: *(operationContext->VariableAddress) += 1;
1140: break;
1141: case DecrementOperation:
1142: *(operationContext->VariableAddress) -= 1;
1143: break;
1144: case ReadOperation:
1145: break;
1146: case WriteOperation:
1147: SerMouPrint((
1148: 3,
1149: "\tWriting 0x%x\n",
1150: *(operationContext->NewValue)
1151: ));
1152: *(operationContext->VariableAddress) =
1153: *(operationContext->NewValue);
1154: break;
1155: default:
1156: ASSERT(FALSE);
1157: break;
1158: }
1159:
1160: *(operationContext->NewValue) = *(operationContext->VariableAddress);
1161:
1162: SerMouPrint((
1163: 3,
1164: "SERMOUSE-SerMouDpcVariableOperation: exit with value 0x%x\n",
1165: *(operationContext->NewValue)
1166: ));
1167: }
1168:
1169: VOID
1170: SerMouGetDataQueuePointer(
1171: IN PVOID Context
1172: )
1173:
1174: /*++
1175:
1176: Routine Description:
1177:
1178: This routine is called synchronously to get the current DataIn and DataOut
1179: pointers for the port InputData queue.
1180:
1181: Arguments:
1182:
1183: Context - Pointer to a structure containing the device extension,
1184: address at which to store the current DataIn pointer, and the
1185: address at which to store the current DataOut pointer.
1186:
1187: Return Value:
1188:
1189: None.
1190:
1191: --*/
1192:
1193: {
1194: PDEVICE_EXTENSION deviceExtension;
1195:
1196: SerMouPrint((3,"SERMOUSE-SerMouGetDataQueuePointer: enter\n"));
1197:
1198: //
1199: // Get address of device extension.
1200: //
1201:
1202: deviceExtension = (PDEVICE_EXTENSION)
1203: ((PGET_DATA_POINTER_CONTEXT) Context)->DeviceExtension;
1204:
1205: //
1206: // Get the DataIn and DataOut pointers.
1207: //
1208:
1209: SerMouPrint((
1210: 3,
1211: "SERMOUSE-SerMouGetDataQueuePointer: DataIn 0x%x, DataOut 0x%x\n",
1212: deviceExtension->DataIn,
1213: deviceExtension->DataOut
1214: ));
1215: ((PGET_DATA_POINTER_CONTEXT) Context)->DataIn = deviceExtension->DataIn;
1216: ((PGET_DATA_POINTER_CONTEXT) Context)->DataOut = deviceExtension->DataOut;
1217: ((PGET_DATA_POINTER_CONTEXT) Context)->InputCount =
1218: deviceExtension->InputCount;
1219:
1220: SerMouPrint((3,"SERMOUSE-SerMouGetDataQueuePointer: exit\n"));
1221: }
1222:
1223: VOID
1224: SerMouInitializeDataQueue (
1225: IN PVOID Context
1226: )
1227:
1228: /*++
1229:
1230: Routine Description:
1231:
1232: This routine initializes the input data queue. It is called
1233: via KeSynchronization, except when called from the initialization routine.
1234:
1235: Arguments:
1236:
1237: Context - Pointer to the device extension.
1238:
1239: Return Value:
1240:
1241: None.
1242:
1243: --*/
1244:
1245: {
1246:
1247: PDEVICE_EXTENSION deviceExtension;
1248:
1249: SerMouPrint((3,"SERMOUSE-SerMouInitializeDataQueue: enter\n"));
1250:
1251: //
1252: // Get address of device extension.
1253: //
1254:
1255: deviceExtension = (PDEVICE_EXTENSION) Context;
1256:
1257: //
1258: // Initialize the input data queue.
1259: //
1260:
1261: deviceExtension->InputCount = 0;
1262: deviceExtension->DataIn = deviceExtension->InputData;
1263: deviceExtension->DataOut = deviceExtension->InputData;
1264:
1265: deviceExtension->OkayToLogOverflow = TRUE;
1266:
1267: SerMouPrint((3,"SERMOUSE-SerMouInitializeDataQueue: exit\n"));
1268:
1269: } // end SerMouInitializeDataQueue
1270:
1271: VOID
1272: SerMouSendReport(
1273: IN PDEVICE_OBJECT DeviceObject
1274: )
1275: /*++
1276:
1277: Routine Description:
1278:
1279: Place a completed report in the queue for subsequent processing by a DPC.
1280:
1281: Arguments:
1282:
1283: Device Object - Pointer to the device object.
1284:
1285: Return Value:
1286:
1287: None.
1288:
1289: --*/
1290:
1291: {
1292: PDEVICE_EXTENSION deviceExtension;
1293:
1294: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1295:
1296: if (!SerMouWriteDataToQueue(
1297: deviceExtension,
1298: &deviceExtension->CurrentInput
1299: )) {
1300:
1301: //
1302: // The mouse input data queue is full. Just drop the
1303: // latest input on the floor.
1304: //
1305: // Queue a DPC to log an overrun error.
1306: //
1307:
1308: SerMouPrint((
1309: 1,
1310: "SERMOUSE-SerMouSendReport: queue overflow\n"
1311: ));
1312:
1313: if (deviceExtension->OkayToLogOverflow) {
1314: KeInsertQueueDpc(
1315: &deviceExtension->ErrorLogDpc,
1316: (PIRP) NULL,
1317: (PVOID) (ULONG) SERMOUSE_MOU_BUFFER_OVERFLOW
1318: );
1319: deviceExtension->OkayToLogOverflow = FALSE;
1320: }
1321:
1322: } else if (deviceExtension->DpcInterlockVariable >= 0) {
1323:
1324: //
1325: // The ISR DPC is already executing. Tell the ISR DPC it has
1326: // more work to do by incrementing the DpcInterlockVariable.
1327: //
1328:
1329: deviceExtension->DpcInterlockVariable += 1;
1330:
1331: } else {
1332:
1333: //
1334: // Queue the ISR DPC.
1335: //
1336:
1337: KeInsertQueueDpc(
1338: &deviceExtension->IsrDpc,
1339: DeviceObject->CurrentIrp,
1340: NULL
1341: );
1342:
1343: }
1344:
1345: return;
1346: }
1347:
1348: VOID
1349: SerMouSetDataQueuePointer(
1350: IN PVOID Context
1351: )
1352:
1353: /*++
1354:
1355: Routine Description:
1356:
1357: This routine is called synchronously to set the DataOut pointer
1358: and InputCount for the port InputData queue.
1359:
1360: Arguments:
1361:
1362: Context - Pointer to a structure containing the device extension
1363: and the new DataOut value for the port InputData queue.
1364:
1365: Return Value:
1366:
1367: None.
1368:
1369: --*/
1370:
1371: {
1372: PDEVICE_EXTENSION deviceExtension;
1373:
1374: SerMouPrint((3,"SERMOUSE-SerMouSetDataQueuePointer: enter\n"));
1375:
1376: //
1377: // Get address of device extension.
1378: //
1379:
1380: deviceExtension = (PDEVICE_EXTENSION)
1381: ((PSET_DATA_POINTER_CONTEXT) Context)->DeviceExtension;
1382:
1383: //
1384: // Set the DataOut pointer.
1385: //
1386:
1387: SerMouPrint((
1388: 3,
1389: "SERMOUSE-SerMouSetDataQueuePointer: old mouse DataOut 0x%x, InputCount %d\n",
1390: deviceExtension->DataOut,
1391: deviceExtension->InputCount
1392: ));
1393: deviceExtension->DataOut = ((PSET_DATA_POINTER_CONTEXT) Context)->DataOut;
1394: deviceExtension->InputCount -=
1395: ((PSET_DATA_POINTER_CONTEXT) Context)->InputCount;
1396:
1397: if (deviceExtension->InputCount == 0) {
1398:
1399: //
1400: // Reset the flag that determines whether it is time to log
1401: // queue overflow errors. We don't want to log errors too often.
1402: // Instead, log an error on the first overflow that occurs after
1403: // the ring buffer has been emptied, and then stop logging errors
1404: // until it gets cleared out and overflows again.
1405: //
1406:
1407: SerMouPrint((
1408: 1,
1409: "SERMOUSE-SerMouSetDataQueuePointer: Okay to log overflow\n"
1410: ));
1411: deviceExtension->OkayToLogOverflow = TRUE;
1412: }
1413:
1414: SerMouPrint((
1415: 3,
1416: "SERMOUSE-SerMouSetDataQueuePointer: new mouse DataOut 0x%x, InputCount %d\n",
1417: deviceExtension->DataOut,
1418: deviceExtension->InputCount
1419: ));
1420:
1421: SerMouPrint((3,"SERMOUSE-SerMouSetDataQueuePointer: exit\n"));
1422: }
1423:
1424: BOOLEAN
1425: SerMouWriteDataToQueue(
1426: PDEVICE_EXTENSION DeviceExtension,
1427: IN PMOUSE_INPUT_DATA InputData
1428: )
1429:
1430: /*++
1431:
1432: Routine Description:
1433:
1434: This routine adds input data from the mouse to the InputData queue.
1435:
1436: Arguments:
1437:
1438: DeviceExtension - Pointer to the device extension.
1439:
1440: InputData - Pointer to the data to add to the InputData queue.
1441:
1442: Return Value:
1443:
1444: Returns TRUE if the data was added, otherwise FALSE.
1445:
1446: --*/
1447:
1448: {
1449:
1450: SerMouPrint((2,"SERMOUSE-SerMouWriteDataToQueue: enter\n"));
1451: SerMouPrint((
1452: 3,
1453: "SERMOUSE-SerMouWriteDataToQueue: DataIn 0x%x, DataOut 0x%x\n",
1454: DeviceExtension->DataIn,
1455: DeviceExtension->DataOut
1456: ));
1457: SerMouPrint((
1458: 3,
1459: "SERMOUSE-SerMouWriteDataToQueue: InputCount %d\n",
1460: DeviceExtension->InputCount
1461: ));
1462:
1463: //
1464: // Check for full input data queue.
1465: //
1466:
1467: if ((DeviceExtension->DataIn == DeviceExtension->DataOut) &&
1468: (DeviceExtension->InputCount != 0)) {
1469:
1470: //
1471: // The input data queue is full. Intentionally ignore
1472: // the new data.
1473: //
1474:
1475: SerMouPrint((1,"SERMOUSE-SerMouWriteDataToQueue: OVERFLOW\n"));
1476: return(FALSE);
1477:
1478: } else {
1479: *(DeviceExtension->DataIn) = *InputData;
1480: DeviceExtension->InputCount += 1;
1481: DeviceExtension->DataIn++;
1482: SerMouPrint((
1483: 2,
1484: "SERMOUSE-SerMouWriteDataToQueue: new InputCount %d\n",
1485: DeviceExtension->InputCount
1486: ));
1487: if (DeviceExtension->DataIn ==
1488: DeviceExtension->DataEnd) {
1489: SerMouPrint((2,"SERMOUSE-SerMouWriteDataToQueue: wrap buffer\n"));
1490: DeviceExtension->DataIn = DeviceExtension->InputData;
1491: }
1492: }
1493:
1494: SerMouPrint((2,"SERMOUSE-SerMouWriteDataToQueue: exit\n"));
1495:
1496: return(TRUE);
1497: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.